diff --git a/RFEM/BasicObjects/solidSet.py b/RFEM/BasicObjects/solidSet.py index 8e941a15..09b111c8 100644 --- a/RFEM/BasicObjects/solidSet.py +++ b/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 diff --git a/RFEM/Loads/solidSetLoad.py b/RFEM/Loads/solidSetLoad.py new file mode 100644 index 00000000..dc8ff5e0 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/RFEM/enums.py b/RFEM/enums.py index 72b171b9..2048e641 100644 --- a/RFEM/enums.py +++ b/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): ''' diff --git a/UnitTests/test_SolidLoads.py b/UnitTests/test_SolidLoads.py index 83f81745..e843b1e4 100644 --- a/UnitTests/test_SolidLoads.py +++ b/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!')