Example with 3 to 1 mapping...

Author: damienmarchal

examples/example-mapping_3_to_1.py

@@ -0,0 +1,100 @@
+"""Implementation of an identity mapping in python"""
+# coding: utf8
+import Sofa
+import numpy as np
+
+class MSELossMapping(Sofa.Core.Mapping_Vec3d_Vec1d):
+    """Implementation of a Mapping in python"""
+    def __init__(self, *args, **kwargs):
+
+        ## This is just an ugly trick to transform pointer to object into sofa linkpath. 
+        for k,v in kwargs.items():
+            if k == "input":
+                kwargs[k] = v.linkpath
+            elif k == "output":
+                kwargs[k] = v.linkpath
+
+        Sofa.Core.Mapping_Vec3d_Vec1d.__init__(self, *args, **kwargs)
+
+        # let's compute the positions initial delta.
+        input_position = kwargs["input"].target().position.value.copy()
+        output_position = kwargs["output"].target().position.value.copy()
+        self.delta = output_position - input_position
+
+        self.target = kwargs.get("target", kwargs["input"].target().rest_position)
+
+    def apply(self, m, outCoord, inCoord):
+        print("PYTHON() APPLY ", outCoord, inCoord)
+        with outCoord.writeableArray() as wa:
+            wa[:] = 1.0
+
+    def applyJ(self, m, outDeriv, inDeriv):
+        print("PYTHON() APPLY-J", outDeriv, inDeriv)
+
+    def applyJT(self, m, outDeriv, inDeriv):
+        print("PYTHON() APPLY-JT", outDeriv, inDeriv)
+
+    def applyConstrainsJT(self, m, outDeriv, inDeriv):
+        print("PYTHON() APPLY-JT for constraints, data are [⋱]", m, outDeriv, inDeriv)
+        print("Constraints ", inDeriv.value)
+
+
+
+
+def createScene(root):
+        root.addObject("RequiredPlugin", pluginName=["Sofa.GL.Component",
+                                                     "Sofa.Component.ODESolver.Backward",
+                                                     "Sofa.Component.LinearSolver.Direct",
+                                                     "Sofa.Component.LinearSolver.Iterative",
+                                                     "Sofa.Component.Mass",
+                                                     "Sofa.Component.StateContainer",
+                                                     "Sofa.Component.Visual"
+                                                      ])
+
+        root.addObject("LineAxis")
+        root.addObject("DefaultAnimationLoop", name="loop")
+
+        root.addChild("Modelling")
+
+        ######### OBJECT #####################
+        o = root.Modelling.addChild("Object")
+        c = o.addObject("MechanicalObject", name="mechanical", template="Vec3d", 
+                        position=[0.0,0.0,0.0, 1.0,0.0,0.0])
+        c.showObject = True
+        c.showColor = [1.0,0.0,0.0,1.0]
+        c.drawMode = 1
+        o.addObject("UniformMass", name="mass", totalMass=1.0)
+        
+        ######### OBJECT #####################
+        m = o.addChild("MappedDof")
+        sm = m.addObject("MechanicalObject", name="mapped_quantities", template="Vec1d", position=[0.0])
+        m.addObject( MSELossMapping(name="MSELossObject", input=c, output=sm, target=c ) )
+        
+        root.addChild("Simulation")
+        root.Simulation.addObject("EulerImplicitSolver")
+        root.Simulation.addObject("CGLinearSolver", tolerance=1e-12, threshold=1e-12, iterations=25)
+        root.Simulation.addChild(root.Modelling)
+
+        return root
+
+
+def main():
+    import SofaRuntime
+    import Sofa.Gui
+    import SofaQt
+
+    root=Sofa.Core.Node("root")
+    createScene(root)
+    Sofa.Simulation.initRoot(root)
+
+    Sofa.Gui.GUIManager.Init("myscene", "qglviewer")
+    Sofa.Gui.GUIManager.createGUI(root, __file__)
+    Sofa.Gui.GUIManager.SetDimension(1080, 1080)
+    Sofa.Gui.GUIManager.MainLoop(root)
+    Sofa.Gui.GUIManager.closeGUI()
+
+    print("End of simulation.")
+
+
+if __name__ == '__main__':
+    main()