midas-civil 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

midas_civil/_boundary.py

@@ -11,7 +11,6 @@ def convList(item):
 
 
 
-
 class Boundary:
 
     @classmethod
@@ -20,6 +19,8 @@ class Boundary:
         if cls.Support.sups!=[]: cls.Support.create()
         if cls.ElasticLink.links!=[]: cls.ElasticLink.create()
         if cls.RigidLink.links!=[]: cls.RigidLink.create()
+        if cls.MLFC.func!=[]: cls.RigidLink.create()
+        if cls.PointSpring.springs!=[]: cls.PointSpring.create()
 
     
     @classmethod
@@ -28,6 +29,8 @@ class Boundary:
         cls.Support.delete()
         cls.ElasticLink.delete()
         cls.RigidLink.delete()
+        cls.MLFC.delete()
+        cls.PointSpring.delete()
 
     @classmethod
     def sync(cls):
@@ -35,8 +38,8 @@ class Boundary:
         cls.Support.sync()
         cls.ElasticLink.sync()
         cls.RigidLink.sync()
-
-
+        cls.MLFC.sync()
+        cls.PointSpring.delete()
 
 
     class Support:
@@ -506,10 +509,33 @@ class Boundary:
     #---------------------------------------------------------------------------------------------------------------
 
     class MLFC:
+
         func = []
         _id = []
 
-        def __init__(self,name,type:str='FORCE',symm:bool=True,data:list=[[0,0],[1,1]],id=None):
+        def __init__(self, name:str, type:str='FORCE', symm:bool=True, data:list=[[0,0],[1,1]], id:int=None):
+            """
+            Force-Deformation Function constructor.
+
+            Parameters:
+                name (str): The name for the Force-Deformation Function.
+                type (str, optional): Type of function, either "FORCE" or "MOMENT". Defaults to "FORCE".
+                symm (bool, optional): Defines if the function is symmetric (True) or unsymmetric (False). Defaults to True.
+                data (list[list[float]], optional): A list of [X, Y] coordinate pairs defining the function curve. Required.
+                    - For "FORCE" type: X is displacement, Y is force.
+                    - For "MOMENT" type: X is rotation in radians, Y is moment.
+                    Defaults to [[0,0],[1,1]].
+                id (int, optional): The function ID. If not provided, it will be auto-assigned.
+
+            Examples:
+                ```python
+                # Create a symmetric force vs. displacement function
+                Boundary.MLFC(name="MyForceFunction", type="FORCE", symm=True, data=[[0,0], [0.1, 100], [0.2, 150]])
+
+                # Create an unsymmetric moment vs. rotation function with a specific ID
+                Boundary.MLFC(name="MyMomentFunction", type="MOMENT", symm=False, data=[[0,0], [0.01, 500], [0.02, 750]], id=5)
+                ```
+            """
             self.NAME = name
             self.TYPE = type
             self.SYMM = symm
@@ -534,6 +560,7 @@ class Boundary:
         
         @classmethod
         def json(cls):
+           
             json = {"Assign": {}}
             for fn in cls.func:
                 json["Assign"][fn.ID]={
@@ -550,22 +577,20 @@ class Boundary:
         @classmethod
         def create(cls):
             """
-            Sends all FUNC data to Midas API.
+            Sends all FUNC data.
             """
             MidasAPI("PUT", "/db/MLFC", cls.json())
         
         @classmethod
         def get(cls):
             """
-            Retrieves data from Midas API.
+            Retrieves data.
             """
             return MidasAPI("GET", "/db/MLFC")
         
         @classmethod
         def sync(cls):
-            """
-            Updates the class with data from the Midas API.
-            """
+            
             cls.links = []
             a = cls.get()
             if a != {'message': ''}:
@@ -584,4 +609,217 @@ class Boundary:
             Deletes all func from the database and resets the class.
             """
             cls.links = []
-            return MidasAPI("DELETE", "/db/MLFC")
+            return MidasAPI("DELETE", "/db/MLFC")
+
+#--------------------------------------------------------------------------------------------------------------------------------------
+
+
+    class PointSpring:
+        """Create Point Spring Object in Python"""
+        springs = []
+        
+        def __init__(self, 
+                    node: int,
+                    spring_type: str = "LINEAR",
+                    group: str = "",
+                    id: int = None,
+                    stiffness: list = None,
+                    fixed_option: list = None,
+                    damping: list = None,
+                    direction: str = "Dx+",
+                    normal_vector: list = None,
+                    function_id: int = 1):
+            """
+            Point Spring constructor.
+            
+            Parameters:
+                node: Node ID where spring is applied
+                spring_type: Type of spring ("LINEAR", "COMP", "TENS", "MULTI")
+                group: Group name (default "")
+                id: Spring ID (optional, auto-assigned if None)
+                stiffness: Spring stiffness values [SDx, SDy, SDz, SRx, SRy, SRz] or single value for COMP/TENS
+                fixed_option: Fixed option array [Boolean, 6] for LINEAR type
+                damping: Damping values [Cx, Cy, Cz, CRx, CRy, CRz] (if provided, damping is enabled)
+                direction: Direction string ("Dx+", "Dx-", "Dy+", "Dy-", "Dz+", "Dz-", "Vector")
+                normal_vector: Normal vector [x, y, z] when direction is "Vector"
+                function_id: Function ID for MULTI type
+            
+            Examples:
+                # Linear spring
+                PointSpring(1, "LINEAR", "Group1", stiffness=[1000, 1000, 1000, 100, 100, 100])
+                
+                # Compression only spring
+                PointSpring(2, "COMP", "Group2", stiffness=5000, direction="Dz+")
+                
+                # Tension only spring with vector direction
+                PointSpring(3, "TENS", "Group3", stiffness=3000, direction="Vector", normal_vector=[0, -1, -1])
+                
+                # Multi-linear spring
+                PointSpring(4, "MULTI", "Group4", direction="Dz+", function_id=1)
+            """
+            
+            # Check if group exists, create if not
+            if group != "":
+                chk = 0
+                a = [v['NAME'] for v in Group.Boundary.json()["Assign"].values()]
+                if group in a:
+                    chk = 1
+                if chk == 0:
+                    Group.Boundary(group)
+            
+            # Validate spring type
+            valid_types = ["LINEAR", "COMP", "TENS", "MULTI"]
+            if spring_type not in valid_types:
+                spring_type = "LINEAR"
+            
+            self.NODE = node
+            self.TYPE = spring_type
+            self.GROUP_NAME = group
+            
+            # Convert direction string to integer
+            direction_map = {
+                "Dx+": 0, "Dx-": 1, "Dy+": 2, "Dy-": 3, 
+                "Dz+": 4, "Dz-": 5, "Vector": 6
+            }
+            self.DIR = direction_map.get(direction, 0)
+            
+            # Auto-assign ID if not provided
+            if id is None:
+                self.ID = len(Boundary.PointSpring.springs) + 1
+            else:
+                self.ID = id
+            
+            # Type-specific parameters
+            if spring_type == "LINEAR":
+                self.SDR = stiffness if stiffness else [0, 0, 0, 0, 0, 0]
+                self.F_S = fixed_option if fixed_option else [False] * 6
+                # Damping logic: if damping values provided, enable damping
+                self.DAMPING = damping is not None and any(d != 0 for d in damping) if damping else False
+                self.Cr = damping if damping else [0, 0, 0, 0, 0, 0]
+                
+            elif spring_type in ["COMP", "TENS"]:
+                self.STIFF = stiffness if stiffness else 0
+                self.DV = normal_vector if normal_vector else [0, 0, 0]
+                
+            elif spring_type == "MULTI":
+                self.DV = normal_vector if normal_vector else [0, 0, 0]
+                self.FUNCTION = function_id
+            
+            # Add to static list
+            Boundary.PointSpring.springs.append(self)
+        
+        @classmethod
+        def json(cls):
+            """
+            Converts PointSpring data to JSON format for API submission.
+            """
+            json_data = {"Assign": {}}
+            
+            for spring in cls.springs:
+                spring_data = {
+                    "ID": spring.ID,
+                    "TYPE": spring.TYPE,
+                    "GROUP_NAME": spring.GROUP_NAME
+                }
+                
+                # Add type-specific parameters
+                if spring.TYPE == "LINEAR":
+                    spring_data["SDR"] = spring.SDR
+                    spring_data["F_S"] = spring.F_S
+                    spring_data["DAMPING"] = spring.DAMPING
+                    if spring.DAMPING:
+                        spring_data["Cr"] = spring.Cr
+                        
+                elif spring.TYPE in ["COMP", "TENS"]:
+                    spring_data["STIFF"] = spring.STIFF
+                    spring_data["DIR"] = spring.DIR
+                    spring_data["DV"] = spring.DV
+                    
+                elif spring.TYPE == "MULTI":
+                    spring_data["DIR"] = spring.DIR
+                    spring_data["DV"] = spring.DV
+                    spring_data["FUNCTION"] = spring.FUNCTION
+                
+                json_data["Assign"][spring.NODE] = {"ITEMS": [spring_data]}
+            
+            return json_data
+        
+        @classmethod
+        def create(cls):
+            """
+            Sends all PointSpring data
+            """
+            MidasAPI("PUT", "/db/nspr", cls.json())
+        
+        @classmethod
+        def get(cls):
+            """
+            Retrieves PointSpring data
+            """
+            return MidasAPI("GET", "/db/nspr")
+        
+        @classmethod
+        def sync(cls):
+            """
+            Updates the PointSpring class with data 
+            """
+            cls.springs = []
+            a = cls.get()
+            
+            if a != {'message': ''}:
+                for node_id, node_data in a.get("NSPR", {}).items():
+                    for item in node_data.get("ITEMS"):
+                        spring_type = item.get("TYPE")
+                        group_name = item.get("GROUP_NAME")
+                        spring_id = item.get("ID", 1)
+                        
+                        # Extract type-specific parameters
+                        if spring_type == "LINEAR":
+                            stiffness = item.get("SDR")
+                            fixed_option = item.get("F_S")
+                            damping = item.get("Cr") if item.get("DAMPING", False) else None
+                            
+                            # Convert direction back to string
+                            dir_map = {0: "Dx+", 1: "Dx-", 2: "Dy+", 3: "Dy-", 4: "Dz+", 5: "Dz-", 6: "Vector"}
+                            direction_str = dir_map.get(0, "Dx+")  # Default for LINEAR
+                            
+                            Boundary.PointSpring(
+                                int(node_id), spring_type, group_name, spring_id,
+                                stiffness, fixed_option, damping, direction_str
+                            )
+                            
+                        elif spring_type in ["COMP", "TENS"]:
+                            stiffness = item.get("STIFF")
+                            direction_int = item.get("DIR")
+                            normal_vector = item.get("DV")
+                            
+                            # Convert direction back to string
+                            dir_map = {0: "Dx+", 1: "Dx-", 2: "Dy+", 3: "Dy-", 4: "Dz+", 5: "Dz-", 6: "Vector"}
+                            direction_str = dir_map.get(direction_int, "Dx+")
+                            
+                            Boundary.PointSpring(
+                                int(node_id), spring_type, group_name, spring_id,
+                                stiffness, None, None, direction_str, normal_vector
+                            )
+                            
+                        elif spring_type == "MULTI":
+                            direction_int = item.get("DIR")
+                            normal_vector = item.get("DV")
+                            function_id = item.get("FUNCTION")
+                            
+                            # Convert direction back to string
+                            dir_map = {0: "Dx+", 1: "Dx-", 2: "Dy+", 3: "Dy-", 4: "Dz+", 5: "Dz-", 6: "Vector"}
+                            direction_str = dir_map.get(direction_int, "Dx+")
+                            
+                            Boundary.PointSpring(
+                                int(node_id), spring_type, group_name, spring_id,
+                                None, None, None, direction_str, normal_vector, function_id
+                            )
+        
+        @classmethod
+        def delete(cls):
+            """
+            Deletes all point springs from the database and resets the class.
+            """
+            cls.springs = []
+            return MidasAPI("DELETE", "/db/nspr")