SoftFingerDesign case extension application: deformation and collapse of soft parts

[Zhangsyotom]

Hello everyone! I am a new fan of SOFA. The powerful functions of this framework attract me very much.
I am trying to simulate a tendon-driven rigid-flexible hybrid robot arm. I built a model based on the code framework in SoftFingerDesign, a similar case in the SoftRobots plugin, but encountered some strange problems.
As shown in the attached figure, compared with the case, I added another degree of freedom of rotation in another direction. Using the same soft material parameters and model as the case, the movement results of the soft finger during simulation are different.
In my model, the soft finger is quickly diverged by gravity when DT=0.01. When DT=0.0001, swinging the robot arm joint will make the flexible finger bounce like toilet paper. I tried to adjust the value of Young's modulus to correct it, but the effect was small.
The same action is no problem in the case( SoftFingerDesign ).
What is the cause of this problem?
Thanks in advance.

The following is my python code for adding soft fingers

import Sofa
from elastic_material_object import ElasticMaterialObject
from stlib3.physics.mixedmaterial import Rigidify
from Arm import Arm
from stlib3.components import addOrientedBoxRoi 
from splib3.constants import Key
import math
class ActuatedManipulator(Sofa.Prefab):
    prefabParameters = [
        {"name": "rotation", "type": "Vec3d", "help": "Rotation in base frame", "default": [0.0, 0.0, 0.0]},
        {"name": "translation", "type": "Vec3d", "help": "Translation in base frame",
         "default": [0.0, 0.0, 0.0]}
    ]

    def __init__(self, *args, **kwargs):
        Sofa.Prefab.__init__(self, *args, **kwargs)

    # Construct the actuated finger
    def init(self):
        # Load the finger mesh and create an elastic body from it
        self.elasticMaterial = self.elasticBody()
        self.ElasticBody.init()

        # Load a servo motor
        arm = self.addChild(Arm(name="Arm", rotation=[0, 0, 0], translation=[0, 0, 0]))
        arm.ActuatedArm.ServoMotor.Articulation.dofs.position.value = [[arm.angleIn.value]]  # Initialize the angle
        arm.ActuatedArm.ServoMotor.minAngle.value = -3
        arm.ActuatedArm.ServoMotor.maxAngle.value = 3

        # Define a region of interest(ROI) to rigidify the nodes of the finger mesh clamped in the servo arm
        box = addOrientedBoxRoi(self,
                                name="boxROIclamped",
                                position=[list(i) for i in self.elasticMaterial.dofs.rest_position.value],
                                translation=[42.0e-3, 173.0e-3, -477.8e-3], 
                                eulerRotation=[0.0, 0.0, 0.0],
                                scale=[100e-3, 100e-3, 17e-3] 
                                )

        box.drawBoxes = True
        box.init()

        # Get the indices of the finger mesh in the ROI, and the ROI frame
        indices = [[ind for ind in box.indices.value]]
        frame = [[0, 0, 0, 0, 0, 0, 1]]

        # Rigidify the finger nodes in the ROI. Create a Rigidified object and set up a spring force
        # field to constrain the nodes to stay in the rest shape
        rigidifiedStruct = Rigidify(self, self.elasticMaterial, groupIndices=indices, frames=frame,
                                    name="RigidifiedStructure")

        servoArm = arm.ActuatedArm.ServoMotor.Articulation.ServoWheel.ServoArm.Articulation.ServoWheel.RigidArm
        servoArm.addChild(rigidifiedStruct.RigidParts)
        servoArm.RigidParts.addObject('RigidMapping', index=0, input=servoArm.dofs.getLinkPath())

    def elasticBody(self):
        # Create a body as a child of the parent (the actuated finger) 
        body = self.addChild("ElasticBody")
        # Create an ElasticMaterialObject, which import a mesh, assign it dofs  and mechanical properties
        # All the properties are expressed in SI units. The dimensions in the generated mesh are in meter,
        # the young modulus in Pascal ...
        # The manufacturer of the Filaflex 70A filament indicates a young modulus of 32MPa. The Poisson ratio is fixed
        # at 0.45 like standard elastomers (silicone, rubber)
        # The rotation and translation are adjusted so that the mesh is correctly positioned wrt the servo motor
        e = body.addChild(ElasticMaterialObject(
            volumeMeshFileName="Data/Mesh/finger.msh",
            topoMesh="tetrahedron",
            # scale=[1e-3, 1e-3, 1e-3],
            scale=[1, 1, 1],
            totalMass=0.015,
            youngModulus=32e6,
            poissonRatio=0.45,
            # rotation=[0.0, -90.0, 30.0],
            # translation=[42.0e-3, 173.0e-3, -740.8e-3]
            rotation = [-90.0, 0.0, 0.0],
            translation = [42.0e-3, 173.0e-3, -480.8e-3]
        ))

        # Add now a visual model to the flexible part
        visual = body.addChild("SoftManipulator1")
        # Load the STL file for the visualization, the rotation and translation must fit the one for the ElasticMaterialObject
        visual.addObject("MeshSTLLoader", name="visualLoader",scale = 1, filename="Data/Mesh/finger.stl",
                         rotation=[-90.0, 0.0, 0.0],
                         translation=[42.0e-3, 173.0e-3, -480.8e-3])
        visual.addObject("OglModel", name="renderer", src="@visualLoader", color=[1.0, 0.0, 0.0, 1.0])

        # Link the dofs of the 3D mesh and the visual model
        visual.addObject("BarycentricMapping", input=e.dofs.getLinkPath(), output=visual.renderer.getLinkPath())

        return e


class ArmController(Sofa.Core.Controller):

    def __init__(self, *args, **kwargs):
        # These are needed (and the normal way to override from a python class)
        Sofa.Core.Controller.__init__(self, *args, **kwargs)

        self.node = kwargs["node"]
        self.time = 0.0
        self.objectDof = kwargs["objectDof"]
        self.actuator1 = kwargs["actuator1"]
        self.actuator2 = kwargs["actuator2"]
        self.forceContact = 0.0
        self.numContact = 0
        # Computation of the contact force applied on the object to grasp
        # self.node.getRoot().GenericConstraintSolver.computeConstraintForces.value = True

    def onKeypressedEvent(self, e):
        motor1_angle = self.actuator1.angleIn.value
        motor2_angle = self.actuator2.angleIn.value
        if e["key"] == Key.uparrow:
            motor1_angle -= math.pi / 6
            if motor1_angle < - 2 * math.pi / 3:
                motor1_angle = - 2 * math.pi / 3
        elif e["key"] == Key.downarrow:
            motor1_angle += math.pi / 6
            if motor1_angle > 2 * math.pi / 3:
                motor1_angle = 2 * math.pi / 3
        elif e["key"] == Key.leftarrow:
            motor2_angle -= math.pi / 6
            if motor2_angle < 0:
                motor2_angle = 0
        elif e["key"] == Key.rightarrow:
            motor2_angle += math.pi / 6
            if motor2_angle > math.pi:
                motor2_angle = math.pi
        self.actuator1.angleIn = motor1_angle
        self.actuator2.angleIn = motor2_angle