Several update

Author: OpenStaad

openstaad/__init__.py

@@ -4,3 +4,6 @@
 from .output import Output
 from .properties import Properties
 from .view import View
+from .support import Support
+from .command import Command
+from .design import Design

openstaad/command.py

@@ -0,0 +1,27 @@
+from openstaad.tools import *
+from comtypes import automation
+from comtypes import client
+
+class Command():
+    def __init__(self):
+        self._staad = client.GetActiveObject("StaadPro.OpenSTAAD")
+        self._command = self._staad.Command
+
+        self._functions= [
+           'PerformAnalysis',
+        ]
+
+        for function_name in self._functions:
+            self._command._FlagAsMethod(function_name)
+
+    def PerformAnalysis(self,print_option:int):
+        """ 
+        --> 1 - Print Load Data
+        --> 2 - Print Statics Check
+        --> 3 - Print Static Load
+        --> 4 - Print Mode Shapes
+        --> 5 - Print Both
+        --> 6 - Print All
+        --> 0 - No Print
+        """
+        self._command.PerformAnalysis(print_option)

openstaad/design.py

@@ -0,0 +1,34 @@
+from openstaad.tools import *
+from comtypes import automation
+from comtypes import client
+
+class Design():
+    def __init__(self):
+        self._staad = client.GetActiveObject("StaadPro.OpenSTAAD")
+        self._design = self._staad.Design
+
+        self._functions= [
+           'CreateDesignBrief',
+           'AssignDesignCommand'
+        ]
+
+        for function_name in self._functions:
+            self._design._FlagAsMethod(function_name)
+
+    def CreateDesignBrief(self,design_code:int):
+        """ 
+        """
+        self._design.CreateDesignBrief(design_code)
+
+    def AssignDesignCommand(self,brief_reference:int,command_name:str,command_value:str,members:list[int]):
+        """ 
+        """
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        # Crear SAFEARRAY para 'release'
+        safe_list_members = make_safe_array_long(members)
+        members = make_variant_vt_ref(safe_list_members, automation.VT_ARRAY | automation.VT_I4)
+
+        self._design.AssignDesignCommand(brief_reference,command_name,command_value,members)

openstaad/geometry.py

@@ -35,8 +35,12 @@ def __init__(self):
             'SelectMultipleBeams',
             'GetGroupCount',
             'GetGroupNames',
-            'CreatePhysicalMember'
-
+            'CreatePhysicalMember',
+            'AddNode',
+            'AddBeam',
+            'DoTranslationalRepeat',
+            'GetIntersectBeamsCount',
+            'IntersectBeams'
         ]
 
         for function_name in self._functions:
@@ -227,3 +231,89 @@ def CreatePhysicalMember(self,member_list:list):
         retval=self._geometry.CreatePhysicalMember(num,lista_variant,None)
 
 
+
+    def AddNode(self,x:float=0.0,y:float=0.0,z:float=0.0):
+        retval=self._geometry.AddNode(x,y,z)
+        return retval
+    
+    def AddBeam(self,node_A,node_B):
+        retval=self._geometry.AddBeam(node_A,node_B)
+        return retval
+
+    def make_safe_array_long(data):
+        if not isinstance(data, list):
+            raise TypeError("Data must be a list of integers")
+        
+        size = len(data)
+        safe_array = automation._midlSAFEARRAY(ctypes.c_long).create([0] * size)
+        
+        for i in range(size):
+            safe_array[i] = data[i]
+        
+        return safe_array
+
+    def make_variant_vt_ref(safe_array, vt_type):
+        variant = automation.VARIANT()
+        variant.vt = vt_type
+        variant._.parray = safe_array
+        return variant
+    
+    def DoTranslationalRepeat(self, varLinkBays: bool, varOpenBase: bool, varAxisDir: int, varSpacingArray: list[float], varNobays: int, varRenumberBay: bool, varRenumberArray: list, varGeometryOnly: bool):
+        try:
+            
+            def make_safe_array_double(array):
+                size = len(array)
+                return automation._midlSAFEARRAY(ctypes.c_double).create(array)
+
+            # Conversión de varSpacingArray
+            safe_spacing_array = make_safe_array_double(varSpacingArray)
+            varSpacingArray = make_variant_vt_ref(safe_spacing_array, automation.VT_ARRAY | automation.VT_R8)
+            
+            retval = self._geometry.DoTranslationalRepeat(varLinkBays, varOpenBase, varAxisDir, varSpacingArray, varNobays, varRenumberBay, varRenumberArray, varGeometryOnly)
+            return retval
+        except Exception as e:
+            print(f"An error occurred in DoTranslationalRepeat: {e}")
+            raise
+    
+    def IntersectBeams(self, Method: int, BeamNosArray: list[int], dTolerance: float, NewBeamNosArray: int):
+        
+        # Conversión de dTolerance
+        safe_n1 = make_safe_array_double(1)
+        dTolerance = make_variant_vt_ref(safe_n1, automation.VT_R8)
+
+        # Ajuste en make_safe_array_long para manejar listas
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        # Conversión de BeamNosArray
+        safe_beam_list = make_safe_array_long(BeamNosArray)
+        BeamNosArray = make_variant_vt_ref(safe_beam_list, automation.VT_ARRAY | automation.VT_I4)
+        
+        # Conversión de NewBeamNosArray
+        # safe_beam_list = make_safe_array_long(NewBeamNosArray)
+        # NewBeamNosArray = make_variant_vt_ref(safe_beam_list, automation.VT_ARRAY | automation.VT_I4)
+
+        
+        # Llamada a la función interna
+        retval = self._geometry.IntersectBeams(Method, BeamNosArray, dTolerance, NewBeamNosArray)
+        return retval
+    
+    def GetIntersectBeamsCount(self, BeamNosArray: list[int], dTolerance: float):
+        safe_n1 = make_safe_array_double(1)
+        dTolerance = make_variant_vt_ref(safe_n1, automation.VT_R8)
+        
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        safe_list = make_safe_array_long(BeamNosArray)
+        BeamNosArray = make_variant_vt_ref(safe_list, automation.VT_ARRAY | automation.VT_I4)
+        
+        n_beams = self._geometry.GetIntersectBeamsCount(BeamNosArray, dTolerance)
+        return n_beams
+    
+
+    
+
+

openstaad/load.py

@@ -8,11 +8,31 @@ def __init__(self):
         self._load = self._staad.Load
 
         self._functions= [
-            'GetLoadCaseTitle'
+            'GetLoadCaseTitle',
+            'AddMemberConcForce',
+            'SetLoadActive',
+            'CreateNewPrimaryLoad'
         ]
 
         for function_name in self._functions:
             self._load._FlagAsMethod(function_name)
 
     def GetLoadCaseTitle(self,lc):
         return self._load.GetLoadCaseTitle(lc)
+    
+    def AddMemberConcForce(self,varBeamNo:list[int],varDirection:int,varForce:float,varD1:float,varD2:float):
+
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        safe_list = make_safe_array_long(varBeamNo)
+        varBeamNo = make_variant_vt_ref(safe_list, automation.VT_ARRAY | automation.VT_I4)
+
+        self._load.AddMemberConcForce(varBeamNo,varDirection,varForce,varD1,varD2)
+        
+    def SetLoadActive(self,varLoadNo:int):
+        self._load.SetLoadActive(varLoadNo)
+
+    def CreateNewPrimaryLoad(self,LoadTitle:str="LOAD CASE X"):
+        self._load.CreateNewPrimaryLoad(LoadTitle)

openstaad/output.py

@@ -31,6 +31,7 @@ def GetMemberEndForces(self,beam, start = True, lc :int= 1,local: int = 0):
         return x.value[0]
 
     def GetSupportReactions(self, node,lc :int= 1):
+        
         safe_n1 = make_safe_array_double(6)
         x = make_variant_vt_ref(safe_n1,  automation.VT_ARRAY |  automation.VT_R8)
 

openstaad/properties.py

@@ -13,7 +13,12 @@ def __init__(self):
             'GetSectionPropertyValues',
             'GetAlphaAngleForSection',
             'GetMemberReleaseSpecEx',
-            'GetMemberSpecCode'
+            'GetMemberSpecCode',
+            'CreateBeamPropertyFromTable',
+            'CreateMemberReleaseSpec',
+            'AssignMemberSpecToBeam',
+            'AssignBeamProperty',
+            'AssignMaterialToMember'
         ]
 
         for function_name in self._functions:
@@ -164,4 +169,115 @@ def GetMemberSpecCode(self, memb):
         make_safe_array_int = make_safe_array_long(1)
         spe = make_variant_vt_ref(make_safe_array_int, automation.VT_ARRAY | automation.VT_I4)
         # print(Warning('GetMemberSpecCode output could be wrong'))
-        return int(self._property.GetMemberSpecCode(memb,spe))
+        return int(self._property.GetMemberSpecCode(memb,spe))
+    
+
+
+    def CreateBeamPropertyFromTable(self,Country_code:int,profile_name:str,type_spec:int=0,spec_1:float=0.0,spec_2:float=0.0):
+        
+        """
+        COUNTRY CODE
+         1->    American
+         2->	Australian
+         3->	British
+         4->	Canadian
+         5->	Chinese
+         6->	Dutch
+         7->	European
+         8->	French
+         9->	German
+         10->	Indian
+         11->	Japanese
+         12->	Russian
+         13->	Southafrican
+         14->	Spanish
+         15->	Venezuelan
+         16->	Korean
+         17->	Aluminum
+         18->	American cold formed
+         19->	Indian cold formed
+         20->	Mexican
+         21->	American Steel Joist
+         22->	AITCTimber
+         23->	Lysaght cold formed
+         24->	British cold formed
+         25->	Canadian Timber
+         26->	Butler cold formed
+         27->	Kingspan cold formed
+         28->	RCeco cold formed
+         29->	Japanese cold formed
+         30->	Australian cold formed
+        """
+        propertyNo = self._property.CreateBeamPropertyFromTable(Country_code,profile_name,type_spec,spec_1,spec_2)
+
+    def CreateMemberReleaseSpec(self, location: int, release: list[int], spring_const: list[float]):
+        """
+        LOCATION
+            0 -> Start
+            1 -> End
+        RELEASE
+            [FX, FY, FZ, MX, MY, MZ]
+        SPRINGCONST
+            [KFX, KFY, KFZ, KMX, KMY, KMZ]
+        """
+        
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        def make_safe_array_double(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_double).create(array)
+        
+        # Crear SAFEARRAY para 'release'
+        safe_list_release = make_safe_array_long(release)
+        release_variant = make_variant_vt_ref(safe_list_release, automation.VT_ARRAY | automation.VT_I4)
+        
+        # Crear SAFEARRAY para 'spring_const'
+        safe_list_spring_const = make_safe_array_double(spring_const)
+        spring_const_variant = make_variant_vt_ref(safe_list_spring_const, automation.VT_ARRAY | automation.VT_R8)
+        
+        # Llamar a la función con los parámetros correctos
+        retval = self._property.CreateMemberReleaseSpec(location, release_variant, spring_const_variant)
+        return retval
+
+    def AssignMemberSpecToBeam(self, Beams: list[int], specNo: int):
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        # Crear SAFEARRAY para 'release'
+        safe_list_release = make_safe_array_long(Beams)
+        Beams = make_variant_vt_ref(safe_list_release, automation.VT_ARRAY | automation.VT_I4)
+
+        retval= self._property.AssignMemberSpecToBeam(Beams, specNo)
+
+        return retval
+    
+    def AssignBeamProperty(self, beams_list: list[int], propertyNo: int):
+        
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        # Crear SAFEARRAY para 'beamNo'
+        safe_list = make_safe_array_long(beams_list)
+        beams_list = make_variant_vt_ref(safe_list, automation.VT_ARRAY | automation.VT_I4)
+
+        retval= self._property.AssignBeamProperty(beams_list, propertyNo)
+
+        return retval
+    
+    def AssignMaterialToMember(self, material_name: str, beamNo: list[int]):
+        
+        def make_safe_array_long(array):
+            size = len(array)
+            return automation._midlSAFEARRAY(ctypes.c_long).create(array)
+        
+        # Crear SAFEARRAY para 'beamNo'
+        safe_list = make_safe_array_long(beamNo)
+        beamNo = make_variant_vt_ref(safe_list, automation.VT_ARRAY | automation.VT_I4)
+
+        retval= self._property.AssignMaterialToMember(material_name, beamNo)
+
+        return retval