midas-civil 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

midas_civil/_node.py

@@ -12,7 +12,10 @@ def dist_tol(a,b):
 def cell(point,size=1): #SIZE OF GRID
     return (int(point.X//size),int(point.Y//size),int(point.Z//size))
 
-#-- NEW SYSTEM
+
+# -------- FUNCTIONS ARE DEFINED BELOW TO RECOGNISE NODE CLASS ----------------
+
+
 
 #5 Class to create nodes
 class Node:
@@ -48,9 +51,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 +97,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)
+
         
 
 
@@ -159,6 +164,16 @@ class Node:
 
 
 
+# ---- GET NODE OBJECT FROM ID ----------
+
+def nodeByID(nodeID:int) -> Node:
+    ''' Return Node object with the input ID '''
+    for node in Node.nodes:
+        if node.ID == nodeID:
+            return node
+        
+    print(f'There is no node with ID {nodeID}')
+    return None
 
 
 

midas_civil/_result.py

@@ -111,7 +111,7 @@ class LoadCombination:
     @classmethod
     def create(cls, classification = "All"):
         if len(LoadCombination.data) == 0:
-            print("No Load Combinations defined!  Define the load combination using the 'LoadCombination' class before creating these in the model.")
+            # print("No Load Combinations defined!  Define the load combination using the 'LoadCombination' class before creating these in the model.")
             return
         if classification not in LoadCombination.valid:
             print(f'"{classification}" is not a valid input.  It is changed to "General".')
@@ -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/_section.py

@@ -732,8 +732,142 @@ class Section:
                 _SectionADD(self)
         
             
+#=======================================================Tapered Group===========================================
 
-
+    class TaperedGroup:
+        
+        data = []
+        
+        def __init__(self, name, elem_list, z_var, y_var, z_exp=None, z_from=None, z_dist=None, 
+                     y_exp=None, y_from=None, y_dist=None, id=""):
+            """
+            Args:
+                name (str): Tapered Group Name (Required).
+                elem_list (list): List of element numbers (Required).
+                z_var (str): Section shape variation for Z-axis: "LINEAR" or "POLY" (Required).
+                y_var (str): Section shape variation for Y-axis: "LINEAR" or "POLY" (Required).
+                z_exp (float, optional): Z-axis exponent. Required if z_var is "POLY".
+                z_from (str, optional): Z-axis symmetric plane ("i" or "j"). Defaults to "i" for "POLY".
+                z_dist (float, optional): Z-axis symmetric plane distance. Defaults to 0 for "POLY".
+                y_exp (float, optional): Y-axis exponent. Required if y_var is "POLY".
+                y_from (str, optional): Y-axis symmetric plane ("i" or "j"). Defaults to "i" for "POLY".
+                y_dist (float, optional): Y-axis symmetric plane distance. Defaults to 0 for "POLY".
+                id (str, optional): ID for the tapered group. Auto-generated if not provided.
             
-
-
+            Example:
+                Section.TapperGroup("Linear", [1, 2, 3], "LINEAR", "LINEAR")
+                Section.TapperGroup("ZPoly", [4, 5], "POLY", "LINEAR", z_exp=2.5)
+            """
+            self.NAME = name
+            self.ELEM_LIST = elem_list
+            self.Z_VAR = z_var
+            self.Y_VAR = y_var
+            
+            # Z-axis parameters (only for POLY)
+            if z_var == "POLY":
+                if z_exp is None:
+                    raise ValueError("z_exp is required when z_var is 'POLY'")
+                self.Z_EXP = z_exp
+                self.Z_FROM = z_from if z_from is not None else "i"
+                self.Z_DIST = z_dist if z_dist is not None else 0
+            else:
+                self.Z_EXP = None
+                self.Z_FROM = None
+                self.Z_DIST = None
+            
+            # Y-axis parameters (only for POLY)
+            if y_var == "POLY":
+                if y_exp is None:
+                    raise ValueError("y_exp is required when y_var is 'POLY'")
+                self.Y_EXP = y_exp
+                self.Y_FROM = y_from if y_from is not None else "i"
+                self.Y_DIST = y_dist if y_dist is not None else 0
+            else:
+                self.Y_EXP = None
+                self.Y_FROM = None
+                self.Y_DIST = None
+            
+            if id == "":
+                id = len(Section.TaperedGroup.data) + 1
+            self.ID = id
+            
+            Section.TaperedGroup.data.append(self)
+        
+        @classmethod
+        def json(cls):
+            json_data = {"Assign": {}}
+            for i in cls.data:
+                # Base data that's always included
+                tapper_data = {
+                    "NAME": i.NAME,
+                    "ELEMLIST": i.ELEM_LIST,
+                    "ZVAR": i.Z_VAR,
+                    "YVAR": i.Y_VAR
+                }
+                
+                # Add Z-axis polynomial parameters only if Z_VAR is "POLY"
+                if i.Z_VAR == "POLY":
+                    tapper_data["ZEXP"] = i.Z_EXP
+                    tapper_data["ZFROM"] = i.Z_FROM
+                    tapper_data["ZDIST"] = i.Z_DIST
+                
+                # Add Y-axis polynomial parameters only if Y_VAR is "POLY"
+                if i.Y_VAR == "POLY":
+                    tapper_data["YEXP"] = i.Y_EXP
+                    tapper_data["YFROM"] = i.Y_FROM
+                    tapper_data["YDIST"] = i.Y_DIST
+                
+                json_data["Assign"][str(i.ID)] = tapper_data
+            
+            return json_data
+        
+        @classmethod
+        def create(cls):
+            MidasAPI("PUT", "/db/tsgr", cls.json())
+        
+        @classmethod
+        def get(cls):
+            return MidasAPI("GET", "/db/tsgr")
+        
+        @classmethod
+        def delete(cls):
+            cls.data = []
+            return MidasAPI("DELETE", "/db/tsgr")
+        
+        @classmethod
+        def sync(cls):
+            cls.data = []
+            response = cls.get()
+            
+            if response and response != {'message': ''}:
+                tsgr_data = response.get('TSGR', {})
+                # Iterate through the dictionary of tapered groups from the API response
+                for tsgr_id, item_data in tsgr_data.items():
+                    # Extract base parameters
+                    name = item_data.get('NAME')
+                    elem_list = item_data.get('ELEMLIST')
+                    z_var = item_data.get('ZVAR')
+                    y_var = item_data.get('YVAR')
+                    
+                    # Extract optional parameters based on variation type
+                    z_exp = item_data.get('ZEXP') if z_var == "POLY" else None
+                    z_from = item_data.get('ZFROM') if z_var == "POLY" else None
+                    z_dist = item_data.get('ZDIST') if z_var == "POLY" else None
+                    
+                    y_exp = item_data.get('YEXP') if y_var == "POLY" else None
+                    y_from = item_data.get('YFROM') if y_var == "POLY" else None
+                    y_dist = item_data.get('YDIST') if y_var == "POLY" else None
+                    
+                    Section.TaperedGroup(
+                        name=name,
+                        elem_list=elem_list,
+                        z_var=z_var,
+                        y_var=y_var,
+                        z_exp=z_exp,
+                        z_from=z_from,
+                        z_dist=z_dist,
+                        y_exp=y_exp,
+                        y_from=y_from,
+                        y_dist=y_dist,
+                        id=tsgr_id
+                    )

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