midas-civil 0.0.9__py3-none-any.whl → 0.1.1__py3-none-any.whl

midas_civil/_construction_backup.py

@@ -0,0 +1,415 @@
+from ._mapi import *
+
+class CS:
+
+    CSA = []  
+
+    def __init__(self, 
+                 name: str,
+                 duration: float = 0, 
+                 s_group: str = None, 
+                 s_age: float = None, 
+                 s_type: str= None, 
+                 b_group: str = None, 
+                 b_pos: str = None, 
+                 b_type: str = None,
+                 l_group: str = None, 
+                 l_day: str = None, 
+                 l_type: str = None, 
+                 id: int = None, 
+                 sr_stage: bool = True, 
+                 ad_stage: bool = False, 
+                 load_in: bool = False, 
+                 nl: int = 5, 
+                 addstp: list = None):
+        """
+        Construction Stage define.
+        
+        Parameters:
+            name: Name of Construction Stage
+            duration: Duration of Construction Stage in days (default 0)
+            s_group: Structure group name or list of group names (default None)
+            s_age: Age of structure group in days and Redistribution value(%) win case of Deactivation (default 0)
+            s_type: Structure activation type - "A" to activate, "D" to deactivate(default A)
+            b_group: Boundary group name or list of group names (default None)
+            b_pos: Boundary position type - "ORIGINAL" or "DEFORMED", or list (default DEFORMED)
+            b_type: Boundary activation type - "A" to activate, "D" to deactivate (default A)
+            l_group: Load group name or list of group names (default None)
+            l_day: Load activation day - "FIRST" or "LAST" (default "FIRST")
+            l_type: Load activation type - "A" to activate, "D" to deactivate (default A)
+            id: The construction stage ID (optional)
+            sr_stage: Save results of this stage (default True)
+            ad_stage: Add additional step results (default False)
+            load_in: Load incremental steps for material nonlinear analysis (default False)
+            nl: Number of load incremental steps (default 5)
+            addstp: List of additional steps (default None)
+        
+        Examples:
+            ```python
+            # Single group activation
+            CS("CS1", 7, "S1", 7, "A", "B1", "DEFORMED", "A", "L1", "FIRST", "A")
+            
+            # Multiple group activation
+            CS("CS1", 7, ["S1", "S2"], [7, 10], ["A", "A"], ["B1", "B2"], 
+               ["DEFORMED", "DEFORMED"], ["A", "A"], ["L1", "L2"], ["FIRST", "FIRST"], ["A", "A"])
+            
+            # Mixed activation and deactivation
+            CS("CS1", 7, ["S1", "S2"], [7, 10], ["A", "D"], ["B1", "B2"], 
+               ["DEFORMED", "DEFORMED"], ["A", "D"], "L1", "FIRST", "A")
+            
+            # With additional options
+            CS("CS1", 7, "S1", 7, "A", "B1", "DEFORMED", "A", "L1", "FIRST", "A",
+               sr_stage=True, ad_stage=True, load_in=True, nl=6, addstp=[1, 2, 3])
+            ```
+        """
+
+        self.NAME = name
+        self.DURATION = duration
+        self.SR_stage = sr_stage
+        self.Ad_stage = ad_stage
+        self.Load_IN = load_in
+        self.NL = nl
+        self.addstp = [] if addstp is None else addstp
+        
+        # Initialize group containers
+        self.act_structure_groups = []  
+        self.deact_structure_groups = []  
+        self.act_boundary_groups = []  
+        self.deact_boundary_groups = []  
+        self.act_load_groups = []  
+        self.deact_load_groups = []  
+        
+        # Set ID
+        if id is None:
+            self.ID = len(CS.CSA) + 1
+        else:
+            self.ID = id
+        
+        # Process structure groups
+        if s_group:
+            # Convert single values to lists for uniform processing
+            if not isinstance(s_group, list):
+                s_group = [s_group]
+                s_age = [s_age if s_age is not None else 0]
+                s_type = [s_type if s_type is not None else "A"]
+            else:
+                # Ensure other parameters are lists too
+                if s_age is None:
+                    s_age = [0] * len(s_group)
+                elif not isinstance(s_age, list):
+                    s_age = [s_age] * len(s_group)
+                
+                if s_type is None:
+                    s_type = ["A"] * len(s_group)
+                elif not isinstance(s_type, list):
+                    s_type = [s_type] * len(s_group)
+            
+            # Process each structure group
+            for i, group in enumerate(s_group):
+                if i < len(s_type) and s_type[i] == "A":
+                    # Activation: Check if already activated in previous stages
+                    for stage in CS.CSA:
+                        for existing_group in stage.act_structure_groups:
+                            if existing_group["name"] == group:
+                                raise ValueError(f"Structure group '{group}' has already been activated in stage '{stage.NAME}' (ID: {stage.ID})")
+                    
+                    age = s_age[i] if i < len(s_age) else 0
+                    self.act_structure_groups.append({"name": group, "age": age})
+                else:
+                    # Deactivation: Check if activated in previous stages
+                    activated = False
+                    for stage in CS.CSA:
+                        for existing_group in stage.act_structure_groups:
+                            if existing_group["name"] == group:
+                                activated = True
+                                break
+                        if activated:
+                            break
+                    
+                    if not activated:
+                        raise ValueError(f"Structure group '{group}' cannot be deactivated as it has not been activated in any previous stage")
+                    
+                    # For deactivation, s_age value is used as redist percentage
+                    redist = s_age[i] if i < len(s_age) else 100
+                    self.deact_structure_groups.append({"name": group, "redist": redist})
+        
+        # Process boundary groups
+        if b_group:
+            # Convert single values to lists for uniform processing
+            if not isinstance(b_group, list):
+                b_group = [b_group]
+                b_pos = [b_pos if b_pos is not None else "DEFORMED"]
+                b_type = [b_type if b_type is not None else "A"]
+            else:
+                # Ensure other parameters are lists too
+                if b_pos is None:
+                    b_pos = ["DEFORMED"] * len(b_group)
+                elif not isinstance(b_pos, list):
+                    b_pos = [b_pos] * len(b_group)
+                
+                if b_type is None:
+                    b_type = ["A"] * len(b_group)
+                elif not isinstance(b_type, list):
+                    b_type = [b_type] * len(b_group)
+            
+            # Process each boundary group
+            for i, group in enumerate(b_group):
+                if i < len(b_type) and b_type[i] == "A":
+                    # Activation: Check if already activated in previous stages
+                    for stage in CS.CSA:
+                        for existing_group in stage.act_boundary_groups:
+                            if existing_group["name"] == group:
+                                raise ValueError(f"Boundary group '{group}' has already been activated in stage '{stage.NAME}' (ID: {stage.ID})")
+                    
+                    pos = b_pos[i] if i < len(b_pos) else "DEFORMED"
+                    self.act_boundary_groups.append({"name": group, "pos": pos})
+                else:
+                    # Deactivation: Check if activated in previous stages
+                    activated = False
+                    for stage in CS.CSA:
+                        for existing_group in stage.act_boundary_groups:
+                            if existing_group["name"] == group:
+                                activated = True
+                                break
+                        if activated:
+                            break
+                    
+                    if not activated:
+                        raise ValueError(f"Boundary group '{group}' cannot be deactivated as it has not been activated in any previous stage")
+                    
+                    self.deact_boundary_groups.append(group)
+        
+        # Process load groups
+        if l_group:
+            # Convert single values to lists for uniform processing
+            if not isinstance(l_group, list):
+                l_group = [l_group]
+                l_day = [l_day if l_day is not None else "FIRST"]
+                l_type = [l_type if l_type is not None else "A"]
+            else:
+                # Ensure other parameters are lists too
+                if l_day is None:
+                    l_day = ["FIRST"] * len(l_group)
+                elif not isinstance(l_day, list):
+                    l_day = [l_day] * len(l_group)
+                
+                if l_type is None:
+                    l_type = ["A"] * len(l_group)
+                elif not isinstance(l_type, list):
+                    l_type = [l_type] * len(l_group)
+            
+            # Process each load group
+            for i, group in enumerate(l_group):
+                if i < len(l_type) and l_type[i] == "A":
+                    # Activation: Check if already activated in previous stages
+                    for stage in CS.CSA:
+                        for existing_group in stage.act_load_groups:
+                            if existing_group["name"] == group:
+                                raise ValueError(f"Load group '{group}' has already been activated in stage '{stage.NAME}' (ID: {stage.ID})")
+                    
+                    day = l_day[i] if i < len(l_day) else "FIRST"
+                    self.act_load_groups.append({"name": group, "day": day})
+                else:
+                    # Deactivation: Check if activated in previous stages
+                    activated = False
+                    for stage in CS.CSA:
+                        for existing_group in stage.act_load_groups:
+                            if existing_group["name"] == group:
+                                activated = True
+                                break
+                        if activated:
+                            break
+                    
+                    if not activated:
+                        raise ValueError(f"Load group '{group}' cannot be deactivated as it has not been activated in any previous stage")
+                    
+                    day = l_day[i] if i < len(l_day) else "FIRST"
+                    self.deact_load_groups.append({"name": group, "day": day})
+        
+        CS.CSA.append(self)
+    
+    @classmethod
+    def json(cls):
+        """
+        Converts Construction Stage data to JSON format 
+        Example:
+            # Get the JSON data for all construction stages
+            json_data = CS.json()
+            print(json_data)
+        """
+        json = {"Assign": {}}
+        
+        for csa in cls.CSA:
+            stage_data = {
+                "NAME": csa.NAME,
+                "DURATION": csa.DURATION,
+                "bSV_RSLT": csa.SR_stage,
+                "bSV_STEP": csa.Ad_stage,
+                "bLOAD_STEP": csa.Load_IN
+            }
+            
+            # Add incremental steps if load step is enabled
+            if csa.Load_IN:
+                stage_data["INCRE_STEP"] = csa.NL
+            
+            # Add additional steps if specified
+            if csa.addstp:
+                stage_data["ADD_STEP"] = csa.addstp
+            else:
+                stage_data["ADD_STEP"] = []
+            
+            # Handle structure group activation
+            if csa.act_structure_groups:
+                stage_data["ACT_ELEM"] = []
+                for group in csa.act_structure_groups:
+                    stage_data["ACT_ELEM"].append({
+                        "GRUP_NAME": group["name"],
+                        "AGE": group["age"]
+                    })
+            
+            # Handle structure group deactivation
+            if csa.deact_structure_groups:
+                stage_data["DACT_ELEM"] = []
+                for group in csa.deact_structure_groups:
+                    stage_data["DACT_ELEM"].append({
+                        "GRUP_NAME": group["name"],
+                        "REDIST": group["redist"]
+                    })
+            
+            # Handle boundary group activation
+            if csa.act_boundary_groups:
+                stage_data["ACT_BNGR"] = []
+                for group in csa.act_boundary_groups:
+                    stage_data["ACT_BNGR"].append({
+                        "BNGR_NAME": group["name"],
+                        "POS": group["pos"]
+                    })
+            
+            # Handle boundary group deactivation
+            if csa.deact_boundary_groups:
+                stage_data["DACT_BNGR"] = []
+                for group_name in csa.deact_boundary_groups:
+                    stage_data["DACT_BNGR"].append(group_name)
+            
+            # Handle load group activation
+            if csa.act_load_groups:
+                stage_data["ACT_LOAD"] = []
+                for group in csa.act_load_groups:
+                    stage_data["ACT_LOAD"].append({
+                        "LOAD_NAME": group["name"],
+                        "DAY": group["day"]
+                    })
+            
+            # Handle load group deactivation
+            if csa.deact_load_groups:
+                stage_data["DACT_LOAD"] = []
+                for group in csa.deact_load_groups:
+                    stage_data["DACT_LOAD"].append({
+                        "LOAD_NAME": group["name"],
+                        "DAY": group["day"]
+                    })
+            
+            json["Assign"][str(csa.ID)] = stage_data
+        
+        return json
+    
+    @classmethod
+    def create(cls):
+        """Creates construction stages in the database"""
+        MidasAPI("PUT", "/db/stag", CS.json())
+    
+    @classmethod
+    def get(cls):
+        """Gets construction stage data from the database"""
+        return MidasAPI("GET", "/db/stag")
+    
+    @classmethod
+    def sync(cls):
+        """Updates the CS class with data from the database"""
+        cls.CSA = []
+        a = CS.get()
+        if a != {'message': ''}:
+            if "STAG" in a:
+                stag_data_dict = a["STAG"]
+            else:
+                return  
+                
+            for stag_id, stag_data in stag_data_dict.items():
+                # Basic stage data
+                name = stag_data.get("NAME")
+                duration = stag_data.get("DURATION")
+                sr_stage = stag_data.get("bSV_RSLT")
+                ad_stage = stag_data.get("bSV_STEP")
+                load_in = stag_data.get("bLOAD_STEP")
+                nl = stag_data.get("INCRE_STEP")
+                addstp = stag_data.get("ADD_STEP")
+                
+                # Create a new CS object with basic properties
+                new_cs = CS(
+                    name=name,
+                    duration=duration,
+                    id=int(stag_id),
+                    sr_stage=sr_stage,
+                    ad_stage=ad_stage,
+                    load_in=load_in,
+                    nl=nl,
+                    addstp=addstp
+                )
+                
+                CS.CSA.pop()
+                
+                # Process activation elements
+                if "ACT_ELEM" in stag_data and stag_data["ACT_ELEM"]:
+                    for elem in stag_data["ACT_ELEM"]:
+                        group_name = elem.get("GRUP_NAME")
+                        age = elem.get("AGE")
+                        new_cs.act_structure_groups.append({"name": group_name, "age": age})
+                
+                # Process deactivation elements
+                if "DACT_ELEM" in stag_data and stag_data["DACT_ELEM"]:
+                    for elem in stag_data["DACT_ELEM"]:
+                        if isinstance(elem, dict):
+                            group_name = elem.get("GRUP_NAME")
+                            redist = elem.get("REDIST")
+                        else:
+                            group_name = elem
+                            redist = 0
+                        new_cs.deact_structure_groups.append({"name": group_name, "redist": redist})
+                
+                # Process activation boundary groups
+                if "ACT_BNGR" in stag_data and stag_data["ACT_BNGR"]:
+                    for bngr in stag_data["ACT_BNGR"]:
+                        group_name = bngr.get("BNGR_NAME")
+                        pos = bngr.get("POS")
+                        new_cs.act_boundary_groups.append({"name": group_name, "pos": pos})
+                
+                # Process deactivation boundary groups
+                if "DACT_BNGR" in stag_data and stag_data["DACT_BNGR"]:
+                    for bngr in stag_data["DACT_BNGR"]:
+                        new_cs.deact_boundary_groups.append(bngr)
+                
+                # Process activation loads
+                if "ACT_LOAD" in stag_data and stag_data["ACT_LOAD"]:
+                    for load in stag_data["ACT_LOAD"]:
+                        group_name = load.get("LOAD_NAME")
+                        day = load.get("DAY")
+                        new_cs.act_load_groups.append({"name": group_name, "day": day})
+                
+                # Process deactivation loads
+                if "DACT_LOAD" in stag_data and stag_data["DACT_LOAD"]:
+                    for load in stag_data["DACT_LOAD"]:
+                        if isinstance(load, dict):
+                            group_name = load.get("LOAD_NAME")
+                            day = load.get("DAY")
+                        else:
+                            group_name = load
+                            day = "FIRST"
+                        new_cs.deact_load_groups.append({"name": group_name, "day": day})
+                
+                CS.CSA.append(new_cs)
+    
+    @classmethod
+    def delete(cls):
+        """Deletes all construction stages from the database and resets the class"""
+        cls.CSA = []
+        return MidasAPI("DELETE", "/db/stag")

midas_civil/_element.py

@@ -1,5 +1,6 @@
 from ._mapi import *
 from ._node import *
+from ._group import _add_elem_2_stGroup
 
 import numpy as np
 
@@ -8,6 +9,8 @@ def _ADD(self):
     Adds an element to the main list. If the ID is 0, it auto-increments.
     If the ID already exists, it replaces the existing element.
     """
+
+    # ------------  ID assignment -----------------------
     id = int(self.ID)
     if not Element.ids:
         count = 1
@@ -27,6 +30,20 @@ def _ADD(self):
         self.ID = id
         Element.elements.append(self)
         Element.ids.append(int(self.ID))
+    
+    # ------------  Group assignment -----------------------
+    if self._GROUP == '' :
+        pass
+    elif isinstance(self._GROUP, list):
+        for gpName in self._GROUP:
+            _add_elem_2_stGroup(self.ID,gpName)
+    elif isinstance(self._GROUP, str):
+        _add_elem_2_stGroup(self.ID,self._GROUP)
+            
+
+
+
+
 
 def _updateElem(self):
     """Sends a PUT request to update a single element in Midas."""
@@ -166,7 +183,7 @@ class Element:
 
     class Beam(_common):
 
-        def __init__(self, i: int, j: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0):
+        def __init__(self, i: int, j: int, mat: int = 1, sect: int = 1, angle: float = 0, group = "" , id: int = 0):
             """
             Creates a BEAM element for frame analysis.
             
@@ -176,6 +193,7 @@ class Element:
                 mat: Material property number (default 1)
                 sect: Section property number (default 1)
                 angle: Beta angle for section orientation in degrees (default 0.0)
+                group: Structure group of the element (str or list; 'SG1' or ['SG1','SG2'])
                 id: Element ID (default 0 for auto-increment)
             
             Examples:
@@ -199,10 +217,11 @@ class Element:
             self.SECT = sect
             self.NODE = [i, j]
             self.ANGLE = angle
+            self._GROUP = group
             _ADD(self)
 
         @staticmethod
-        def SDL(s_loc:list,dir:list,l:float,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0): #CHANGE TO TUPLE
+        def SDL(s_loc:list,dir:list,l:float,n:int=1,mat:int=1,sect:int=1,angle:float=0, group = "" , id: int = 0): #CHANGE TO TUPLE
                 beam_nodes =[]
                 beam_obj = []
                 s_locc = np.array(s_loc)
@@ -216,13 +235,13 @@ class Element:
                 for i in range(n):
                     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,id_new))
+                    beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,group,id_new))
                 
                 return beam_obj
                     
 
         @staticmethod
-        def SE(s_loc:list,e_loc:list,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0):
+        def SE(s_loc:list,e_loc:list,n:int=1,mat:int=1,sect:int=1,angle:float=0, group = "" , id: int = 0):
                 beam_nodes =[]
                 beam_obj = []
                 i_loc = np.linspace(s_loc,e_loc,n+1)
@@ -233,12 +252,12 @@ class Element:
                 for i in range(n):
                     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,id_new))
+                    beam_obj.append(Element.Beam(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,group,id_new))
                 
                 return beam_obj
 
     class Truss(_common):
-        def __init__(self, i: int, j: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0):
+        def __init__(self, i: int, j: int, mat: int = 1, sect: int = 1, angle: float = 0, group = "" , id: int = 0):
             """
             Creates a TRUSS element
             
@@ -248,6 +267,7 @@ class Element:
                 mat: Material property number (default 1)
                 sect: Section property number (default 1)
                 angle: Beta angle for section orientation in degrees (default 0.0)
+                group: Structure group of the element (str or list; 'SG1' or ['SG1','SG2'])
                 id: Element ID (default 0 for auto-increment)
             
             Examples:
@@ -268,10 +288,11 @@ class Element:
             self.SECT = sect
             self.NODE = [i, j]
             self.ANGLE = angle
+            self._GROUP = group
             _ADD(self)
 
         @staticmethod
-        def SDL(s_loc:list,dir:list,l:float,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0):
+        def SDL(s_loc:list,dir:list,l:float,n:int=1,mat:int=1,sect:int=1,angle:float=0, group = "" , id: int = 0):
             beam_nodes =[]
             beam_obj =[]
             s_locc = np.array(s_loc)
@@ -285,13 +306,13 @@ class Element:
             for i in range(n):
                 if id == 0 : id_new = 0
                 else: id_new = id+i
-                beam_obj.append(Element.Truss(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
+                beam_obj.append(Element.Truss(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,group,id_new))
             
             return beam_obj
                 
 
         @staticmethod
-        def SE(s_loc:list,e_loc:list,n:int=1,mat:int=1,sect:int=1,angle:float=0,id:int=0):
+        def SE(s_loc:list,e_loc:list,n:int=1,mat:int=1,sect:int=1,angle:float=0, group = "" , id: int = 0):
             beam_nodes =[]
             beam_obj = []
             i_loc = np.linspace(s_loc,e_loc,n+1)
@@ -302,12 +323,12 @@ class Element:
             for i in range(n):
                 if id == 0 : id_new = 0
                 else: id_new = id+i
-                beam_obj.append(Element.Truss(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,id_new))
+                beam_obj.append(Element.Truss(beam_nodes[i],beam_nodes[i+1],mat,sect,angle,group,id_new))
             
             return beam_obj 
           
     class Plate(_common):
-        def __init__(self, nodes: list, stype: int = 1, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0):
+        def __init__(self, nodes: list, stype: int = 1, mat: int = 1, sect: int = 1, angle: float = 0, group = "" , id: int = 0):
             """
             Creates a PLATE element.
             
@@ -317,6 +338,7 @@ class Element:
                 mat: Material property number (default 1)
                 sect: Section (thickness) property number (default 1)
                 angle: Material angle for orthotropic materials in degrees (default 0.0)
+                group: Structure group of the element (str or list; 'SG1' or ['SG1','SG2'])
                 id: Element ID (default 0 for auto-increment)
             
             Examples:
@@ -338,10 +360,11 @@ class Element:
             self.NODE = nodes
             self.ANGLE = angle
             self.STYPE = stype
+            self._GROUP = group
             _ADD(self)
             
     class Tension(_common):
-     def __init__(self, i: int, j: int, stype: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0, non_len: float = None, cable_type: int = None, tens: float = None, t_limit: float = None):
+     def __init__(self, i: int, j: int, stype: int, mat: int = 1, sect: int = 1, angle: float = 0, group = "" , id: int = 0, non_len: float = None, cable_type: int = None, tens: float = None, t_limit: float = None):
         """
         Creates a TENSTR (Tension-only) element.
         
@@ -352,6 +375,7 @@ class Element:
             mat: Material property number (default 1)
             sect: Section property number (default 1)
             angle: Beta angle for section orientation in degrees (default 0.0)
+            group: Structure group of the element (str or list; 'SG1' or ['SG1','SG2'])
             id: Element ID (default 0 for auto-increment)
             non_len: Non-linear length parameter for Hook/Cable (default None)
             cable_type: Cable type for stype=3 (1=Pretension, 2=Horizontal, 3=Lu) (default None)
@@ -380,6 +404,7 @@ class Element:
         self.NODE = [i, j]
         self.ANGLE = angle
         self.STYPE = stype
+        self._GROUP = group
         
         # Handle subtype-specific parameters
         if stype == 1:  # Tension-only specific
@@ -403,7 +428,7 @@ class Element:
         _ADD(self)
 
     class Compression(_common):
-        def __init__(self, i: int, j: int, stype: int, mat: int = 1, sect: int = 1, angle: float = 0, id: int = 0, tens: float = None, t_limit: float = None, non_len: float = None):
+        def __init__(self, i: int, j: int, stype: int, mat: int = 1, sect: int = 1, angle: float = 0, group = "" , id: int = 0, tens: float = None, t_limit: float = None, non_len: float = None):
             """
             Creates a COMPTR (Compression-only) element.
             
@@ -414,6 +439,7 @@ class Element:
                 mat: Material property number (default 1)
                 sect: Section property number (default 1)
                 angle: Beta angle for section orientation in degrees (default 0.0)
+                group: Structure group of the element (str or list; 'SG1' or ['SG1','SG2'])
                 id: Element ID (default 0 for auto-increment)
                 tens: Allowable tension or initial compression force (default None)
                 t_limit: Compression limit value. If provided, the compression limit flag is set to True. (default None)
@@ -438,6 +464,7 @@ class Element:
             self.NODE = [i, j]
             self.ANGLE = angle
             self.STYPE = stype
+            self._GROUP = group
             
             # Handle subtype-specific parameters
             if stype == 1:  # Compression-only specific
@@ -453,7 +480,7 @@ class Element:
             _ADD(self)
 
     class Solid(_common):
-        def __init__(self, nodes: list, mat: int = 1, sect: int = 0, id: int = 0):
+        def __init__(self, nodes: list, mat: int = 1, sect: int = 0, group = "" , id: int = 0):
             """
             Creates a SOLID element for 3D analysis.
             
@@ -463,6 +490,7 @@ class Element:
                        - 6 nodes: Pentahedral element  
                        - 8 nodes: Hexahedral element
                 mat: Material property number (default 1)
+                group: Structure group of the element (str or list; 'SG1' or ['SG1','SG2'])
                 id: Element ID (default 0 for auto-increment)
             
             Examples:
@@ -484,6 +512,7 @@ class Element:
             self.MATL = mat
             self.SECT = sect # Solid elements don't use section properties
             self.NODE = nodes
+            self._GROUP = group
             _ADD(self)