midas-civil 1.0.9__py3-none-any.whl → 1.1.1__py3-none-any.whl

midas_civil/__init__.py

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

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": {}}
@@ -352,6 +385,12 @@ class Element:
         Element.elements = []
         Element.ids = []
         Element.__elemDIC__={}
+    
+    @staticmethod
+    def clear():
+        Element.elements = []
+        Element.ids = []
+        Element.__elemDIC__={}
 
     # --- Element Type Subclasses ---
 
@@ -408,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
@@ -424,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
@@ -446,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
@@ -456,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 = []
@@ -464,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 = []
@@ -489,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
 
@@ -540,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
@@ -971,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/_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/_mapi.py

@@ -3,7 +3,8 @@ import sys
 from colorama import Fore, Style
 try:import winreg
 except: pass
-
+import time
+import polars as pl
 
 
 
@@ -18,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:
@@ -124,6 +154,17 @@ 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()
+
+
     if method == "POST":
         response = requests.post(url=url, headers=headers, json=body)
     elif method == "PUT":
@@ -133,22 +174,26 @@ def MidasAPI(method:str, command:str, body:dict={})->dict:
     elif method == "DELETE":
         response = requests.delete(url=url, headers=headers)
 
-    if NX.debug_print:
-        print(method, command, response.status_code , "✅")
+    end_time = time.perf_counter()
+    elapsed_time = end_time - start_time
 
+    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 == 1:
-        MAPI_KEY.count = 0
+    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/_material.py

@@ -1620,6 +1620,10 @@ class TDMatLink:
         MidasAPI("DELETE","/db/TMAT")
         TDMatLink.mats={}
 
+    @staticmethod
+    def clear():
+        TDMatLink.mats={}
+
     @staticmethod
     def sync():
         a = TDMatLink.get()

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/_node.py

@@ -152,6 +152,13 @@ class Node:
         Node.Grid={}
         Node.__nodeDic__ = {}
 
+    @staticmethod
+    def clear():
+        Node.nodes=[]
+        Node.ids=[]
+        Node.Grid={}
+        Node.__nodeDic__ = {}
+
 
 
 

midas_civil/_result_extract.py

@@ -135,7 +135,7 @@ class Result :
                 "TABLE_NAME": tableName,
                 "STYLES": {
                     "FORMAT": "Fixed",
-                    "PLACE": 12
+                    "PLACE": 5
                 }
             }
         }
@@ -162,7 +162,7 @@ class Result :
 
 
 
-    # ---------- Result TABLE ------------------------------
+    # ---------- Result TABLE (For ALL TABLES)------------------------------
     @staticmethod
     def ResultTable(tabletype:str,keys=[],loadcase:list=[],cs_stage=[],force_unit='KN',len_unit='M'):
         '''
@@ -177,7 +177,7 @@ class Result :
                 "TABLE_TYPE": tabletype,
                 "STYLES": {
                     "FORMAT": "Fixed",
-                    "PLACE": 12
+                    "PLACE": 5
                 }
             }
         }
@@ -204,3 +204,58 @@ class Result :
         ss_json = MidasAPI("POST","/post/table",js_dat)
         _setUNIT(currUNIT)
         return _JSToDF_ResTable(ss_json)
+    
+
+    class TABLE :
+        
+        @staticmethod
+        def BeamForce_VBM(keys=[],loadcase:list=[],items=['all'],parts=["PartI", "PartJ"],components=['all'],force_unit='KN',len_unit='M'):
+            '''
+                Keys : List{int} -> Element/ Node IDs  |  str -> Structure Group Name
+                Loadcase : Loadcase name followed by type. eg. DeadLoad(ST)
+                Items to display : [ "Axial" , "Shear-y" , "Shear-z" , "Torsion" , "Moment-y" , "Moment-z"]
+                Parts : ["PartI", "Part1/4", "Part2/4", "Part3/4", "PartJ"]
+                Components (colms of tabulart result): [ "Elem", "Load", "Part", "Component", "Axial", "Shear-y", "Shear-z", "Torsion", "Moment-y", "Moment-z" ]
+                
+            '''
+
+            js_dat = {
+                "Argument": {
+                    "TABLE_NAME": "SS_Table",
+                    "TABLE_TYPE": "BEAMFORCEVBM",
+                    "STYLES": {
+                        "FORMAT": "Fixed",
+                        "PLACE": 5
+                    },
+                    "PARTS" : parts
+                }
+            }
+
+
+            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
+
+            if components!=['all']:
+                if "Elem" not in components: components.append("Elem")
+                if "Load" not in components: components.append("Load")
+                if "Part" not in components: components.append("Part")
+                if "Component" not in components: components.append("Component")
+                js_dat["Argument"]['COMPONENTS'] = components
+            
+            if items!=['all']:
+                js_dat["Argument"]['ITEM_TO_DISPLAY'] = items
+
+
+
+            currUNIT = _getUNIT()
+            Model.units(force=force_unit,length=len_unit)
+            ss_json = MidasAPI("POST","/post/table",js_dat)
+            _setUNIT(currUNIT)
+            return _JSToDF_ResTable(ss_json)
+

midas_civil/_section/_TapdbSecSS.py

@@ -1,5 +1,6 @@
 from ._offsetSS import Offset
 from ._offsetSS import _common
+import math
 
 class _SS_TAPERED_DBUSER(_common):
 
@@ -44,4 +45,131 @@ class _SS_TAPERED_DBUSER(_common):
     
     @staticmethod
     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)
+        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,*args):
+        if end: 
+            shape.PARAMS = shape.PARAMS_J
+            # print(' J end taken')
+        else: 
+            # print(' I end taken')
+            shape.PARAMS = shape.PARAMS_I
+
+        if shape.SHAPE == 'SB' :
+            H,B = shape.PARAMS[:2]
+
+            sect_lin_con = [[1,2],[3,1]]
+
+            sect_cg_LT = [-B/2,H/2]
+            sect_cg_CC = [0,0]
+            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]
+            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]
+
+        elif shape.SHAPE == 'L' :
+            H,B,tw,tf = shape.PARAMS[:4]
+
+            sect_cg_LT = [0,0]
+            sect_cg_CC = [(H*tw*tw+B*B*tf)/(2*(B*tw+H*tf)),-(H*H*tw+B*tf*tf)/(2*(B*tw+H*tf))]
+            sect_cg_RB = [B,-H]
+
+            # sect_shape = [[0.5*tw,-H],[0.5*tw,-0.5*tf],[B,-0.5*tf]]
+            sect_shape = [[0,-H],[0,0],[B,0]]
+            sect_lin_con = [[3,2],[2,1]]
+            sect_thk = [tw,tf]
+            # sect_thk_off = [0,0]
+            sect_thk_off = [tw/2,tf/2]
+        
+        elif shape.SHAPE == 'C' :
+            H,B1,tw,tf1,B2,tf2 = shape.PARAMS[:6]
+            if B2 == 0 : B2 = B1
+            if tf2 == 0 : tf2 = tf1
+
+            sect_cg_LT = [0,0]
+            sect_cg_CC = [(B1+B2)*0.2,-H*0.5]
+            sect_cg_RB = [max(B1,B2),-H]
+
+            # sect_shape = [[0.5*tw,-0.5*tf1],[B1,-0.5*tf1],[0.5*tw,-H+0.5*tf2],[B2,-H+0.5*tf2]]
+            sect_shape = [[0,0],[B1,0],[0,-H],[B2,-H]]
+            sect_lin_con = [[2,1],[1,3],[3,4]]
+            sect_thk = [tf1,tw,tf2]
+            # sect_thk_off = [0,0,0]
+            sect_thk_off = [tf1/2,tw/2,tf2/2]
+
+        elif shape.SHAPE == 'H' :
+            H,B1,tw,tf1,B2,tf2,r1,r2 = shape.PARAMS[:8]
+            if B2 == 0 : B2 = B1
+            if tf2 == 0 : tf2 = tf1
+
+            sect_cg_LT = [-0.5*max(B1,B2),0.5*H]
+            sect_cg_CC = [0,0]
+            sect_cg_RB = [0.5*max(B1,B2),-0.5*H]
+
+            sect_shape = [[-0.5*B1,0.5*(H-tf1)],[0,0.5*(H-tf1)],[0.5*B1,0.5*(H-tf1)],[-0.5*B2,-0.5*(H-tf2)],[0,-0.5*(H-tf2)],[0.5*B2,-0.5*(H-tf2)]]
+            sect_lin_con = [[2,1],[3,2],[2,5],[4,5],[5,6]]
+            sect_thk = [tf1,tf1,tw,tf2,tf2]
+            sect_thk_off = [0,0,0,0,0]
+        
+        elif shape.SHAPE == 'T' :
+            H,B,tw,tf = shape.PARAMS[:4]
+
+            sect_cg_LT = [-B*0.5,0]
+            sect_cg_CC = [0,-H*0.3]
+            sect_cg_RB = [B*0.5,-H]
+
+            sect_shape = [[-0.5*B,-0.5*tf],[0,-0.5*tf],[0.5*B,-0.5*tf],[0,-H]]
+            sect_lin_con = [[2,1],[3,2],[2,4]]
+            sect_thk = [tf,tf,tw]
+            sect_thk_off = [0,0,0]
+
+        elif shape.SHAPE == 'B' :
+            H,B,tw,tf1,C,tf2 = shape.PARAMS[:6]
+            if tf2 == 0 : tf2 = tf1
+
+            sect_cg_LT = [-0.5*B,0.5*H]
+            sect_cg_CC = [0,0]
+            sect_cg_RB = [0.5*B,-0.5*H]
+
+            # sect_shape = [[0.5*(B-tw),0.5*(H-tf1)],[-0.5*(B-tw),0.5*(H-tf1)],[-0.5*(B-tw),-0.5*(H-tf2)],[0.5*(B-tw),-0.5*(H-tf2)]]
+            sect_shape = [[0.5*B,0.5*H],[-0.5*B,0.5*H],[-0.5*B,-0.5*H],[0.5*B,-0.5*H]]
+
+            sect_lin_con = [[1,2],[2,3],[3,4],[4,1]]
+            sect_thk = [tf1,tw,tf2,tw]
+            # sect_thk_off = [0,0,0,0]
+            sect_thk_off = [0.5*tf1,0.5*tw,0.5*tf2,0.5*tw]
+        
+        elif shape.SHAPE == 'P' :
+            D,tw = shape.PARAMS[:2]
+
+            # R = 0.5*(D-tw)
+            R = 0.5*D
+
+            sect_cg_LT = [-R,R]
+            sect_cg_CC = [0,0]
+            sect_cg_RB = [R,-R]
+
+            sect_shape = []
+            sect_lin_con = []
+            sect_thk = []
+            sect_thk_off = []
+
+            n = 16
+            for i in range(n):
+                sect_shape.append([R*math.sin(i*2*math.pi/n),R*math.cos(i*2*math.pi/n)])
+                sect_lin_con.append([i+1,i+2])
+                sect_thk.append(tw)
+                sect_thk_off.append(-0.5*tw)
+            sect_lin_con[-1] = [i+1,1]
+
+
+
+        sect_cg = (sect_cg_LT,sect_cg_CC,sect_cg_RB)
+
+        return sect_shape, sect_thk ,sect_thk_off, sect_cg , sect_lin_con

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