Frank faulstich solid set loads

RFEM/BasicObjects/solidSet.py

@@ -83,7 +83,7 @@ def GroupOfSolids(self,
         clientObject.no = no
 
         # Solids number
-        clientObject.solides = ConvertToDlString(solids_no)
+        clientObject.solids = ConvertToDlString(solids_no)
 
         # Solid Set Type
         clientObject.set_type = solid_set_type.name

RFEM/Loads/solidSetLoad.py

@@ -0,0 +1,280 @@
+from RFEM.initModel import *
+from RFEM.enums import *
+
+class SolidSetLoad():
+
+    def __init__(self,
+                 no: int =1,
+                 load_case_no: int = 1,
+                 solid_sets_no: str= '1',
+                 load_type = SolidSetLoadType.LOAD_TYPE_FORCE,
+                 load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM,
+                 load_direction = SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,
+                 magnitude: float = 0,
+                 comment: str = '',
+                 params: dict = {}):
+
+        # Client model | Solid Load
+        clientObject = clientModel.factory.create('ns0:solid_set_load')
+
+        # Clears object attributes | Sets all attributes to None
+        clearAtributes(clientObject)
+
+        # Load No.
+        clientObject.no = no
+
+        # Load Case No.
+        clientObject.load_case = load_case_no
+
+        # Assigned Solid No.
+        clientObject.solid_sets = ConvertToDlString(solid_sets_no)
+
+        # Load Type
+        clientObject.load_type = load_type.name
+
+        # Load Distribution
+        clientObject.load_distribution = load_distribution.name
+
+        # Load Direction
+        clientObject.load_direction = load_direction.name
+
+        # Load Magnitude
+        clientObject.uniform_magnitude = magnitude
+
+        # Comment
+        clientObject.comment = comment
+
+        # Adding optional parameters via dictionary
+        for key in params:
+            clientObject[key] = params[key]
+
+        # Add Solid Load to client model
+        clientModel.service.set_solid_set_load(load_case_no, clientObject)
+
+
+    def Force(self,
+              no: int =1,
+              load_case_no: int = 1,
+              solid_sets_no: str= '1',
+              load_direction = SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,
+              magnitude: float = 0,
+              comment: str = '',
+              params: dict = {}):
+
+        # Client model | Solid Load
+        clientObject = clientModel.factory.create('ns0:solid_set_load')
+
+        # Clears object attributes | Sets all attributes to None
+        clearAtributes(clientObject)
+
+        # Load No.
+        clientObject.no = no
+
+        # Load Case No.
+        clientObject.load_case = load_case_no
+
+        # Assigned Solid No.
+        clientObject.solid_sets = ConvertToDlString(solid_sets_no)
+
+        # Load Type
+        clientObject.load_type = SolidSetLoadType.LOAD_TYPE_FORCE.name
+
+        # Load Distribution
+        clientObject.load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name
+
+        # Load Direction
+        clientObject.load_direction = load_direction.name
+
+        # Load Magnitude
+        clientObject.uniform_magnitude = magnitude
+
+        # Comment
+        clientObject.comment = comment
+
+        # Adding optional parameters via dictionary
+        for key in params:
+            clientObject[key] = params[key]
+
+        # Add Solid Load to client model
+        clientModel.service.set_solid_set_load(load_case_no, clientObject)
+
+    def Temperature(self,
+                    no: int = 1,
+                    load_case_no: int = 1,
+                    solid_sets_no: str= '1',
+                    load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM,
+                    load_parameter = None,
+                    comment: str = '',
+                    params: dict = {}):
+        '''
+        load_parameter:
+            LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude
+            LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [magnitude_1, magnitude_2, node_1, node_2]
+            LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [magnitude_1, magnitude_2, node_1, node_2]
+            LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [magnitude_1, magnitude_2, node_1, node_2]
+        params:
+            {''}
+        '''
+        # Client model | Solid Load
+        clientObject = clientModel.factory.create('ns0:solid_set_load')
+
+        # Clears object attributes | Sets all attributes to None
+        clearAtributes(clientObject)
+
+        # Load No.
+        clientObject.no = no
+
+        # Load Case No.
+        clientObject.load_case = load_case_no
+
+        # Assigned Solid No.
+        clientObject.solid_sets = ConvertToDlString(solid_sets_no)
+
+        # Load Type
+        clientObject.load_type = SolidSetLoadType.LOAD_TYPE_TEMPERATURE.name
+
+        # Load Distribution
+        if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM":
+            clientObject.uniform_magnitude = load_parameter
+        else:
+            clientObject.magnitude_1 = load_parameter[0]
+            clientObject.magnitude_2 = load_parameter[1]
+            clientObject.node_1 = load_parameter[2]
+            clientObject.node_2 = load_parameter[3]
+
+        clientObject.load_distribution = load_distribution.name
+
+        # Comment
+        clientObject.comment = comment
+
+        # Adding optional parameters via dictionary
+        for key in params:
+            clientObject[key] = params[key]
+
+        # Add Solid Load to client model
+        clientModel.service.set_solid_set_load(load_case_no, clientObject)
+
+    def Strain(self,
+               no: int = 1,
+               load_case_no: int = 1,
+               solid_sets_no: str= '1',
+               load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM,
+               load_parameter = None,
+               comment: str = '',
+               params: dict = {}):
+        '''
+        load_parameter:
+            LOAD_DISTRIBUTION_UNIFORM: load_parameter = [strain_uniform_magnitude_x, strain_uniform_magnitude_y, strain_uniform_magnitude_z]
+            LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2]
+            LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2]
+            LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2]
+        params:
+            {''}
+        '''
+        # Client model | Solid Load
+        clientObject = clientModel.factory.create('ns0:solid_set_load')
+
+        # Clears object attributes | Sets all attributes to None
+        clearAtributes(clientObject)
+
+        # Load No.
+        clientObject.no = no
+
+        # Load Case No.
+        clientObject.load_case = load_case_no
+
+        # Assigned Solid No.
+        clientObject.solid_sets = ConvertToDlString(solid_sets_no)
+
+        # Load Type
+        clientObject.load_type = SolidSetLoadType.LOAD_TYPE_STRAIN.name
+
+        # Load Distribution
+        if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM":
+            clientObject.strain_uniform_magnitude_x = load_parameter[0]
+            clientObject.strain_uniform_magnitude_y = load_parameter[1]
+            clientObject.strain_uniform_magnitude_z = load_parameter[2]
+        else:
+            clientObject.strain_magnitude_x1 = load_parameter[0]
+            clientObject.strain_magnitude_y1 = load_parameter[1]
+            clientObject.strain_magnitude_z1 = load_parameter[2]
+            clientObject.strain_magnitude_x2 = load_parameter[3]
+            clientObject.strain_magnitude_y2 = load_parameter[4]
+            clientObject.strain_magnitude_z2 = load_parameter[5]
+            clientObject.node_1 = load_parameter[6]
+            clientObject.node_2 = load_parameter[7]
+
+        clientObject.load_distribution = load_distribution.name
+
+        # Comment
+        clientObject.comment = comment
+
+        # Adding optional parameters via dictionary
+        for key in params:
+            clientObject[key] = params[key]
+
+        # Add Solid Load to client model
+        clientModel.service.set_solid_set_load(load_case_no, clientObject)
+
+    def Motion(self,
+               no: int = 1,
+               load_case_no: int = 1,
+               solid_sets_no: str= '1',
+               load_parameter = None,
+               comment: str = '',
+               params: dict = {}):
+        '''
+        load_parameter:
+            load_parameter = [angular_velocity, angular_acceleration, axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z, axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z]
+        params:
+            {''}
+        '''
+        # Client model | Solid Load
+        clientObject = clientModel.factory.create('ns0:solid_set_load')
+
+        # Clears object attributes | Sets all attributes to None
+        clearAtributes(clientObject)
+
+        # Load No.
+        clientObject.no = no
+
+        # Load Case No.
+        clientObject.load_case = load_case_no
+
+        # Assigned Solid No.
+        clientObject.solid_sets = ConvertToDlString(solid_sets_no)
+
+        # Load Type
+        clientObject.load_type = SolidSetLoadType.LOAD_TYPE_ROTARY_MOTION.name
+
+        # Velocity
+        clientObject.angular_velocity = load_parameter[0]
+
+        # Acceleration
+        clientObject.angular_acceleration = load_parameter[1]
+
+        # Axis Definition
+        clientObject.axis_definition_p1_x = load_parameter[2]
+        clientObject.axis_definition_p1_y = load_parameter[3]
+        clientObject.axis_definition_p1_z = load_parameter[4]
+        clientObject.axis_definition_p2_x = load_parameter[5]
+        clientObject.axis_definition_p2_y = load_parameter[6]
+        clientObject.axis_definition_p2_z = load_parameter[7]
+
+        # Comment
+        clientObject.comment = comment
+
+        # Adding optional parameters via dictionary
+        for key in params:
+            clientObject[key] = params[key]
+
+        # Add Solid Load to client model
+        clientModel.service.set_solid_set_load(load_case_no, clientObject)
+
+    def Buoyancy():
+        print('The function Buoyancy() is not implemented yet.')
+        pass
+
+    def Gass():
+        print('The function Gass() is not implemented yet.')
+        pass

RFEM/enums.py

@@ -647,24 +647,24 @@ class SolidLoadDirection(Enum):
     Solid Load Load Direction | Enum
     '''
     LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE = range(3)
-
-class PeriodicResponseCombinationRule(Enum):
+class SolidSetLoadType(Enum):
     '''
-    Spectral Analysis Settings Combination Rule For Periodic Responses
+    Solidset Load Load Type | Enum
     '''
-    ABSOLUTE_SUM, CQC, SRSS = range(3)
+    LOAD_TYPE_BUOYANCY, LOAD_TYPE_FORCE, LOAD_TYPE_GAS, LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_STRAIN, LOAD_TYPE_TEMPERATURE = range(6)
 
-class DirectionalComponentCombinationRule(Enum):
+class SolidSetLoadDistribution(Enum):
     '''
-    Spectral Analysis Settings Combination Rule For Directional Components
+    Solidset Load Load Distribution | Enum
     '''
-    ABSOLUTE_SUM, SCALED_SUM, SRSS = range(3)
+    LOAD_DISTRIBUTION_LINEAR_IN_X, LOAD_DISTRIBUTION_LINEAR_IN_Y, LOAD_DISTRIBUTION_LINEAR_IN_Z, LOAD_DISTRIBUTION_UNIFORM = range(4)
 
-class CqsDampingRule(Enum):
+class SolidSetLoadDirection(Enum):
     '''
-    Spectal Analysis Settings Damping for CQC Rule
+    Solidset Load Load Direction | Enum
     '''
-    CONSTANT_FOR_EACH_MODE, DIFFERENT_FOR_EACH_MODE = range(2)
+    LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE = range(3)
+
 
 class StabilityAnalysisSettingsAnalysisType(Enum):
     '''

UnitTests/test_SolidLoads.py

@@ -1,4 +1,5 @@
 from RFEM.Loads.solidLoad import SolidLoad
+from RFEM.Loads.solidSetLoad import SolidSetLoad
 from RFEM.enums import *
 from RFEM.window import *
 from RFEM.dataTypes import *
@@ -153,6 +154,16 @@ def test_solid_loads():
     # Solid Set
     SolidSet.ContinuousSolids(SolidSet, 1, '2 3')
 
+    SolidSetLoad(1, 1, '1', SolidSetLoadType.LOAD_TYPE_FORCE, SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE, 58.9*1000, 'My Comment')
+    SolidSetLoad.Force(SolidSetLoad, 2, 1, '1', SolidLoadDirection.LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE, 8974.123, 'My 2nd Comment')
+    SolidSetLoad.Temperature(SolidSetLoad, 3, 1, '1', SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, [25489], 'My 3rd Comment')
+    SolidSetLoad.Temperature(SolidSetLoad, 4, 1, '1', SolidSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, [1.5, 8.9, 16, 15], 'My 3rd Comment')
+    SolidSetLoad.Strain(SolidSetLoad, 5, 1, '1', SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, [0.1, 0.2, 0.3], 'My Comment')
+    SolidSetLoad.Strain(SolidSetLoad, 6, 1, '1', SolidLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y, [0.1, 0.2, 0.3, 0.1, 0.2, 0.3, 13, 16])
+    SolidSetLoad.Motion(SolidSetLoad, 7, 1, '1', [1.5, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0])
+    SolidSetLoad.Buoyancy()
+    SolidSetLoad.Gass()
+
     #Calculate_all()
     print('Ready!')