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

midas_civil/_group.py

@@ -1,5 +1,24 @@
 
 from ._mapi import *
+
+
+
+# ----------- HELPER FUNCTION -----------
+# --------   ADD ELEMENT TO STRUCTURE GROUP -------
+
+def _add_elem_2_stGroup(elemID,groupName):
+    up = 0
+    if groupName in Group.Structure._names:
+        for i in Group.Structure.Groups:
+            if i.NAME == groupName:
+                i.ELIST = list(i.ELIST + [elemID])
+    else:
+        Group.Structure(groupName)
+        _add_elem_2_stGroup(elemID,groupName)
+
+
+
+
 #---------------------------------------------------------------------------------------------------------------
 class Group:
 
@@ -35,6 +54,7 @@ class Group:
 
         Groups = []
         ids=[]
+        _names = []
         url= "/db/GRUP"
 
         def __init__(self, name, nlist=[],elist=[]):
@@ -46,6 +66,7 @@ class Group:
             self.NLIST = list(set(nlist))
             Group.Structure.ids.append(self.ID)
             Group.Structure.Groups.append(self)
+            Group.Structure._names.append(self.NAME)
     
         @classmethod
         def update(cls, name,operation = "r", nlist = [],elist = [] ):
@@ -65,7 +86,7 @@ class Group:
         
         @classmethod
         def json(cls):
-            "Generates the json file for all defined structure groups."
+            """Generates the json file for all defined structure groups."""
             json = {"Assign":{}}
             for i in cls.Groups:
                 json["Assign"][i.ID] = {

midas_civil/_load.py

@@ -122,6 +122,11 @@ class Load:
         def get():
             return MidasAPI("GET","/db/BODF")
         
+        @classmethod
+        def delete(cls):
+            cls.data=[]
+            return MidasAPI("DELETE","/db/BODF")
+        
         @staticmethod
         def sync():
             a = Load.SW.get()
@@ -264,7 +269,8 @@ class Load:
             D = (D + [0] * 4)[:4]
             P = (P + [0] * 4)[:4]
             if P == [0, 0, 0, 0]: P = [value, value, 0, 0]
-            if eccn_type != 0 or eccn_type != 1: eccn_type = 0
+            if eccn_type not in (0, 1):
+                eccn_type = 1
             if direction not in ("GX", "GY", "GZ", "LX", "LY", "LZ"): direction = "GZ"
             if eccn_dir not in ("GX", "GY", "GZ", "LX", "LY", "LZ"): eccn_dir = "LY"
             if cmd not in ("BEAM", "LINE", "TYPICAL"): cmd = "BEAM"
@@ -381,4 +387,321 @@ class Load:
                             Load.Beam(i,a['BMLD'][i]['ITEMS'][j]['LCNAME'], a['BMLD'][i]['ITEMS'][j]['P'][0], a['BMLD'][i]['ITEMS'][j]['GROUP_NAME'],
                                 a['BMLD'][i]['ITEMS'][j]['DIRECTION'], a['BMLD'][i]['ITEMS'][j]['ID'], a['BMLD'][i]['ITEMS'][j]['D'], a['BMLD'][i]['ITEMS'][j]['P'],
                                 a['BMLD'][i]['ITEMS'][j]['CMD'], a['BMLD'][i]['ITEMS'][j]['TYPE'], a['BMLD'][i]['ITEMS'][j]['USE_ECCEN'], a['BMLD'][i]['ITEMS'][j]['USE_PROJECTION'])
-    #---------------------------------------------------------------------------------------------------------------
+  
+  
+    #--------------------------------  Load to Mass  ------------------------------------------------------------
+
+    #20 Class to add Load to Mass:
+    class LoadToMass:
+        """Creates load to mass conversion and converts to JSON format.
+        Example: LoadToMass("Z", ["DL", "LL"], [1.0, 0.5])
+        """
+        data = []
+        
+        def __init__(self, dir, load_case, load_factor=None, nodal_load=True, beam_load=True, 
+                    floor_load=True, pressure=True, gravity=9.806):
+            """
+            dir (str): Mass Direction - "X", "Y", "Z", "XY", "YZ", "XZ", "XYZ"
+            load_case (list): List of load case names
+            load_factor (list, optional): List of scale factors corresponding to load cases. 
+                                        If None or shorter than load_case, remaining factors default to 1.0
+            nodal_load (bool): Include nodal loads. Defaults to True
+            beam_load (bool): Include beam loads. Defaults to True  
+            floor_load (bool): Include floor loads. Defaults to True
+            pressure (bool): Include pressure loads. Defaults to True
+            gravity (float): Gravity acceleration. Defaults to 9.806
+            """
+            
+            # Validate direction
+            valid_directions = ["X", "Y", "Z", "XY", "YZ", "XZ", "XYZ"]
+            if dir not in valid_directions:
+                dir = "XYZ"  # Default to XYZ if invalid
+                
+            # Ensure load_case is a list
+            if not isinstance(load_case, list):
+                load_case = [load_case]
+                
+            # Handle load_factor - ensure it matches load_case length
+            if load_factor is None:
+                load_factor = [1.0] * len(load_case)
+            elif not isinstance(load_factor, list):
+                load_factor = [load_factor]
+                
+            # Pad load_factor with 1.0 if shorter than load_case
+            while len(load_factor) < len(load_case):
+                load_factor.append(1.0)
+                
+            # Check if load cases exist - give warning if not
+            for case in load_case:
+                chk = 0
+                for i in Load_Case.cases:
+                    if case in i.NAME:
+                        chk = 1
+                if chk == 0:
+                    print(f"Warning: Load case '{case}' does not exist!")
+            
+            self.DIR = dir
+            self.LOAD_CASE = load_case
+            self.LOAD_FACTOR = load_factor
+            self.NODAL = nodal_load
+            self.BEAM = beam_load
+            self.FLOOR = floor_load
+            self.PRESSURE = pressure
+            self.GRAVITY = gravity
+            
+            Load.LoadToMass.data.append(self)
+        
+        @classmethod
+        def json(cls):
+            json_data = {"Assign": {}}
+            
+            for load_obj in enumerate(cls.data):
+                # Create vLC array with load case names and factors
+                vlc_array = []
+                for i, case_name in enumerate(load_obj.LOAD_CASE):
+                    vlc_array.append({
+                        "LCNAME": case_name,
+                        "FACTOR": load_obj.LOAD_FACTOR[i]
+                    })
+                
+                json_data["Assign"]["1"] = {
+                    "DIR": load_obj.DIR,
+                    "bNODAL": load_obj.NODAL,
+                    "bBEAM": load_obj.BEAM, 
+                    "bFLOOR": load_obj.FLOOR,
+                    "bPRES": load_obj.PRESSURE,
+                    "GRAV": load_obj.GRAVITY,
+                    "vLC": vlc_array
+                }
+                
+            return json_data
+        
+        @classmethod
+        def create(cls):
+            return MidasAPI("PUT", "/db/ltom", cls.json())
+        
+        @classmethod
+        def get(cls):
+            return MidasAPI("GET", "/db/ltom")
+        
+        @classmethod
+        def delete(cls):
+            cls.data = []
+            return MidasAPI("DELETE", "/db/ltom")
+        
+        @classmethod
+        def sync(cls):
+            cls.data = []
+            response = cls.get()
+            
+            if response != {'message': ''}:
+                for key, item_data in response.get('LTOM', {}).items():
+                    # Extract load cases and factors from vLC array
+                    load_cases = []
+                    load_factors = []
+                    
+                    for lc_item in item_data.get('vLC'):
+                        load_cases.append(lc_item.get('LCNAME'))
+                        load_factors.append(lc_item.get('FACTOR'))
+                    
+                    # Create LoadToMass object
+                    Load.LoadToMass(
+                        dir=item_data.get('DIR'),
+                        load_case=load_cases,
+                        load_factor=load_factors,
+                        nodal_load=item_data.get('bNODAL'),
+                        beam_load=item_data.get('bBEAM'),
+                        floor_load=item_data.get('bFLOOR'),
+                        pressure=item_data.get('bPRES'),
+                        gravity=item_data.get('GRAV')
+                    )
+
+    #-----------------------------------------------------------NodalMass-----------------
+    #21NodalMass
+
+    class NodalMass:
+        """Creates nodal mass and converts to JSON format.
+        Example: NodalMass(1.5, 2.0, 3.0, 0.1, 0.2, 0.3)
+        """
+        data = []
+        
+        def __init__(self, mX, mY=0, mZ=0, rmX=0, rmY=0, rmZ=0):
+            """
+            mX (float): Translational Lumped Mass in GCS X-direction (Required)
+            mY (float): Translational Lumped Mass in GCS Y-direction. Defaults to 0
+            mZ (float): Translational Lumped Mass in GCS Z-direction. Defaults to 0
+            rmX (float): Rotational Mass Moment of Inertia about GCS X-axis. Defaults to 0
+            rmY (float): Rotational Mass Moment of Inertia about GCS Y-axis. Defaults to 0
+            rmZ (float): Rotational Mass Moment of Inertia about GCS Z-axis. Defaults to 0
+            """
+            self.MX = mX
+            self.MY = mY
+            self.MZ = mZ
+            self.RMX = rmX
+            self.RMY = rmY
+            self.RMZ = rmZ
+            
+            Load.NodalMass.data.append(self)
+        
+        @classmethod
+        def json(cls):
+            json_data = {"Assign": {}}
+            
+            # Use the last added mass data (or first if only one exists)
+            if cls.data:
+                mass_obj = cls.data[-1]  # Get the most recent mass object
+                json_data["Assign"]["1"] = {
+                    "mX": mass_obj.MX,
+                    "mY": mass_obj.MY,
+                    "mZ": mass_obj.MZ,
+                    "rmX": mass_obj.RMX,
+                    "rmY": mass_obj.RMY,
+                    "rmZ": mass_obj.RMZ
+                }
+            
+            return json_data
+        
+        @classmethod
+        def create(cls):
+            return MidasAPI("PUT", "/db/nmas", cls.json())
+        
+        @classmethod
+        def get(cls):
+            return MidasAPI("GET", "/db/nmas")
+        
+        @classmethod
+        def delete(cls):
+            cls.data = []
+            return MidasAPI("DELETE", "/db/nmas")
+        
+        @classmethod
+        def sync(cls):
+            cls.data = []
+            response = cls.get()
+            
+            if response != {'message': ''}:
+                nmas_data = response.get('NMAS', {})
+                if "1" in nmas_data:
+                    item_data = nmas_data["1"]
+                    Load.NodalMass(
+                        mX=item_data.get('mX'),
+                        mY=item_data.get('mY'),
+                        mZ=item_data.get('mZ'),
+                        rmX=item_data.get('rmX'),
+                        rmY=item_data.get('rmY'),
+                        rmZ=item_data.get('rmZ')
+                    )
+
+#-----------------------------------------------------------Specified Displacement-------------------------------------------------
+    class SpDisp:
+        """Creates specified displacement loads and converts to JSON format.
+        Example: SpDisp(10, "LL", "Group1", [1.5, 1.5, 1.5, 1.5, 0.5, 0.5])
+        """
+        data = []
+        
+        def __init__(self, node, load_case, load_group="", values=[0, 0, 0, 0, 0, 0], id=""):
+            """
+            node (int): Node number (Required)
+            load_case (str): Load case name (Required)
+            load_group (str, optional): Load group name. Defaults to ""
+            values (list): Displacement values [Dx, Dy, Dz, Rx, Ry, Rz]. Defaults to [0, 0, 0, 0, 0, 0]
+            id (str, optional): Load ID. Defaults to auto-generated
+            """
+            
+            # Check if load case exists - give warning if not
+            chk = 0
+            for i in Load_Case.cases:
+                if load_case in i.NAME:
+                    chk = 1
+            if chk == 0:
+                print(f"Warning: Load case '{load_case}' does not exist!")
+                
+            # Check if load group exists and create if specified
+            if load_group != "":
+                chk = 0
+                a = [v['NAME'] for v in Group.Load.json()["Assign"].values()]
+                if load_group in a:
+                    chk = 1
+                if chk == 0:
+                    print(f"Warning: Load group '{load_group}' does not exist!")
+            
+            # Ensure values is a list of 6 elements [Dx, Dy, Dz, Rx, Ry, Rz]
+            if not isinstance(values, list):
+                values = [0, 0, 0, 0, 0, 0]
+            
+            # Pad or truncate to exactly 6 values
+            values = (values + [0] * 6)[:6]
+            
+            self.NODE = node
+            self.LCN = load_case
+            self.LDGR = load_group
+            self.VALUES = values
+            
+            if id == "":
+                id = len(Load.SpDisp.data) + 1
+            self.ID = id
+            
+            Load.SpDisp.data.append(self)
+        
+        @classmethod
+        def json(cls):
+            json_data = {"Assign": {}}
+            
+            for i in cls.data:
+                if i.NODE not in list(json_data["Assign"].keys()):
+                    json_data["Assign"][i.NODE] = {"ITEMS": []}
+                
+                # Create VALUES array with OPT_FLAG logic
+                values_array = []
+                displacement_labels = ["Dx", "Dy", "Dz", "Rx", "Ry", "Rz"]
+                
+                for idx, value in enumerate(i.VALUES):
+                    values_array.append({
+                        "OPT_FLAG": value != 0,  # True if value > 0, False if value = 0
+                        "DISPLACEMENT": float(value)
+                    })
+                
+                json_data["Assign"][i.NODE]["ITEMS"].append({
+                    "ID": i.ID,
+                    "LCNAME": i.LCN,
+                    "GROUP_NAME": i.LDGR,
+                    "VALUES": values_array
+                })
+                
+            return json_data
+        
+        @classmethod
+        def create(cls):
+            return MidasAPI("PUT", "/db/sdsp", cls.json())
+        
+        @classmethod
+        def get(cls):
+            return MidasAPI("GET", "/db/sdsp")
+        
+        @classmethod
+        def delete(cls):
+            cls.data = []
+            return MidasAPI("DELETE", "/db/sdsp")
+        
+        @classmethod
+        def sync(cls):
+            cls.data = []
+            response = cls.get()
+            
+            if response != {'message': ''}:
+                for node_key in response['SDSP'].keys():
+                    for j in range(len(response['SDSP'][node_key]['ITEMS'])):
+                        item = response['SDSP'][node_key]['ITEMS'][j]
+                        
+                        # Extract displacement values from VALUES array
+                        values = []
+                        for val_item in item.get('VALUES', []):
+                            values.append(val_item.get('DISPLACEMENT', 0))
+                        
+                        Load.SpDisp(
+                            int(node_key),
+                            item['LCNAME'],
+                            item['GROUP_NAME'],
+                            values,
+                            item['ID']
+                        )

midas_civil/_material.py

@@ -58,7 +58,7 @@ class Material:
         if Material.mats!=[] : Material.create_only()
         if CreepShrinkage.mats!=[] : CreepShrinkage.create()
         if CompStrength.mats!=[] : CompStrength.create()
-        if TDLink.json()!={'Assign':{}} : TDLink.create()
+        if TDMatLink.json()!={'Assign':{}} : TDMatLink.create()
         
     
     @staticmethod
@@ -1592,23 +1592,23 @@ class CompStrength:
 
 
 
-class TDLink:
+class TDMatLink:
     mats = {}
     def __init__(self,matID,CnSName='',CompName=''):
 
-        TDLink.mats[str(matID)]={
+        TDMatLink.mats[str(matID)]={
             "TDMT_NAME": CnSName,
             "TDME_NAME": CompName
         }
     
     @classmethod
     def json(cls):
-        json = {"Assign": TDLink.mats}
+        json = {"Assign": TDMatLink.mats}
         return json
     
     @staticmethod
     def create():
-        MidasAPI("PUT","/db/TMAT",TDLink.json())
+        MidasAPI("PUT","/db/TMAT",TDMatLink.json())
         
     @staticmethod
     def get():
@@ -1618,16 +1618,16 @@ class TDLink:
     @staticmethod
     def delete():
         MidasAPI("DELETE","/db/TMAT")
-        TDLink.mats={}
+        TDMatLink.mats={}
 
     @staticmethod
     def sync():
-        a = TDLink.get()
+        a = TDMatLink.get()
         if a != {'message': ''}:
             if list(a['TMAT'].keys()) != []:
-                TDLink.mats = []
-                TDLink.ids=[]
+                TDMatLink.mats = []
+                TDMatLink.ids=[]
                 for j in a['TMAT'].keys():
-                    TDLink(a['TMAT'][j], int(j))
+                    TDMatLink(a['TMAT'][j], int(j))
 
 #-------------------------------------------------------------------------------------------------

midas_civil/_model.py

@@ -341,6 +341,44 @@ class Model:
 
 
             MidasAPI("PUT","/db/PJCF",js)
+    
+    @staticmethod
+    def exportJSON(location=""):
+        """Export the model data as JSON file
+        Model.exportJSON('D:\\model.json')"""
+        if location.endswith('.json'):
+            MidasAPI("POST","/doc/EXPORT",{"Argument":str(location)})
+        else:
+            print('⚠️  Location data in exportJSON is missing file extension')
+
+    @staticmethod
+    def exportMCT(location=""):
+        """Export the model data as MCT file
+        Model.exportMCT('D:\\model.mct')"""
+        if location.endswith('.mct'):
+            MidasAPI("POST","/doc/EXPORTMXT",{"Argument":str(location)})
+        else:
+            print('⚠️  Location data in exportMCT is missing file extension')
+
+    
+    @staticmethod
+    def importJSON(location=""):
+        """Import JSON data file in MIDAS CIVIL NX
+        Model.importJSON('D:\\model.json')"""
+        if location.endswith('.json'):
+            MidasAPI("POST","/doc/IMPORT",{"Argument":str(location)})
+        else:
+            print('⚠️  Location data in importJSON is missing file extension')
+
+    @staticmethod
+    def importMCT(location=""):
+        """Import MCT data file in MIDAS CIVIL NX
+        Model.importMCT('D:\\model.mct')"""
+        if location.endswith('.mct'):
+            MidasAPI("POST","/doc/IMPORTMXT",{"Argument":str(location)})
+        else:
+            print('⚠️  Location data in importMCT is missing file extension')
+