before the train 3/3

damienmarchal · Apr 14, 2025 · Apr 14, 2025 · Apr 14, 2025 · Apr 14, 2025 · Apr 14, 2025
commit 592c13d96d4eb68c827877fcc39586ed9ee33fff
diff --git a/splib/core/enum_types.py b/splib/core/enum_types.py
@@ -39,4 +39,12 @@ class ElementType(Enum):
 class StateType(Enum):
     VEC3            = 3
     VEC1            = 1
-    RIGID           = 7
+    RIGID           = 7
+
+    def __str__(self):
+        if self == StateType.VEC3:
+            return "Vec3"
+        if self == StateType.VEC1:
+            return "Vec1"
+        if self == StateType.RIGID:
+            return "Rigid3"
diff --git a/splib/mechanics/mass.py b/splib/mechanics/mass.py
@@ -3,6 +3,7 @@
 from splib.core.enum_types import ElementType
 
 
+# TODO : use the massDensity only and deduce totalMass if necessary from it + volume
 @ReusableMethod
 def addMass(node,template,totalMass=DEFAULT_VALUE,massDensity=DEFAULT_VALUE,lumping=DEFAULT_VALUE,**kwargs):
     if (not isDefault(totalMass)) and (not isDefault(massDensity)) :

diff --git a/stlib/entities/__entity__.py b/stlib/entities/__entity__.py
@@ -1,7 +1,7 @@
 from stlib.core.baseParameters import BaseParameters
 from stlib.prefabs.collision import CollisionParameters, Collision
 from stlib.prefabs.visual import VisualParameters, Visual
-from stlib.prefabs.behavior import Behavior, BehaviorParameters
+from stlib.prefabs.material import Material, MaterialParameters
 from stlib.geometry import Geometry
 from stlib.geometry.extract import ExtractParameters
 import dataclasses
@@ -22,7 +22,7 @@ class EntityParameters(BaseParameters):
     addVisual : Optional[Callable] = lambda x : Visual(VisualParameters()) 
 
     geometry : GeometryParameters
-    behavior : BehaviorParameters
+    material : MaterialParameters
     collision : Optional[CollisionParameters] = None
     visual : Optional[VisualParameters] = None
 
@@ -31,7 +31,7 @@ class EntityParameters(BaseParameters):
 class Entity(Sofa.Core.BaseEntity): 
 
     # A simulated object
-    behavior : Behavior
+    material : Material
     visual : Visual
     collision : Collision
     geometry : Geometry
@@ -49,12 +49,12 @@ def __init__(self, parent=None, parameters=EntityParameters(), **kwargs):
 
         self.geometry = self.add(Geometry, self.parameters.geometry)
 
-        ### Check compatilibility of Behavior
-        if self.parameters.behavior.stateType != self.parameters.template:
-            print("WARNING: imcompatibility between templates of entity and behavior")
-            self.parameters.behavior.stateType = self.parameters.template
+        ### Check compatilibility of Material
+        if self.parameters.material.stateType != self.parameters.template:
+            print("WARNING: imcompatibility between templates of both the entity and the material")
+            self.parameters.material.stateType = self.parameters.template
 
-        self.behavior = self.add(Behavior,self.parameters.behavior)
+        self.material = self.add(Material,self.parameters.material)
 
         if self.parameters.collision is not None:
             self.collision = self.add(Collision,self.parameters.collision)
@@ -65,11 +65,15 @@ def __init__(self, parent=None, parameters=EntityParameters(), **kwargs):
             self.visual = self.add(Visual,self.parameters.visual)
             self.addMapping(self.parameters.visual, self.visual)
 
+
     def addMapping(self, destParameter, destPrefab):
+
+        templateString = f'{self.parameters.template},{destParameter.template}'
+
         if( self.parameters.template == StateType.VEC3):
             if isinstance(destParameter.geometry,ExtractParameters):
-                destPrefab.addObject("IdentityMapping", input="@../behavior/", output="@.", template='Vec3,Vec3')
+                destPrefab.addObject("IdentityMapping", input="@../material/", output="@.", template=templateString)
             else :
-                destPrefab.addObject("BarycentricMapping", input="@../behavior/", output="@.", template='Vec3,Vec3')
+                destPrefab.addObject("BarycentricMapping", input="@../material/", output="@.", template=templateString)
         else:
-            destPrefab.addObject("RigidMapping", input="@../behavior", output="@.", template='Rigid3,Vec3')
+            destPrefab.addObject("RigidMapping", input="@../material", output="@.", template=templateString)
diff --git a/stlib/entities/deformable/__deformable__.py b/stlib/entities/deformable/__deformable__.py
@@ -1,37 +1,69 @@
 from stlib.entities import Entity, EntityParameters
-from stlib.entities.deformable.__parameters__ import  DeformableParameters
+from stlib.prefabs.material import Material, MaterialParameters
 from stlib.prefabs.visual import Visual
-from stlib.mixins.collision import CollisionMixin
-from splib.core.enum_types import ConstitutiveLaw
+from splib.core.enum_types import ConstitutiveLaw, ElementType
+from splib.mechanics.linear_elasticity import *
+from splib.mechanics.hyperelasticity import *
+from splib.mechanics.mass import addMass
 
-class DeformableParameters(EntityParameters):
 
-    constitutiveLaw : ConstitutiveLaw = ConstitutiveLaw.ELASTIC
+class DeformableBehaviorParameters(MaterialParameters):
 
-class Deformable(CollisionMixin, Entity):
+    constitutiveLawType : ConstitutiveLaw 
+    elementType : ElementType
+    parameters : list[float]
 
-    params : DeformableParameters
+    def addMaterial(self, node):
 
-    @staticmethod
-    def getParameters(**kwargs) -> DeformableParameters:
-        return DeformableParameters(**kwargs)
+        addMass(node, node.stateType, massDensity=node.massDensity, lumping=node.massLumping)
+
+        # TODO : change this with inheritance
+        if(self.constitutiveLawType == ConstitutiveLaw.HYPERELASTIC):
+            addHyperelasticity(node,self.elementType, self.parameters)
+        else:
+            addLinearElasticity(node,self.elementType, self.parameters[0], self.parameters[1])
+
+
+# class Deformable(Entity):
+
+#     params : DeformableParameters
+
+#     @staticmethod
+#     def getParameters(**kwargs) -> DeformableParameters:
+#         return DeformableParameters(**kwargs)
 
 
-    def __init__(self, params : DeformableParameters, **kwargs):
-        Entity.__init__(self, **kwargs)  
+#     def __init__(self, params : DeformableParameters, **kwargs):
+#         Entity.__init__(self, **kwargs)  
 
-        self.__addConstitutiveLaw__()
-        self.addCollision(params.collision)
+#         self.__addConstitutiveLaw__()
+#         self.addCollision(params.collision)
 
 
-    #@customizable
-    # Need generic way of defining paramaters (linear/hyper...)
-    def __addConstitutiveLaw__(self):
-        self.params.addConstitutiveLaw()
+#     #@customizable
+#     # Need generic way of defining paramaters (linear/hyper...)
+#     def __addConstitutiveLaw__(self):
+#         self.params.addConstitutiveLaw()
 
 
-    #@customizable
-    def __addVisual__(self):
-        #Extract surface and add identity mapping
-        self.add(Visual, self.params.visual)
+#     #@customizable
+#     def __addVisual__(self):
+#         #Extract surface and add identity mapping
+#         self.add(Visual, self.params.visual)
+
+
+
+
+
+def createScene(root) :
+
+    from stlib.geometry.file import FileParameters    
+    from stlib.geometry.extract import ExtractParameters    
 
+    liverParameters = EntityParameters()
+    liverParameters.behavior = DeformableBehaviorParameters()
+    liverParameters.behavior.constitutiveLawType = ConstitutiveLaw.ELASTIC
+    liverParameters.behavior.parameters = [1000, 0.45]
+    liverParameters.geometry = FileParameters("liver.vtk")
+    liverParameters.visual = ExtractParameters()
+    myDeformableObject = root.add(Entity, liverParameters)
diff --git a/stlib/entities/deformable/__parameters__.py b/stlib/entities/deformable/__parameters__.py
diff --git a/stlib/prefabs/behavior.py b/stlib/prefabs/behavior.py
diff --git a/stlib/prefabs/material.py b/stlib/prefabs/material.py
@@ -0,0 +1,26 @@
+from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses, Any
+from splib.core.enum_types import StateType
+from stlib.core.basePrefab import BasePrefab
+from splib.mechanics.mass import addMass
+
+@dataclasses.dataclass
+class MaterialParameters(BaseParameters):
+    name: str = "Material"
+
+    stateType: StateType = StateType.VEC3
+    massDensity: float
+    massLumping: bool
+
+    addMaterial : Optional[Callable] = lambda node : addMass(node, node.stateType, massDensity=node.massDensity, lumping=node.massLumping)
+
+
+# TODO : previously called Behavior
+class Material(BasePrefab):
+    def __init__(self, params: MaterialParameters):
+        BasePrefab.__init__(self, params)
+
+        self.params = params
+        self.addObject("MechanicalObject", name="States", template=str(self.params.stateType))
+
+        if(params.addMaterial is not None):
+            params.addMaterial(self)