midas-civil 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

midas_civil/_node.py

@@ -48,9 +48,9 @@ class Node:
             node_count = max(Node.ids)+1
         
         
-        self.X = x
-        self.Y = y
-        self.Z = z
+        self.X = round(x,6)
+        self.Y = round(y,6)
+        self.Z = round(z,6)
 
         if id == 0 : self.ID = node_count
         if id != 0 : self.ID = id
@@ -94,7 +94,9 @@ class Node:
                 Node.ids.append(self.ID)
                 Node.Grid[cell_loc].append(self)
             
-        _add_node_2_stGroup(self.ID,group)
+        if group !="":
+            _add_node_2_stGroup(self.ID,group)
+
         
 
 
@@ -115,13 +117,14 @@ class Node:
     
     @staticmethod
     def sync():
-        Node.nodes = []
+        Node.nodes=[]
         Node.ids=[]
+        Node.Grid={}
         a = Node.get()
         if a != {'message': ''}:
             if list(a['NODE'].keys()) != []:
                 for j in a['NODE'].keys():
-                    Node(round(a['NODE'][j]['X'],6), round(a['NODE'][j]['Y'],6), round(a['NODE'][j]['Z'],6),int(j),0)
+                    Node(round(a['NODE'][j]['X'],6), round(a['NODE'][j]['Y'],6), round(a['NODE'][j]['Z'],6), id=int(j), group='', merge=0)
 
     @staticmethod
     def delete2(nodes_list):
@@ -142,6 +145,7 @@ class Node:
             MidasAPI("DELETE",f"/db/NODE/")
             Node.nodes=[]
             Node.ids=[]
+            Node.Grid={}
 
     @staticmethod
     def delete():

midas_civil/_result.py

@@ -142,13 +142,13 @@ class LoadCombination:
     
     @classmethod
     def delete(cls, classification = "All", ids = []):
-        json = LoadCombination.call_json(classification)
+        json = LoadCombination.json(classification)
         a = ""
         for i in range(len(ids)):
             a += str(ids[i]) + ","
         a = "/" + a[:-1]
         if json == {}: 
-            print("No load combinations are defined to delete.  Def")
+            print("No load combinations are defined to delete.")
         for i in list(json.keys()):
             MidasAPI("DELETE",LoadCombination.com_map.get(i) + a)
 #---------------------------------------------------------------------------------------------------------------

midas_civil/_result_extract.py

@@ -2,6 +2,7 @@ import polars as pl
 import json
 import xlsxwriter
 from ._mapi import *
+from ._model import *
 # js_file = open('JSON_Excel Parsing\\test.json','r')
 
 # print(js_file)
@@ -125,7 +126,7 @@ class Result :
 
     # ---------- User defined TABLE (Dynamic Report Table) ------------------------------
     @staticmethod
-    def UserDefinedTable(tableName:str, summary=0):
+    def UserDefinedTable(tableName:str, summary=0, force_unit='KN',len_unit='M'):
         js_dat = {
             "Argument": {
                 "TABLE_NAME": tableName,
@@ -135,11 +136,11 @@ class Result :
                 }
             }
         }
-
+        Model.units(force=force_unit,length=len_unit)
         ss_json = MidasAPI("POST","/post/TABLE",js_dat)
         return _JSToDF_UserDefined(tableName,ss_json,summary)
     
-    # ---------- Result TABLE ------------------------------
+    # ---------- LIST ALL USER DEFINED TABLE ------------------------------
     @staticmethod
     def UserDefinedTables_print():
         ''' Print all the User defined table names '''
@@ -158,18 +159,17 @@ class Result :
 
     # ---------- Result TABLE ------------------------------
     @staticmethod
-    def ResultTable(tabletype:str,elements:list=[],loadcase:list=[],cs_stage=[],force_unit='kN',len_unit='m'):
+    def ResultTable(tabletype:str,keys=[],loadcase:list=[],cs_stage=[],force_unit='KN',len_unit='M'):
         '''
             TableType : REACTIONG | REACTIONL | DISPLACEMENTG | DISPLACEMENTL | TRUSSFORCE | TRUSSSTRESS
+            Keys : List{int} -> Element/ Node IDs  |  str -> Structure Group Name
+            Loadcase : Loadcase name followed by type. eg. DeadLoad(ST)
         '''
+
         js_dat = {
             "Argument": {
                 "TABLE_NAME": "SS_Table",
                 "TABLE_TYPE": tabletype,
-                "UNIT": {
-                    "FORCE": force_unit,
-                    "DIST": len_unit
-                },
                 "STYLES": {
                     "FORMAT": "Fixed",
                     "PLACE": 12
@@ -185,9 +185,17 @@ class Result :
                 js_dat["Argument"]['STAGE_STEP'] = cs_stage
 
 
-        if elements!=[]: js_dat["Argument"]['NODE_ELEMS'] = {"KEYS": elements}
+        if isinstance(keys,list):
+            if keys!=[]:
+                js_dat["Argument"]['NODE_ELEMS'] = {"KEYS": keys}
+        elif isinstance(keys,str):
+            js_dat["Argument"]['NODE_ELEMS'] = {"STRUCTURE_GROUP_NAME": keys}
+
+
         if loadcase!=[]: js_dat["Argument"]['LOAD_CASE_NAMES'] = loadcase
 
+
+        Model.units(force=force_unit,length=len_unit)
         ss_json = MidasAPI("POST","/post/table",js_dat)
         return _JSToDF_ResTable(ss_json)
 

midas_civil/_settlement.py

@@ -0,0 +1,160 @@
+from ._mapi import *
+
+class Settlement:
+    
+    @classmethod
+    def create(cls):
+        """Creates Settlement Load in MIDAS Civil NX"""
+        if cls.Group.data != []: cls.Group.create()
+        if cls.Case.data != []: cls.Case.create()
+    
+    @classmethod
+    def delete(cls):
+        """Deletes Settlement load from MIDAS Civil NX and Python"""
+        cls.Group.delete()
+        cls.Case.delete()
+    
+    @classmethod
+    def sync(cls):
+        """Sync Settlement load from MIDAS Civil NX to Python"""
+        cls.Group.sync()
+        cls.Case.sync()
+    
+    class Group:
+        """ 
+        Parameters:
+            name: Settlement group name (string)
+            displacement: Settlement displacement value (number)
+            node_list: List of node IDs to include in the group (array of integers)
+            id: Group ID (optional, auto-generated if not provided)
+        
+        Examples:
+            ```python
+            Settlement.Group("SG1", 0.025, [100, 101])
+            Settlement.Group("SG2", 0.015, [102, 103])
+            ```
+        """
+        data = []
+
+        def __init__(self, name, displacement, node_list, id=""):
+            self.NAME = name
+            self.SETTLE = displacement
+            self.ITEMS = node_list
+            if id == "": id = len(Settlement.Group.data) + 1
+            self.ID = id
+            
+            Settlement.Group.data.append(self)
+
+        @classmethod
+        def json(cls):
+            json = {"Assign": {}}
+            for i in cls.data:
+                json["Assign"][str(i.ID)] = {
+                    "NAME": i.NAME,
+                    "SETTLE": i.SETTLE,
+                    "ITEMS": i.ITEMS
+                }
+            return json
+        
+        @staticmethod
+        def create():
+            MidasAPI("PUT", "/db/smpt", Settlement.Group.json())
+        
+        @staticmethod
+        def get():
+            return MidasAPI("GET", "/db/smpt")
+        
+        @classmethod
+        def delete(cls):
+            cls.data = []
+            return MidasAPI("DELETE", "/db/smpt")
+        
+        @classmethod
+        def sync(cls):
+            cls.data = []
+            a = cls.get()
+            if a != {'message': ''}:
+                for i in a['SMPT'].keys():
+                    Settlement.Group(
+                        a['SMPT'][i]['NAME'], 
+                        a['SMPT'][i]['SETTLE'], 
+                        a['SMPT'][i]['ITEMS'],
+                        int(i)
+                    )
+
+    
+    class Case:
+        """
+        
+        Parameters:
+            name: Settlement load case name (string)
+            settlement_groups: List of settlement group names to include (array of strings, default [])
+            factor: Settlement scale factor (number, default 1.0)
+            min_groups: Minimum number of settlement groups (integer, default 1)
+            max_groups: Maximum number of settlement groups (integer, default 1)
+            desc: Description of the settlement case (string, default "")
+            id: Case ID (optional, auto-generated if not provided)
+        
+        Examples:
+            ```python
+            Settlement.Case("SMLC1", ["SG1"], 1.2, 1, 1, "Foundation Settlement Case")
+            Settlement.Case("SMLC2", ["SG1", "SG2"], 1.0, 1, 2, "Combined Settlement")
+            ```
+        """
+        data = []
+
+        def __init__(self, name, settlement_groups=[],factor=1.0, min_groups=1, max_groups=1, desc="", id=""):
+            self.NAME = name
+            self.DESC = desc
+            self.FACTOR = factor
+            self.MIN = min_groups
+            self.MAX = max_groups
+            self.ST_GROUPS = settlement_groups
+            if id == "": id = len(Settlement.Case.data) + 1
+            self.ID = id
+            
+            Settlement.Case.data.append(self)
+
+        @classmethod
+        def json(cls):
+            json = {"Assign": {}}
+            for i in cls.data:
+                json["Assign"][str(i.ID)] = {
+                    "NAME": i.NAME,
+                    "DESC": i.DESC,
+                    "FACTOR": i.FACTOR,
+                    "MIN": i.MIN,
+                    "MAX": i.MAX,
+                    "ST_GROUPS": i.ST_GROUPS
+                }
+            return json
+        
+        @staticmethod
+        def create():
+            MidasAPI("PUT", "/db/smlc", Settlement.Case.json())
+        
+        @staticmethod
+        def get():
+            return MidasAPI("GET", "/db/smlc")
+        
+        @classmethod
+        def delete(cls):
+            cls.data = []
+            return MidasAPI("DELETE", "/db/smlc")
+        
+        @classmethod
+        def sync(cls):
+            cls.data = []
+            a = cls.get()
+            if a != {'message': ''}:
+                for i in a['SMLC'].keys():
+                    Settlement.Case(
+                        a['SMLC'][i]['NAME'],
+                        a['SMLC'][i]['DESC'], 
+                        a['SMLC'][i]['FACTOR'],
+                        a['SMLC'][i]['MIN'],
+                        a['SMLC'][i]['MAX'],
+                        a['SMLC'][i]['ST_GROUPS'],
+                        int(i)
+                    )
+

midas_civil/_temperature.py

@@ -16,6 +16,8 @@ class Temperature:
         if cls.System.temps: cls.System.create()
         if cls.Element.temps: cls.Element.create()
         if cls.Gradient.temps: cls.Gradient.create()
+        if cls.Nodal.temps: cls.Nodal.create()
+        if cls.BeamSection.temps: cls.BeamSection.create()        
 
     @classmethod
     def delete(cls):
@@ -23,6 +25,8 @@ class Temperature:
         cls.System.delete()
         cls.Element.delete()
         cls.Gradient.delete()
+        cls.Nodal.delete()
+        cls.BeamSection.delete()
         
 
     @classmethod
@@ -31,7 +35,9 @@ class Temperature:
         cls.System.sync()
         cls.Element.sync()
         cls.Gradient.sync()
-        
+        cls.Nodal.sync()
+        cls.BeamSection.sync()
+                
     # --------------------------------------------------------------------------------------------------
     # System Temperature
     # --------------------------------------------------------------------------------------------------
@@ -351,3 +357,258 @@ class Temperature:
             return MidasAPI("DELETE", "/db/gtmp")
 
     # --------------------------------------------------------------------------------------------------
+    # Nodal Temperature
+    # --------------------------------------------------------------------------------------------------
+    class Nodal:
+        """
+        Create Nodal Temperature  
+        
+        Parameters:
+            node (int): Node ID
+            temperature (float): Temperature value  
+            lcname (str): Load case name **(Must exist in the model)**
+            group (str): Load group name (default "")
+            id (int): Temperature ID (optional)
+        
+        Example:
+            Temperature.Nodal(6, 10, "Test")
+        """
+        temps = []
+        
+        def __init__(self, node, temperature, lcname, group="", id=None):
+            if group:
+                chk = 0
+                try:
+                    a = [v['NAME'] for v in Group.Load.json()["Assign"].values()]
+                    if group in a:
+                        chk = 1
+                except:
+                    pass
+                if chk == 0:
+                    Group.Load(group)
+            
+            self.NODE = node
+            self.TEMPER = temperature
+            self.LCNAME = lcname
+            self.GROUP_NAME = group
+            
+            if id is None:
+                existing_ids = []
+                for temp in Temperature.Nodal.temps:
+                    if temp.NODE == node:
+                        existing_ids.extend([item.get('ID', 0) for item in temp.ITEMS if hasattr(temp, 'ITEMS')])
+                self.ID = max(existing_ids, default=0) + 1
+            else:
+                self.ID = id
+            
+            existing_temp = None
+            for temp in Temperature.Nodal.temps:
+                if temp.NODE == node:
+                    existing_temp = temp
+                    break
+            
+            item_data = {
+                "ID": self.ID, "LCNAME": self.LCNAME,
+                "GROUP_NAME": self.GROUP_NAME, "TEMPER": self.TEMPER
+            }
+
+            if existing_temp:
+                if not hasattr(existing_temp, 'ITEMS'):
+                    existing_temp.ITEMS = []
+                existing_temp.ITEMS.append(item_data)
+            else:
+                self.ITEMS = [item_data]
+                Temperature.Nodal.temps.append(self)
+
+        @classmethod
+        def json(cls):
+            """Creates JSON with 'Assign' key from Nodal Temperature objects defined in Python"""
+            json_data = {"Assign": {}}
+            for temp in cls.temps:
+                json_data["Assign"][str(temp.NODE)] = {"ITEMS": temp.ITEMS}
+            return json_data
+
+        @staticmethod
+        def create():
+            """Creates Nodal Temperatures in MIDAS Civil NX"""
+            MidasAPI("PUT", "/db/ntmp", Temperature.Nodal.json())
+
+        @staticmethod
+        def get():
+            """Get the JSON of Nodal Temperatures from MIDAS Civil NX"""
+            return MidasAPI("GET", "/db/ntmp")
+
+        @staticmethod
+        def sync():
+            """Sync Nodal Temperatures from MIDAS Civil NX to Python"""
+            Temperature.Nodal.temps = []
+            a = Temperature.Nodal.get()
+            
+            if a and 'NTMP' in a:
+                temp_data = a.get('NTMP', {})
+                for node_id, node_data in temp_data.items():
+                    node_obj = type('obj', (object,), {
+                        'NODE': int(node_id),
+                        'ITEMS': node_data.get('ITEMS', [])
+                    })()
+                    Temperature.Nodal.temps.append(node_obj)
+
+        @staticmethod
+        def delete():
+            """Delete Nodal Temperatures from MIDAS Civil NX and Python"""
+            Temperature.Nodal.temps = []
+            return MidasAPI("DELETE", "/db/ntmp")
+
+
+    # --------------------------------------------------------------------------------------------------
+    # Beam Section Temperature
+    # --------------------------------------------------------------------------------------------------
+    class BeamSection:
+        """
+        Create Beam Section Temperature Object in Python.
+        
+        Parameters:
+            element (int): Element ID to apply the load.
+            lcname (str): Load Case Name (must exist in the model).
+            section_type (str, optional): 'General' or 'PSC'. Defaults to 'General'.
+            type (str, optional): 'Element' or 'Input'. Defaults to 'Element'.
+            group (str, optional): Load Group Name.
+            id (int, optional): Load ID.
+            dir (str, optional): Direction, 'LY' or 'LZ'. Defaults to 'LZ'.
+            ref_pos (str, optional): Reference Position, 'Centroid', 'Top', or 'Bot'. Defaults to 'Centroid'.
+            val_b (float, optional): B Value.
+            val_h1 (float, optional): H1 Value.
+            val_h2 (float, optional): H2 Value.
+            val_t1 (float, optional): T1 Value.
+            val_t2 (float, optional): T2 Value.
+            elast (float, optional): Modulus of Elasticity (required for 'Input' type).
+            thermal (float, optional): Thermal Coefficient (required for 'Input' type).
+            psc_ref (int, optional): Reference for PSC, 0 for Top, 1 for Bottom.
+            psc_opt_b (int, optional): B-Type option for PSC. (0 for Section type)
+            psc_opt_h1 (int, optional): H1-Type option for PSC. (0 - Z1 , 1- Z2 ,2 - Z2)
+            psc_opt_h2 (int, optional): H2-Type option for PSC.  (0 - Z1 , 1- Z2 ,2 - Z2)
+        """
+        temps = []
+
+        def __init__(self, element, lcname, section_type='General', type='Element', group="", id=None, 
+                    dir='LZ', ref_pos='Centroid', val_b=0, val_h1=0, val_h2=0, val_t1=0, val_t2=0,
+                    elast=None, thermal=None, psc_ref=0, psc_opt_b=1, psc_opt_h1=3, psc_opt_h2=3):
+
+            # Validate required parameters for Input type
+            if type.upper() == 'INPUT':
+                if elast is None or thermal is None:
+                    raise ValueError("For 'Input' type, both 'elast' and 'thermal' parameters are required.")
+
+            # Handle load group creation
+            if group:
+                chk = 0
+                try:
+                    a = [v['NAME'] for v in Group.Load.json()["Assign"].values()]
+                    if group in a:
+                        chk = 1
+                except:
+                    pass
+                if chk == 0:
+                    Group.Load(group)
+            
+            self.ELEMENT = element
+
+            # Auto-assign ID if not provided
+            if id is None:
+                existing_ids = []
+                for temp in Temperature.BeamSection.temps:
+                    if temp.ELEMENT == element:
+                        existing_ids.extend([item.get('ID', 0) for item in temp.ITEMS if hasattr(temp, 'ITEMS')])
+                self.ID = max(existing_ids, default=0) + 1
+            else:
+                self.ID = id
+            
+            # Construct the nested dictionary for vSECTTMP
+            vsec_item = {
+                "TYPE": type.upper(),
+                "VAL_B": val_b,
+                "VAL_H1": val_h1,
+                "VAL_H2": val_h2,
+                "VAL_T1": val_t1,
+                "VAL_T2": val_t2,
+            }
+
+            is_psc = section_type.lower() == 'psc'
+            
+            # Add material properties for Input type
+            if type.upper() == 'INPUT':
+                vsec_item["ELAST"] = elast
+                vsec_item["THERMAL"] = thermal
+            
+            # Add PSC-specific parameters
+            if is_psc:
+                vsec_item["REF"] = psc_ref
+                vsec_item["OPT_B"] = psc_opt_b
+                vsec_item["OPT_H1"] = psc_opt_h1
+                vsec_item["OPT_H2"] = psc_opt_h2
+
+            # Construct the main item dictionary
+            item_data = {
+                "ID": self.ID,
+                "LCNAME": lcname,
+                "GROUP_NAME": group,
+                "DIR": dir,
+                "REF": ref_pos,
+                "NUM": 1,
+                "bPSC": is_psc,
+                "vSECTTMP": [vsec_item]
+            }
+
+            # Check if an object for this element already exists
+            existing_temp = None
+            for temp in Temperature.BeamSection.temps:
+                if temp.ELEMENT == element:
+                    existing_temp = temp
+                    break
+
+            if existing_temp:
+                if not hasattr(existing_temp, 'ITEMS'):
+                    existing_temp.ITEMS = []
+                existing_temp.ITEMS.append(item_data)
+            else:
+                self.ITEMS = [item_data]
+                Temperature.BeamSection.temps.append(self)
+        
+        @classmethod
+        def json(cls):
+            """Creates JSON from Beam Section Temperature objects defined in Python"""
+            json_data = {"Assign": {}}
+            for temp in cls.temps:
+                json_data["Assign"][str(temp.ELEMENT)] = {"ITEMS": temp.ITEMS}
+            return json_data
+
+        @staticmethod
+        def create():
+            """Creates Beam Section Temperatures in MIDAS Civil NX"""
+            MidasAPI("PUT", "/db/btmp", Temperature.BeamSection.json())
+
+        @staticmethod
+        def get():
+            """Get the JSON of Beam Section Temperatures from MIDAS Civil NX"""
+            return MidasAPI("GET", "/db/btmp")
+
+        @staticmethod
+        def sync():
+            """Sync Beam Section Temperatures from MIDAS Civil NX to Python"""
+            Temperature.BeamSection.temps = []
+            a = Temperature.BeamSection.get()
+            
+            if a and 'BTMP' in a:
+                temp_data = a.get('BTMP', {})
+                for element_id, element_data in temp_data.items():
+                    element_obj = type('obj', (object,), {
+                        'ELEMENT': int(element_id),
+                        'ITEMS': element_data.get('ITEMS', [])
+                    })()
+                    Temperature.BeamSection.temps.append(element_obj)
+
+        @staticmethod
+        def delete():
+            """Delete Beam Section Temperatures from MIDAS Civil NX and Python"""
+            Temperature.BeamSection.temps = []
+            return MidasAPI("DELETE", "/db/btmp")