midas-civil 1.1.0__tar.gz → 1.1.1__tar.gz

{midas_civil-1.1.0 → midas_civil-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midas_civil
-Version: 1.1.0
+Version: 1.1.1
 Summary: Python library for MIDAS Civil NX
 Home-page: https://github.com/MIDASIT-Co-Ltd/midas-civil-python
 Author: Sumit Shekhar

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/__init__.py

@@ -1,7 +1,7 @@
 import requests
 from colorama import Fore,Style
 from ._mapi import *
-_version_ = "1.1.0"
+_version_ = "1.1.1"
 
 
 print('\n╭────────────────────────────────────────────────────────────────────────────────────╮')

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_element.py

@@ -3,10 +3,37 @@ from ._node import *
 from ._group import _add_elem_2_stGroup
 from ._group import _add_node_2_stGroup,Group
 import numpy as np
-from scipy.interpolate import splev, splprep
+from scipy.interpolate import splev, splprep , interp1d , Akima1DInterpolator
 from math import hypot
 import math
+from ._utils import _convItem2List
 
+def _SInterp(angle,num_points):
+    ''' Angle -> Input list | Num Points -> Output length'''
+
+    angle = _convItem2List(angle)
+    if len(angle) == 1 : 
+        angle.append(angle[0])
+        angle.append(angle[0])
+    if len(angle) == 2 : 
+        angle.append(angle[-1])
+        angle[1] = (angle[0]+angle[2])*0.5
+
+    num_angle = len(angle)
+    angle_intrp_x = [0]
+    angle_intrp_y = [angle[0]]
+    for a in range(num_angle-1):
+        angle_intrp_x.append((a+1)*(num_points-1)/(num_angle-1))
+        angle_intrp_y.append(angle[a+1])
+
+    _alignment = Akima1DInterpolator(angle_intrp_x, angle_intrp_y,method='makima')
+    angle_intrp_func = interp1d(angle_intrp_x, angle_intrp_y)
+
+    angle_intrp_finalY = []
+    for i in range(num_points):
+        angle_intrp_finalY.append(_alignment(i))
+
+    return angle_intrp_finalY
 
 def _interpolateAlignment(pointsArray,n_seg=10,deg=1,mSize=0,includePoint:bool=True) -> list:
     ''' Returns point list and beta angle list'''
@@ -146,6 +173,8 @@ def _pointOffset(pts,yEcc=0,zEcc=0,angle=0):
     from ._utils import _matchArray
 
     angle2 = _matchArray(pts,angle)
+    yEcc2 = _matchArray(pts,yEcc)
+    zEcc2 = _matchArray(pts,zEcc)
 
     norm = []
     norm.append(_calcVector(np.subtract(pts[1],pts[0]),angle2[0]))    # first X- along vector
@@ -165,7 +194,7 @@ def _pointOffset(pts,yEcc=0,zEcc=0,angle=0):
 
     pt_new = []
     for i in range(len(pts)):
-        pt_new.append(pts[i]+yEcc*norm[i][1]+zEcc*norm[i][2])
+        pt_new.append(pts[i]+yEcc2[i]*norm[i][1]+zEcc2[i]*norm[i][2])
 
     return pt_new
 
@@ -319,6 +348,10 @@ class Element:
     ids = []
     __elemDIC__ = {}
 
+    
+    lastLoc = (0,0,0) #Last Location created using Beam element
+    '''Last Node Location created by Beam / Truss element - (x,y,z)'''
+
     @classmethod
     def json(cls):
         json_data = {"Assign": {}}
@@ -414,6 +447,8 @@ class Element:
                 _norm2 = np.linalg.norm(_n2.AXIS ,axis=1,keepdims=True)
                 _n2.AXIS = _n2.AXIS /_norm2
 
+            Element.lastLoc = (_n2.X,_n2.Y,_n2.Z)
+
             _ADD(self)
 
         @staticmethod
@@ -430,7 +465,7 @@ class Element:
                     locc = s_locc+i*l*unit_vec/n
                     Enode=Node(locc[0].item(),locc[1].item(),locc[2].item())
                     beam_nodes.append(Enode.ID)
-                
+                Element.lastLoc = (locc[0].item(),locc[1].item(),locc[2].item())
                 for i in range(n):
                     if id == 0 : id_new = 0
                     else: id_new = id+i
@@ -452,7 +487,6 @@ class Element:
                 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
@@ -462,6 +496,9 @@ class Element:
         
         @staticmethod
         def PLine(points_loc:list,n_div:int=0,deg:int=1,includePoint:bool=True,mat:int=1,sect:int=1,angle:float=0, group = "" , id: int = 0,bLocalAxis=False):
+                '''
+                angle : float of list(float)
+                '''
 
                 beam_nodes =[]
                 beam_obj = []
@@ -470,23 +507,29 @@ class Element:
                 else:
                     i_loc = _interpolateAlignment(points_loc,n_div,deg,0,includePoint)
 
-                from ._utils import _matchArray
-                angle = _matchArray(i_loc,angle)
+                num_points = len(i_loc)                
+                angle_intrp_finalY = _SInterp(angle,num_points-1) #Beta Angle to be applied to Elements So, n-1
 
                 for i in i_loc:
                     Enode=Node(i[0],i[1],i[2])
                     beam_nodes.append(Enode.ID)
-                
                 for i in range(len(i_loc)-1):
                     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[i],group,id_new,bLocalAxis))
+                    beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle_intrp_finalY[i].item(),group,id_new,bLocalAxis))
                 
                 return beam_obj
         
         @staticmethod
-        def PLine2(points_loc:list,n_div:int=0,deg:int=1,includePoint:bool=True,mat:int=1,sect:int=1,angle:float=0, group = "" , id: int = 0,bLocalAxis=False,yEcc=0,zEcc=0):
-                
+        def PLine2(points_loc:list,n_div:int=0,deg:int=1,includePoint:bool=True,mat:int=1,sect:int=1,angle:list[float]=0, group = "" , id: int = 0,bLocalAxis=False,yEcc:list[float]=0,zEcc:list[float]=0,bAngleInEcc:bool=True):
+                '''
+                Creates a polyline with Eccentricity considering the beta angle provided   
+                angle , yEcc , zEcc : float or list(float)   
+                        [0,10] -> Angle at start = 0 | Angle at end = 10   
+                        [0,10,0] -> Angle at start = 0 |  Angle at mid = 10  |  Angle at end = 0   
+                        Inbetween values are **MAKIMA 1D** interpolated. (not cubic)
+                '''
+                from ._utils import _matchArray
                 
                 beam_nodes =[]
                 beam_obj = []
@@ -495,21 +538,27 @@ class Element:
                 else:
                     i_loc = _interpolateAlignment(points_loc,n_div,deg,0,includePoint)
                 
-                from ._utils import _matchArray
-                angle = _matchArray(i_loc,angle)
+                
+                num_points = len(i_loc)                
+                if bAngleInEcc:
+                    angle_intrp_Ecc = _SInterp(angle,num_points)
+                else:
+                    angle_intrp_Ecc = _matchArray(i_loc,[0])
+                angle_intrp_finalY = _SInterp(angle,num_points-1) #Beta Angle to be applied to Elements So, n-1
+                
+                yEcc_intrp = _SInterp(yEcc,num_points)
+                zEcc_intrp = _SInterp(zEcc,num_points)
 
-                i_loc2 = _pointOffset(i_loc,yEcc,zEcc,angle)
+                i_loc2 = _pointOffset(i_loc,yEcc_intrp,zEcc_intrp,angle_intrp_Ecc)
                 for i in i_loc2:
                     Enode=Node(i[0],i[1],i[2])
                     beam_nodes.append(Enode.ID)
-
-                
                 
 
                 for i in range(len(i_loc2)-1):
                     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[i],group,id_new,bLocalAxis))
+                    beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle_intrp_finalY[i].item(),group,id_new,bLocalAxis))
                 
                 return beam_obj
 
@@ -546,7 +595,9 @@ class Element:
             self.NODE = [i, j]
             self.ANGLE = angle
             self._GROUP = group
-            self.LENGTH = _nodeDIST(nodeByID(i),nodeByID(j))
+            _n2 = nodeByID(j)
+            self.LENGTH = _nodeDIST(nodeByID(i),_n2)
+            Element.lastLoc = (_n2.X,_n2.Y,_n2.Z)
             _ADD(self)
 
         @staticmethod
@@ -977,5 +1028,5 @@ def elemByID(elemID:int) -> Element:
     try:
         return (Element.__elemDIC__[str(elemID)])
     except:
-        print(f'There is no element with ID {elemID}')
+        print(Fore.RED +f'There is no element with ID {elemID}'+Style.RESET_ALL)
         return None

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_load.py

@@ -256,7 +256,7 @@ class Load:
         data = []
         def __init__(self, element, load_case: str, load_group: str = "", value: float=0, direction: str = "GZ",
             id = "", D = [0, 1, 0, 0], P = [0, 0, 0, 0], cmd = "BEAM", typ = "UNILOAD", use_ecc = False, use_proj = False,
-            eccn_dir = "LZ", eccn_type = 1, ieccn = 0, jeccn = 0, adnl_h = False, adnl_h_i = 0, adnl_h_j = 0): 
+            eccn_dir = "LY", eccn_type = 1, ieccn = 0, jeccn = 0, adnl_h = False, adnl_h_i = 0, adnl_h_j = 0): 
             """
             element: Element Number 
             load_case (str): Load case name
@@ -737,4 +737,72 @@ class Load:
                             item['GROUP_NAME'],
                             values,
                             item['ID']
-                        )
+                        )
+    class Line:
+        def __init__(self, element_ids, load_case: str, load_group: str = "", D = [0, 1, 0, 0], P = [0, 0, 0, 0], direction: str = "GZ",
+            id = "", typ = "CONLOAD", use_ecc = False, use_proj = False,
+            eccn_dir = "LY", eccn_type = 1, ieccn = 0, jeccn = 0, adnl_h = False, adnl_h_i = 0, adnl_h_j = 0) :
+
+            elem_IDS = []
+            elem_LEN = []
+
+            for eID in element_ids:
+                try: 
+                    elm_len = elemByID(eID).LENGTH
+                    elem_IDS.append(eID)
+                    elem_LEN.append(elm_len)
+                    # print(f"ID = {eID} LEN = {elm_len}")
+                except: pass
+            cum_LEN = np.insert(np.cumsum(elem_LEN),0,0)
+
+
+            if typ == 'CONLOAD':
+                for i in range(len(D)):
+                    for q in range(len(cum_LEN)):
+                        if D[i] >= 0:
+                            if D[i] < cum_LEN[q] :
+                                # print(f'LOADING ELEMENT at {D[i]}m = {elem_IDS[q-1]}')
+                                rel_loc = (D[i] - cum_LEN[q-1]) / elem_LEN[q-1]
+                                # print(f"Relative location = {rel_loc}")
+                                Load.Beam(element=elem_IDS[q-1],load_case=load_case,load_group=load_group,D=[rel_loc],P=[P[i]],direction=direction,
+                                        id = id, typ = "CONLOAD", use_ecc = use_ecc, use_proj = use_proj,
+                                        eccn_dir = eccn_dir, eccn_type = eccn_type, ieccn = ieccn, jeccn = jeccn, adnl_h = adnl_h, adnl_h_i = adnl_h_i, adnl_h_j = adnl_h_j)
+                                break 
+            
+            if typ == 'UNILOAD':
+                D = D[:2]
+                P = P[:2]
+                elms_indx = []
+                for i in range(2):
+                    for q in range(len(cum_LEN)):
+                        if D[i] < cum_LEN[q] :
+                            # print(f'LOADING ELEMENT at {D[i]}m = {elem_IDS[q-1]}')
+                            elms_indx.append(q-1)
+                            # rel_loc = (D[i] - cum_LEN[q-1]) / elem_LEN[q-1]
+                            break 
+                if len(elms_indx)==1: elms_indx.append(len(cum_LEN)-2)
+                # print(f"INDEXs = {elms_indx}")
+                # print("-"*10)
+                # print(f"INDEXs = {elms_indx}")
+                # print("-"*10)
+                if elms_indx != []:
+                    for i in range(elms_indx[0],elms_indx[1]+1):
+
+                        rel1 = (max(D[0],cum_LEN[i]) - cum_LEN[i]) / elem_LEN[i]
+                        rel2 = (min(D[1],cum_LEN[i+1]) - cum_LEN[i]) / elem_LEN[i]
+
+                        p1 = P[0]+(max(D[0],cum_LEN[i])-D[0])*(P[1]-P[0])/(D[1]-D[0])
+                        p2 = P[0]+(min(D[1],cum_LEN[i+1])-D[0])*(P[1]-P[0])/(D[1]-D[0])
+                        if rel2-rel1 == 0: continue
+                        
+
+                        # print(f"Loading ELEM -> {elem_IDS[i]} , D1 = {rel1} , P1 = {p1} | D2 = {rel2} , P2 = {p2}")
+                        # Load.Beam(elem_IDS[i],load_case,load_group,D=[rel1,rel2],P=[p1,p2],typ=typ,direction=direction)
+                        Load.Beam(element=elem_IDS[i],load_case=load_case,load_group=load_group,D=[rel1,rel2],P=[p1,p2],direction=direction,
+                                        id = id, typ = "UNILOAD", use_ecc = use_ecc, use_proj = use_proj,
+                                        eccn_dir = eccn_dir, eccn_type = eccn_type, ieccn = ieccn, jeccn = jeccn, adnl_h = adnl_h, adnl_h_i = adnl_h_i, adnl_h_j = adnl_h_j)
+
+                        
+
+                
+                

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_mapi.py

@@ -4,7 +4,7 @@ from colorama import Fore, Style
 try:import winreg
 except: pass
 import time
-
+import polars as pl
 
 
 
@@ -19,7 +19,36 @@ def Midas_help():
 class NX:
     version_check = True
     user_print = True
-    debug_print = False
+    debug_request = False
+    debug_requestJSON = False
+    debug_response = False
+
+    _symbol_responseCode_ = {
+        "1" : "⌛",
+        "2" : "✅",
+        "3" : "⚠️",
+        "4" : "💀",
+        "5" : "💀"
+    }
+
+
+    @staticmethod
+    def JSToDF_Results(js_json):
+        res_json = {}
+
+        c=0
+        for heading in js_json["SS_Table"]["HEAD"]:
+            for dat in js_json["SS_Table"]["DATA"]:
+                try:
+                    res_json[heading].append(dat[c])
+                except:
+                    res_json[heading]=[]
+                    res_json[heading].append(dat[c])
+
+            c+=1
+
+        res_df = pl.DataFrame(res_json)
+        return(res_df)
     
 
 class MAPI_COUNTRY:
@@ -125,6 +154,14 @@ def MidasAPI(method:str, command:str, body:dict={})->dict:
         "MAPI-Key": mapi_key
     }
 
+    if MAPI_KEY.count == 1:
+        MAPI_KEY.count =0
+        if NX.user_print:
+            _checkUSER()
+
+
+
+
     start_time = time.perf_counter()
 
 
@@ -140,22 +177,23 @@ def MidasAPI(method:str, command:str, body:dict={})->dict:
     end_time = time.perf_counter()
     elapsed_time = end_time - start_time
 
-    if NX.debug_print:
-        print(f"{method} |  URL : {command} | STATUS : {response.status_code} | TIME : {elapsed_time:.4f} sec")
-
-
-
-    if MAPI_KEY.count == 1:
-        MAPI_KEY.count = 0
+    if NX.debug_request:
+        # sym = NX._symbol_responseCode_[str(response.status_code)[0]]
+        # print(Fore.RED+f">>   METHOD : {method} |  URL : {command} | STATUS : "+Fore.YELLOW+f" {response.status_code} "+Fore.RED+f"| TIME : {elapsed_time:.4f} sec "+Style.RESET_ALL)
+        print(Fore.RED+f">>   METHOD : {method} |  URL : {command} | STATUS :  {response.status_code} | TIME : {elapsed_time:.4f} sec "+Style.RESET_ALL)
+    if NX.debug_requestJSON:
+        print(Fore.CYAN+">>  "+str(body)+Style.RESET_ALL)
+    if NX.debug_response:
+        print(Fore.GREEN+">>  "+str(response.json())+Style.RESET_ALL)
+
+    if MAPI_KEY.count == 0:
+        MAPI_KEY.count = -1
         if response.status_code == 404:
             print(Fore.RED +'\n╭─ 💀   ─────────────────────────────────────────────────────────────────────────────╮')
             print(f"│  Civil NX model is not connected.  Click on 'Apps > Connect' in Civil NX.          │")
             print(f"│  Make sure the MAPI Key in python code is matching with the MAPI key in Civil NX.  │")
             print('╰────────────────────────────────────────────────────────────────────────────────────╯\n'+Style.RESET_ALL)
             sys.exit(0)
-
-        if NX.user_print:
-            _checkUSER()
     
 
 

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_model.py

@@ -252,6 +252,7 @@ class Model:
         Boundary.create()
         Load.create()
         Tendon.create()
+        if Section.TaperedGroup.data !=[] : Section.TaperedGroup.create()
 
         LoadCombination.create()
 

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_result_extract.py

@@ -207,6 +207,7 @@ class Result :
     
 
     class TABLE :
+        
         @staticmethod
         def BeamForce_VBM(keys=[],loadcase:list=[],items=['all'],parts=["PartI", "PartJ"],components=['all'],force_unit='KN',len_unit='M'):
             '''

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_section/_TapdbSecSS.py

@@ -47,7 +47,7 @@ class _SS_TAPERED_DBUSER(_common):
     def _objectify(id,name,type,shape,offset,uShear,u7DOF,js):
         return _SS_TAPERED_DBUSER(name,shape,js['SECT_BEFORE']['SECT_I']['vSIZE'],js['SECT_BEFORE']['SECT_J']['vSIZE'],offset,uShear,u7DOF,id)
     
-    def _centerLine(shape,end):
+    def _centerLine(shape,end,*args):
         if end: 
             shape.PARAMS = shape.PARAMS_J
             # print(' J end taken')

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_section/__init__.py

@@ -263,8 +263,8 @@ class Section:
         
         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=""):
+        def __init__(self, name, elem_list, z_var="LINEAR", y_var="LINEAR", z_exp=2.0, z_from="i", z_dist=0, 
+                     y_exp=2.0, y_from="i", y_dist=0, id=""):
             """
             Args:
                 name (str): Tapered Group Name (Required).

{midas_civil-1.1.0 → midas_civil-1.1.1}/midas_civil/_section/_dbSecSS.py

@@ -43,7 +43,7 @@ class _SS_DBUSER(_common):
     def _objectify(id,name,type,shape,offset,uShear,u7DOF,js):
         return _SS_DBUSER(name,shape,js['SECT_BEFORE']['SECT_I']['vSIZE'],offset,uShear,u7DOF,id)
     
-    def _centerLine(shape,end):
+    def _centerLine(shape,*args):
         if shape.SHAPE == 'SB' :
             H,B = shape.PARAMS[:2]
 
@@ -54,13 +54,13 @@ class _SS_DBUSER(_common):
             sect_cg_RB = [B/2,-H/2]
 
             if H > B :
-                sect_shape = [[0,0],[0,H/2],[0,-H/2],[0,H/4],[0,-H/4]]
-                sect_thk = [B,B,B,B]
-                sect_thk_off = [0,0,0,0]
+                sect_shape = [[0,0],[0,H/2],[0,-H/2]]
+                sect_thk = [B,B]
+                sect_thk_off = [0,0]
             else : 
-                sect_shape = [[0,0],[B/2,0],[-B/2,0],[B/4,0],[-B/4,0]]
-                sect_thk = [H,H,H,H]
-                sect_thk_off = [0,0,0,0]
+                sect_shape = [[0,0],[B/2,0],[-B/2,0]]
+                sect_thk = [H,H]
+                sect_thk_off = [0,0]
 
         elif shape.SHAPE == 'L' :
             H,B,tw,tf = shape.PARAMS[:4]

midas_civil-1.1.0/midas_civil/_section/_pscSS.py → midas_civil-1.1.1/midas_civil/_section/_pscSS copy.py

@@ -115,7 +115,7 @@ class _SS_PSC_12CELL(_common):
                             vD[0],vD[1],vD[2],vD[3],vD[4],vD[5],vD[6],vD[7],
                             offset,uShear,u7DOF,id)
     
-    def _centerLine(shape,end):
+    def _centerLine(shape,*args):
         if shape.SHAPE == '1CEL':
             BO1 = shape.BO1
             BO2 = shape.BO2