midas-civil 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

midas_civil/_boundary.py

@@ -10,6 +10,7 @@ def convList(item):
             return item
 
 
+
 class Boundary:
 
     @classmethod
@@ -18,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
@@ -26,6 +29,8 @@ class Boundary:
         cls.Support.delete()
         cls.ElasticLink.delete()
         cls.RigidLink.delete()
+        cls.MLFC.delete()
+        cls.PointSpring.delete()
 
     @classmethod
     def sync(cls):
@@ -33,8 +38,8 @@ class Boundary:
         cls.Support.sync()
         cls.ElasticLink.sync()
         cls.RigidLink.sync()
-
-
+        cls.MLFC.sync()
+        cls.PointSpring.delete()
 
 
     class Support:
@@ -502,3 +507,319 @@ class Boundary:
             cls.links = []
             return MidasAPI("DELETE", "/db/RIGD")
     #---------------------------------------------------------------------------------------------------------------
+
+    class MLFC:
+
+        func = []
+        _id = []
+
+        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
+            self.DATA = data
+
+            self.X = [dat[0] for dat in self.DATA]
+            self.Y = [dat[1] for dat in self.DATA]
+
+            # Auto-assign ID if not provided
+            if id is None:
+                if __class__._id == []:
+                    self.ID = 1
+                else:
+                    self.ID = max(__class__._id) + 1
+            else:
+                self.ID = id
+
+            __class__._id.append(self.ID)
+            __class__.func.append(self)
+        
+
+        
+        @classmethod
+        def json(cls):
+           
+            json = {"Assign": {}}
+            for fn in cls.func:
+                json["Assign"][fn.ID]={
+                    "NAME": fn.NAME,
+                    "TYPE": fn.TYPE,
+                    "SYMM": fn.SYMM,
+                    "FUNC_ID": 0,
+                    "ITEMS": []
+                }
+                for i in range(len(fn.X)):
+                    json["Assign"][fn.ID]["ITEMS"].append({"X":fn.X[i],"Y":fn.Y[i]})
+            return json
+        
+        @classmethod
+        def create(cls):
+            """
+            Sends all FUNC data.
+            """
+            MidasAPI("PUT", "/db/MLFC", cls.json())
+        
+        @classmethod
+        def get(cls):
+            """
+            Retrieves data.
+            """
+            return MidasAPI("GET", "/db/MLFC")
+        
+        @classmethod
+        def sync(cls):
+            
+            cls.links = []
+            a = cls.get()
+            if a != {'message': ''}:
+                for i in a['MLFC'].keys():
+                    name = a['MLFC'][i]["NAME"]
+                    type = a['MLFC'][i]["TYPE"]
+                    symm = a['MLFC'][i]["SYMM"]
+                    data = []
+                    for j in (a['MLFC'][i]['ITEMS']):
+                        data.append([j["X"],j["Y"]])
+                    Boundary.MLFC(name,type,symm,data,int(i))
+        
+        @classmethod
+        def delete(cls):
+            """
+            Deletes all func from the database and resets the class.
+            """
+            cls.links = []
+            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")

midas_civil/_element.py

@@ -4,214 +4,271 @@ from ._node import *
 import numpy as np
 
 def _ADD(self):
-    # Commom HERE ---------------------------------------------
+    """
+    Adds an element to the main list. If the ID is 0, it auto-increments.
+    If the ID already exists, it replaces the existing element.
+    """
     id = int(self.ID)
-    if Element.ids == []: 
+    if not Element.ids:
         count = 1
     else:
-        count = max(Element.ids)+1
+        count = max(Element.ids) + 1
 
-    if id==0 :
+    if id == 0:
         self.ID = count
         Element.elements.append(self)
         Element.ids.append(int(self.ID))
     elif id in Element.ids:
-        self.ID=int(id)
-        print(f'⚠️  Element with ID {id} already exist! It will be replaced.')
-        index=Element.ids.index(id)
-        Element.elements[index]=self
+        self.ID = int(id)
+        print(f'⚠️  Element with ID {id} already exists! It will be replaced.')
+        index = Element.ids.index(id)
+        Element.elements[index] = self
     else:
-        self.ID=id        
+        self.ID = id
         Element.elements.append(self)
         Element.ids.append(int(self.ID))
-    # Common END -------------------------------------------------------
-
 
 def _updateElem(self):
-    js2s = {'Assign':{self.ID : _Obj2JS(self)}}
-    MidasAPI('PUT','/db/elem',js2s)
+    """Sends a PUT request to update a single element in Midas."""
+    js2s = {'Assign': {self.ID: _Obj2JS(self)}}
+    MidasAPI('PUT', '/db/elem', js2s)
     return js2s
 
-
-
-
 def _Obj2JS(obj):
-
-    js={}
-
-    if obj.TYPE == 'BEAM':
-        #---  BEAM ---------------------------------------
-        js =  {
-            "TYPE": obj.TYPE,
-            "MATL": obj.MATL,
-            "SECT": obj.SECT,
-            "NODE": [
-                obj.NODE[0],
-                obj.NODE[1]
-            ],
-            "ANGLE": obj.ANGLE
-        }
-    elif obj.TYPE == 'TRUSS':
-        #---  TRUSS ---------------------------------------
-        js =  {
-            "TYPE": obj.TYPE,
-            "MATL": obj.MATL,
-            "SECT": obj.SECT,
-            "NODE": [
-                obj.NODE[0],
-                obj.NODE[1]
-            ],
-            "ANGLE": obj.ANGLE
-        }
+    """Converts a Python element object to its JSON dictionary representation."""
+    # Base attributes common to many elements
+    js = {
+        "TYPE": obj.TYPE,
+        "MATL": obj.MATL,
+        "SECT": obj.SECT,
+        "NODE": obj.NODE,
+    }
     
-    elif obj.TYPE == 'PLATE':
-        #---  PLATE ---------------------------------------
-        js =  {
-            "TYPE": obj.TYPE,
-            "MATL": obj.MATL,
-            "SECT": obj.SECT,
-            "NODE": obj.NODE,
-            "ANGLE": obj.ANGLE,
-            "STYPE": obj.STYPE
-        }
-
+    # Add optional attributes if they exist on the object
+    if hasattr(obj, 'ANGLE'): js["ANGLE"] = obj.ANGLE
+    if hasattr(obj, 'STYPE'): js["STYPE"] = obj.STYPE
+    
+    # Handle type-specific and subtype-specific attributes
+    if obj.TYPE == 'TENSTR': # Tension/Hook/Cable
+        # Tension-only (stype=1) - can have TENS parameter
+        if obj.STYPE == 1:
+            if hasattr(obj, 'TENS'): js["TENS"] = obj.TENS
+            if hasattr(obj, 'T_LIMIT'): js["T_LIMIT"] = obj.T_LIMIT
+            if hasattr(obj, 'T_bLMT'): js["T_bLMT"] = obj.T_bLMT
+        
+        # Hook (stype=2) - has NON_LEN parameter
+        elif obj.STYPE == 2:
+            if hasattr(obj, 'NON_LEN'): js["NON_LEN"] = obj.NON_LEN
+        
+        # Cable (stype=3) - has CABLE, NON_LEN, and TENS parameters
+        elif obj.STYPE == 3:
+            if hasattr(obj, 'CABLE'): js["CABLE"] = obj.CABLE
+            if hasattr(obj, 'NON_LEN'): js["NON_LEN"] = obj.NON_LEN
+            if hasattr(obj, 'TENS'): js["TENS"] = obj.TENS
+
+    elif obj.TYPE == 'COMPTR': # Compression/Gap
+        # Compression-only (stype=1) - can have TENS, T_LIMIT, T_bLMT
+        if obj.STYPE == 1:
+            if hasattr(obj, 'TENS'): js["TENS"] = obj.TENS
+            if hasattr(obj, 'T_LIMIT'): js["T_LIMIT"] = obj.T_LIMIT
+            if hasattr(obj, 'T_bLMT'): js["T_bLMT"] = obj.T_bLMT
+        
+        # Gap (stype=2) - has NON_LEN parameter
+        elif obj.STYPE == 2:
+            if hasattr(obj, 'NON_LEN'): js["NON_LEN"] = obj.NON_LEN
+            
     return js
 
-def _JS2Obj(id,js):
-    type = js['TYPE']
-    matl = js['MATL']
-    sect = js['SECT']
-    node = js['NODE']
-    angle = js['ANGLE']
-
-    if type == 'BEAM':
-        Element.Beam(node[0],node[1],matl,sect,angle,id)
-    elif type == 'TRUSS':
-        Element.Truss(node[0],node[1],matl,sect,angle,id)
-    elif type == 'PLATE':
-        stype = js['STYPE']
-        Element.Plate(node,stype,matl,sect,angle,id)
+def _JS2Obj(id, js):
+    """Converts a JSON dictionary back into a Python element object during sync."""
+    elem_type = js.get('TYPE')
     
+    # Prepare arguments for constructors
+    args = {
+        'id': int(id),
+        'mat': js.get('MATL'),
+        'sect': js.get('SECT'),
+        'node': js.get('NODE'),
+        'angle': js.get('ANGLE'),
+        'stype': js.get('STYPE')
+    }
+    
+    # Prepare individual parameters for optional/subtype-specific parameters
+    non_len = js.get('NON_LEN')
+    cable_type = js.get('CABLE')
+    tens = js.get('TENS')
+    t_limit = js.get('T_LIMIT')
+
+    if elem_type == 'BEAM':
+        Element.Beam(args['node'][0], args['node'][1], args['mat'], args['sect'], args['angle'], args['id'])
+    elif elem_type == 'TRUSS':
+        Element.Truss(args['node'][0], args['node'][1], args['mat'], args['sect'], args['angle'], args['id'])
+    elif elem_type == 'PLATE':
+        Element.Plate(args['node'], args['stype'], args['mat'], args['sect'], args['angle'], args['id'])
+    elif elem_type == 'TENSTR':
+        Element.Tension(args['node'][0], args['node'][1], args['stype'], args['mat'], args['sect'], args['angle'], args['id'], non_len, cable_type, tens, t_limit)
+    elif elem_type == 'COMPTR':
+        Element.Compression(args['node'][0], args['node'][1], args['stype'], args['mat'], args['sect'], args['angle'], args['id'], tens, t_limit, non_len)
+    elif elem_type == 'SOLID':
+        Element.Solid(nodes=args['node'], mat=args['mat'], sect=args['sect'], id=args['id'])
 
 
 class _common:
+    """Common base class for all element types."""
     def __str__(self):
-        return str(f'ID = {self.ID}  \nJSON : {_Obj2JS(self)}\n')
+        return str(f'ID = {self.ID} \nJSON : {_Obj2JS(self)}\n')
 
     def update(self):
         return _updateElem(self)
 
-
-
-
-
-
-#6 Class to create elements
+# --- Main Element Class ---
 class Element:
-    """ Use Beam or Truss function"""
+    """
+    Main class to create and manage structural elements like Beams, Trusses,
+    Plates, Tension/Compression-only elements, and Solids.
+    """
     elements = []
     ids = []
 
     @classmethod
     def json(cls):
-        json = {"Assign":{}}
+        json_data = {"Assign": {}}
         for elem in cls.elements:
             js = _Obj2JS(elem)
-            json["Assign"][elem.ID] = js
-        return json
-    
+            json_data["Assign"][elem.ID] = js
+        return json_data
+
     @classmethod
     def create(cls):
-        if cls.elements!=[]:
-            MidasAPI("PUT","/db/ELEM",Element.json())
-        
+        if cls.elements:
+            MidasAPI("PUT", "/db/ELEM", Element.json())
+
     @staticmethod
     def get():
-        return MidasAPI("GET","/db/ELEM")
-    
+        return MidasAPI("GET", "/db/ELEM")
+
     @staticmethod
     def sync():
         a = Element.get()
-        if a != {'message': ''}:
-            if list(a['ELEM'].keys()) != []:
-                Element.elements = []
-                Element.ids=[]
-                for elem_id in a['ELEM'].keys():
-                    _JS2Obj(elem_id,a['ELEM'][elem_id])
-    
+        if a and 'ELEM' in a and a['ELEM']:
+            Element.elements = []
+            Element.ids = []
+            for elem_id, data in a['ELEM'].items():
+                _JS2Obj(elem_id, data)
+
     @staticmethod
     def delete():
-        MidasAPI("DELETE","/db/ELEM")
-        Element.elements=[]
-        Element.ids=[]
-        
+        MidasAPI("DELETE", "/db/ELEM")
+        Element.elements = []
+        Element.ids = []
 
+    # --- Element Type Subclasses ---
 
     class Beam(_common):
 
-        def __init__(self,i:int,j:int,mat:int=1,sect:int=1,angle:float=0,id:int=0):
+        def __init__(self, i: int, j: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0):
+            """
+            Creates a BEAM element for frame analysis.
+            
+            Parameters:
+                i: Start node ID
+                j: End node ID  
+                mat: Material property number (default 1)
+                sect: Section property number (default 1)
+                angle: Beta angle for section orientation in degrees (default 0.0)
+                id: Element ID (default 0 for auto-increment)
+            
+            Examples:
+                ```python
+                # Simple beam with default properties
+                Element.Beam(1, 2)
+                
+                # Beam with specific material and section
+                Element.Beam(1, 2, mat=2, sect=3)
+                
+                # Beam with 90° rotation (strong axis vertical)
+                Element.Beam(1, 2, mat=1, sect=1, angle=90.0)
+                
+                # Beam with specific ID
+                Element.Beam(1, 2, mat=1, sect=1, angle=0.0, id=100)
+                ```
+            """
             self.ID = id
             self.TYPE = 'BEAM'
             self.MATL = mat
             self.SECT = sect
-            self.NODE=[i,j]
+            self.NODE = [i, j]
             self.ANGLE = angle
-
             _ADD(self)
 
         @staticmethod
         def SDL(s_loc:list,dir:list,l:float,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0): #CHANGE TO TUPLE
-            beam_nodes =[]
-            beam_obj = []
-            s_locc = np.array(s_loc)
-            unit_vec = np.array(dir)/np.linalg.norm(dir)
-
-            for i in range(n+1):
-                locc = s_locc+i*l*unit_vec/n
-                Enode=Node(locc[0].item(),locc[1].item(),locc[2].item())
-                beam_nodes.append(Enode.ID)
-            
-            for i in range(n):
-                if id == 0 : id_new = 0
-                else: id_new = id+i
-                beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
-            
-            return beam_obj
+                beam_nodes =[]
+                beam_obj = []
+                s_locc = np.array(s_loc)
+                unit_vec = np.array(dir)/np.linalg.norm(dir)
+
+                for i in range(n+1):
+                    locc = s_locc+i*l*unit_vec/n
+                    Enode=Node(locc[0].item(),locc[1].item(),locc[2].item())
+                    beam_nodes.append(Enode.ID)
+                
+                for i in range(n):
+                    if id == 0 : id_new = 0
+                    else: id_new = id+i
+                    beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
                 
+                return beam_obj
+                    
 
         @staticmethod
         def SE(s_loc:list,e_loc:list,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0):
-            beam_nodes =[]
-            beam_obj = []
-            i_loc = np.linspace(s_loc,e_loc,n+1)
-            for i in range(n+1):
-                Enode=Node(i_loc[i][0].item(),i_loc[i][1].item(),i_loc[i][2].item())
-                beam_nodes.append(Enode.ID)
-            
-            for i in range(n):
-                if id == 0 : id_new = 0
-                else: id_new = id+i
-                beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
-            
-            return beam_obj
-
-
-
-
+                beam_nodes =[]
+                beam_obj = []
+                i_loc = np.linspace(s_loc,e_loc,n+1)
+                for i in range(n+1):
+                    Enode=Node(i_loc[i][0].item(),i_loc[i][1].item(),i_loc[i][2].item())
+                    beam_nodes.append(Enode.ID)
+                
+                for i in range(n):
+                    if id == 0 : id_new = 0
+                    else: id_new = id+i
+                    beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
+                
+                return beam_obj
 
     class Truss(_common):
-
-        def __init__(self,i:int,j:int,mat:int=1,sect:int=1,angle:float=0,id:int=0):
+        def __init__(self, i: int, j: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0):
+            """
+            Creates a TRUSS element
+            
+            Parameters:
+                i: Start node ID
+                j: End node ID
+                mat: Material property number (default 1)
+                sect: Section property number (default 1)
+                angle: Beta angle for section orientation in degrees (default 0.0)
+                id: Element ID (default 0 for auto-increment)
+            
+            Examples:
+                ```python
+                # Simple truss member
+                Element.Truss(1, 2)
+                
+                # Truss with specific material and section
+                Element.Truss(1, 2, mat=3, sect=2)
+                
+                # Diagonal truss member
+                Element.Truss(3, 4, mat=1, sect=1, id=50)
+                ```
+            """
             self.ID = id
             self.TYPE = 'TRUSS'
             self.MATL = mat
             self.SECT = sect
-            self.NODE=[i,j]
+            self.NODE = [i, j]
             self.ANGLE = angle
-
             _ADD(self)
-            
-
 
         @staticmethod
         def SDL(s_loc:list,dir:list,l:float,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0):
@@ -247,23 +304,187 @@ class Element:
                 else: id_new = id+i
                 beam_obj.append(Element.Truss(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
             
-            return beam_obj
-    
-
-
+            return beam_obj 
+          
     class Plate(_common):
-
-        def __init__(self,nodes:list,stype:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0):
+        def __init__(self, nodes: list, stype: int = 1, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0):
+            """
+            Creates a PLATE element.
+            
+            Parameters:
+                nodes: List of node IDs [n1, n2, n3] for triangular or [n1, n2, n3, n4] for quadrilateral
+                stype: Plate subtype (1=Thick plate, 2=Thin plate, 3=With drilling DOF) (default 1)
+                mat: Material property number (default 1)
+                sect: Section (thickness) property number (default 1)
+                angle: Material angle for orthotropic materials in degrees (default 0.0)
+                id: Element ID (default 0 for auto-increment)
+            
+            Examples:
+                ```python
+                # Triangular thick plate
+                Element.Plate([1, 2, 3], stype=1, mat=1, sect=1)
+                
+                # Quadrilateral thin plate
+                Element.Plate([1, 2, 3, 4], stype=2, mat=2, sect=1)
+                
+                # Plate with drilling DOF for shell analysis
+                Element.Plate([5, 6, 7, 8], stype=3, mat=1, sect=2, angle=45.0)
+                ```
+            """
             self.ID = id
             self.TYPE = 'PLATE'
             self.MATL = mat
             self.SECT = sect
-            self.NODE=nodes
+            self.NODE = nodes
             self.ANGLE = angle
             self.STYPE = stype
-
+            _ADD(self)
+            
+    class Tension(_common):
+     def __init__(self, i: int, j: int, stype: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0, non_len: float = None, cable_type: int = None, tens: float = None, t_limit: float = None):
+        """
+        Creates a TENSTR (Tension-only) element.
+        
+        Parameters:
+            i: Start node ID
+            j: End node ID
+            stype: Tension element subtype (1=Tension-only, 2=Hook, 3=Cable)
+            mat: Material property number (default 1)
+            sect: Section property number (default 1)
+            angle: Beta angle for section orientation in degrees (default 0.0)
+            id: Element ID (default 0 for auto-increment)
+            non_len: Non-linear length parameter for Hook/Cable (default None)
+            cable_type: Cable type for stype=3 (1=Pretension, 2=Horizontal, 3=Lu) (default None)
+            tens: Initial tension force or allowable compression (default None)
+            t_limit: Tension limit value. If provided, the tension limit flag is set to True. (default None)
+        
+        Examples:
+            ```python
+            # Simple tension-only member
+            Element.Tension(1, 2, stype=1)
+            
+            # Tension-only with allowable compression and a tension limit
+            Element.Tension(1, 2, stype=1, tens=0.5, t_limit=-15)
+            
+            # Hook element with slack length
+            Element.Tension(3, 4, stype=2, non_len=0.5)
+            
+            # Cable with initial tension and catenary effects
+            Element.Tension(5, 6, stype=3, cable_type=3, tens=1000.0, non_len=0.1)
+            ```
+        """
+        self.ID = id
+        self.TYPE = 'TENSTR'
+        self.MATL = mat
+        self.SECT = sect
+        self.NODE = [i, j]
+        self.ANGLE = angle
+        self.STYPE = stype
+        
+        # Handle subtype-specific parameters
+        if stype == 1:  # Tension-only specific
+            if tens is not None:
+                self.TENS = tens
+            if t_limit is not None:
+                self.T_LIMIT = t_limit
+                self.T_bLMT = True
+                
+        elif stype == 2:  # Hook specific
+            if non_len is not None:
+                self.NON_LEN = non_len
+                
+        elif stype == 3:  # Cable specific
+            if cable_type is not None:
+                self.CABLE = cable_type
+            if non_len is not None:
+                self.NON_LEN = non_len
+            if tens is not None:
+                self.TENS = tens
+        _ADD(self)
+
+    class Compression(_common):
+        def __init__(self, i: int, j: int, stype: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0, tens: float = None, t_limit: float = None, non_len: float = None):
+            """
+            Creates a COMPTR (Compression-only) element.
+            
+            Parameters:
+                i: Start node ID
+                j: End node ID
+                stype: Compression element subtype (1=Compression-only, 2=Gap)
+                mat: Material property number (default 1)
+                sect: Section property number (default 1)
+                angle: Beta angle for section orientation in degrees (default 0.0)
+                id: Element ID (default 0 for auto-increment)
+                tens: Allowable tension or initial compression force (default None)
+                t_limit: Compression limit value. If provided, the compression limit flag is set to True. (default None)
+                non_len: Non-linear length parameter for gap (default None)
+            
+            Examples:
+                ```python
+                # Simple compression-only member
+                Element.Compression(1, 2, stype=1)
+                
+                # Compression-only with tension limit and buckling limit
+                Element.Compression(1, 2, stype=1, tens=27, t_limit=-15)
+                
+                # Gap element with initial gap
+                Element.Compression(3, 4, stype=2, non_len=0.25)
+                ```
+            """
+            self.ID = id
+            self.TYPE = 'COMPTR'
+            self.MATL = mat
+            self.SECT = sect
+            self.NODE = [i, j]
+            self.ANGLE = angle
+            self.STYPE = stype
+            
+            # Handle subtype-specific parameters
+            if stype == 1:  # Compression-only specific
+                if tens is not None:
+                    self.TENS = tens
+                if t_limit is not None:
+                    self.T_LIMIT = t_limit
+                    self.T_bLMT = True
+                    
+            elif stype == 2:  # Gap specific
+                if non_len is not None:
+                    self.NON_LEN = non_len
             _ADD(self)
 
+    class Solid(_common):
+        def __init__(self, nodes: list, mat: int = 1, sect: int = 0, id: int = 0):
+            """
+            Creates a SOLID element for 3D analysis.
+            
+            Parameters:
+                nodes: List of node IDs defining the solid element
+                       - 4 nodes: Tetrahedral element
+                       - 6 nodes: Pentahedral element  
+                       - 8 nodes: Hexahedral element
+                mat: Material property number (default 1)
+                id: Element ID (default 0 for auto-increment)
+            
+            Examples:
+                ```python
+                # Tetrahedral solid element
+                Element.Solid([1, 2, 3, 4], mat=1)
+                
+                # Wedge solid element
+                Element.Solid([1, 2, 3, 4, 5, 6], mat=2)
+                
+                # Hexahedral solid element
+                Element.Solid([1, 2, 3, 4, 5, 6, 7, 8], mat=1, id=200)
+                ```
+            """
+            if len(nodes) not in [4, 6, 8]:
+                raise ValueError("Solid element must have 4, 6, or 8 nodes.")
+            self.ID = id
+            self.TYPE = 'SOLID'
+            self.MATL = mat
+            self.SECT = sect # Solid elements don't use section properties
+            self.NODE = nodes
+            _ADD(self)
 
     
 

midas_civil/_mapi.py

@@ -1,6 +1,13 @@
 import requests
 import sys
 
+
+def Midas_help():
+    """MIDAS Documnetation : https://midas-rnd.github.io/midasapi-python """
+    print("---"*22)
+    print("|   HELP MANUAL : https://midas-rnd.github.io/midasapi-python/   |")
+    print("---"*22,"\n")
+
 class MAPI_PRODUCT:
     product = "civil"
 

{midas_civil-0.0.6.dist-info → midas_civil-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midas_civil
-Version: 0.0.6
+Version: 0.0.8
 Summary: Python library for MIDAS Civil NX
 Author: Sumit Shekhar
 Author-email: sumit.midasit@gmail.com

{midas_civil-0.0.6.dist-info → midas_civil-0.0.8.dist-info}/RECORD

@@ -1,10 +1,10 @@
 midas_civil/__init__.py,sha256=mq1dqMgS92chPxRbKzoA7X33jpgz5y-8a_CpBvQUmJI,510
-midas_civil/_boundary.py,sha256=gGZtVtYk7ey68KOK8aNk7wGrb4OSDLqo69ynorfiJ58,19138
+midas_civil/_boundary.py,sha256=VwDgysWvcwlu2gTfEyxPuXqCp4IXKs2NTn3jUz7Brhg,32390
 midas_civil/_construction.py,sha256=Pj7V-NYCkkT-aMjKXfs1jKa9klsGh48UXDLwn3BLYTY,18225
-midas_civil/_element.py,sha256=RyuJN2XMCrZoBBJ5a0CDbRISocPL0WyuQvYdKes6vMc,7237
+midas_civil/_element.py,sha256=UbXgad_D_yNgTXWRO1zMP2hQB82BaDdMWvGymrg0L1g,18508
 midas_civil/_group.py,sha256=8iZCIB6XEgFz4Z7QEDU3wd7t18xAtNnqetw5Ch1UOeY,10074
 midas_civil/_load.py,sha256=__qVQgbyfAILyoLv8eDGZ_1uMunzzDG1tUu5zWWD-oA,17213
-midas_civil/_mapi.py,sha256=5B6m4csZiERswaVfgI8pQLopfHXmfwaNlJyLsi204Pw,2132
+midas_civil/_mapi.py,sha256=NImeBj8L7rwrYuaeXbaU3-UnCL4Fyp6tB1wf0UpdQp8,2354
 midas_civil/_material.py,sha256=hlgBGL5JTN1-aDL5hXwU9lalAhzoD0pPP-8HE2jCfAs,10711
 midas_civil/_model.py,sha256=wbf3gmFgv0ZB4rphxr-3xLspH-WD7p6aB7PQCNGHA40,14923
 midas_civil/_node.py,sha256=yj17RT3Ei7RafWQVHThjwPGUHe3DTQbuv0MwuDjCJro,3513
@@ -13,8 +13,8 @@ midas_civil/_result_extract.py,sha256=nYR3cYYZVogVje-Y4Y1Lh1S-lCDs_n-1MCwvkmWk6q
 midas_civil/_section.py,sha256=56RWJdyvDr7Es7Is8Fxq3jPCPP57WW8ECCYZzhm6bf0,26375
 midas_civil/_thickness.py,sha256=Mungooyfo0_JJUmjPCr25h0PSSW_TtEfcMa-hz3YGZA,3146
 midas_civil/_utils.py,sha256=eymiqO8KaTKdhVY3saebqNS0BbUUmGmgw3-ELKqew0A,2611
-midas_civil-0.0.6.dist-info/licenses/LICENSE,sha256=zrL4RwZC4rb-by_ZHKXwKdIwcs6ATy59TPZ9HxPHCrs,1071
-midas_civil-0.0.6.dist-info/METADATA,sha256=2LRiSrSpRr3xu9aKBNRAoP-VUCvt1GhonYhWQBDPcRo,1709
-midas_civil-0.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-midas_civil-0.0.6.dist-info/top_level.txt,sha256=_NFmrlN5V9OxJ-PAO4s_om8OA8uupXho3QqZcSsnbuI,12
-midas_civil-0.0.6.dist-info/RECORD,,
+midas_civil-0.0.8.dist-info/licenses/LICENSE,sha256=zrL4RwZC4rb-by_ZHKXwKdIwcs6ATy59TPZ9HxPHCrs,1071
+midas_civil-0.0.8.dist-info/METADATA,sha256=Xfg4B9gsHuRxpVwwbV-xX7mwnrVe1zAHD4noTzCZXzA,1709
+midas_civil-0.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+midas_civil-0.0.8.dist-info/top_level.txt,sha256=_NFmrlN5V9OxJ-PAO4s_om8OA8uupXho3QqZcSsnbuI,12
+midas_civil-0.0.8.dist-info/RECORD,,