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

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']
+                        )