From ed14597e0db8115760c219540128d2bb3a7e0b83 Mon Sep 17 00:00:00 2001 From: MichalO Date: Mon, 2 May 2022 12:26:59 +0200 Subject: [PATCH 1/4] Special Objects and Special Objects Types update initial commit --- RFEM/SpecialObjects/enlargedColumnHead.py | 58 ++-- RFEM/SpecialObjects/intersection.py | 11 + RFEM/SpecialObjects/resultSection.py | 235 ++++++++++++++- RFEM/SpecialObjects/structureModification.py | 71 +++++ RFEM/SpecialObjects/surfaceContact.py | 24 +- .../SpecialObjects/surfaceResultAdjustment.py | 70 ++++- .../surfaceContactType.py | 267 +++++++++++++++++- RFEM/enums.py | 56 +++- UnitTests/test_SpecialObjects.py | 99 +++++++ 9 files changed, 855 insertions(+), 36 deletions(-) create mode 100644 UnitTests/test_SpecialObjects.py diff --git a/RFEM/SpecialObjects/enlargedColumnHead.py b/RFEM/SpecialObjects/enlargedColumnHead.py index 76b29665..ba22d3ff 100644 --- a/RFEM/SpecialObjects/enlargedColumnHead.py +++ b/RFEM/SpecialObjects/enlargedColumnHead.py @@ -1,28 +1,30 @@ -from RFEM.initModel import Model, clearAtributes - -class EnlargedColumnHead(): - def __init__(self, - no: int = 1, - comment: str = '', - params: dict = None, - model = Model): - - # Client model | Enlarged Column Head - clientObject = model.clientModel.factory.create('ns0:enlarged_column_head') - - # Clears object atributes | Sets all atributes to None - clearAtributes(clientObject) - - # Enlarged Column Head No. - clientObject.no = no - - # Comment - clientObject.comment = comment - - # Adding optional parameters via dictionary - if params: - for key in params: - clientObject[key] = params[key] - - # Add Enlarged Column Head to client model - model.clientModel.service.set_enlarged_column_head(clientObject) +# TODO: only in pre-release status +# +#from RFEM.initModel import Model, clearAtributes +# +#class EnlargedColumnHead(): +# def __init__(self, +# no: int = 1, +# comment: str = '', +# params: dict = None, +# model = Model): +# +# # Client model | Enlarged Column Head +# clientObject = model.clientModel.factory.create('ns0:enlarged_column_head') +# +# # Clears object atributes | Sets all atributes to None +# clearAtributes(clientObject) +# +# # Enlarged Column Head No. +# clientObject.no = no +# +# # Comment +# clientObject.comment = comment +# +# # Adding optional parameters via dictionary +# if params: +# for key in params: +# clientObject[key] = params[key] +# +# # Add Enlarged Column Head to client model +# model.clientModel.service.set_enlarged_column_head(clientObject) diff --git a/RFEM/SpecialObjects/intersection.py b/RFEM/SpecialObjects/intersection.py index 96a3d255..23ff6a6f 100644 --- a/RFEM/SpecialObjects/intersection.py +++ b/RFEM/SpecialObjects/intersection.py @@ -8,6 +8,17 @@ def __init__(self, comment: str = '', params: dict = None, model = Model): + """ + Intersection + + Args: + no (int, optional): Number + surface_1 (int, optional): Surface number 1 + surface_2 (int, optional): Surface number 2 + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ # Client model | Intersection clientObject = model.clientModel.factory.create('ns0:intersection') diff --git a/RFEM/SpecialObjects/resultSection.py b/RFEM/SpecialObjects/resultSection.py index 82ed22f2..b147e2fd 100644 --- a/RFEM/SpecialObjects/resultSection.py +++ b/RFEM/SpecialObjects/resultSection.py @@ -1,11 +1,218 @@ -from RFEM.initModel import Model, clearAtributes +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import ResultSectionType, ResultSectionProjection, ResultSectionResultDirection class ResultSection(): def __init__(self, no: int = 1, + type = ResultSectionType.TYPE_2_POINTS_AND_VECTOR, + show_section_in_direction = ResultSectionResultDirection.SHOW_RESULTS_IN_LOCAL_PLUS_Z, + show_values_on_isolines: bool = False, + parameters: list = None, + assigned_to_all_surfaces: bool = True, + assigned_to_all_solids: bool = True, comment: str = '', params: dict = None, model = Model): + """ + Result Section + + Args: + no (int, mandatory): Number + type (enum, mandatory): Categories Type + show_section_in_direction (enum, mandatory): Show section in direction + show_values_on_isolines (bool, mandatory): Show values on isolines + parameters (list, mandatory): Variable parameters + if type == ResultSectionType.TYPE_LINE: + [lines] + ['1 2'] + if type == ResultSectionType.TYPE_2_POINTS_AND_VECTOR: + [coordinate_system, first_point_coordinates, second_point_coordinates, projection, vector] + [1, [1,0,0], [0,2,0], ResultSectionProjection.PROJECTION_IN_VECTOR, [1,1,1]] + assigned_to_all_surfaces (bool, optional) = Assigned to all surface + assigned_to_all_solids (bool, optional) Assigned to all solids + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ + + # Client model | Result Section + clientObject = model.clientModel.factory.create('ns0:result_section') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Result Section No. + clientObject.no = no + + # Result Section Type + clientObject.type = type.name + + # Result Section Show Section in Direction + clientObject.show_results_in_direction = show_section_in_direction.name + + # Result Section Show Values on Isolines Option + clientObject.show_values_on_isolines_enabled = show_values_on_isolines + + # Result Section Parameters + if type == ResultSectionType.TYPE_LINE: + clientObject.lines = ConvertToDlString(parameters[0]) + elif type == ResultSectionType.TYPE_2_POINTS_AND_VECTOR: + clientObject.coordinate_system = parameters[0] + clientObject.first_point_coordinate_1 = parameters[1][0] + clientObject.first_point_coordinate_2 = parameters[1][1] + clientObject.first_point_coordinate_3 = parameters[1][2] + clientObject.second_point_coordinate_1 = parameters[2][0] + clientObject.second_point_coordinate_2 = parameters[2][1] + clientObject.second_point_coordinate_3 = parameters[2][2] + clientObject.projection_in_direction = parameters[3].name + if parameters[3] == ResultSectionProjection.PROJECTION_IN_VECTOR: + clientObject.vector_coordinate_1 = parameters[4][0] + clientObject.vector_coordinate_2 = parameters[4][1] + clientObject.vector_coordinate_3 = parameters[4][2] + + # Assigned to all surfaces + if assigned_to_all_surfaces: + clientObject.assigned_to_surfaces = '0' + else: + clientObject.assigned_to_surfaces = '' + + # Assigned to all solids + if assigned_to_all_solids: + clientObject.assigned_to_solids = '0' + else: + clientObject.assigned_to_solids = '' + + # Comment + #clientObject.comment = comment + + # Adding optional parameters via dictionary + if params: + for key in params: + clientObject[key] = params[key] + + # Add Result Section to client model + model.clientModel.service.set_result_section(clientObject) + + @staticmethod + def TwoPointsAndVector( + no: int = 1, + coordinate_system: int = 1, + show_section_in_direction = ResultSectionResultDirection.SHOW_RESULTS_IN_LOCAL_PLUS_Z, + show_values_on_isolines: bool = False, + first_point_coordinates: list = None, + second_point_coordinates: list = None, + projection = ResultSectionProjection.PROJECTION_IN_GLOBAL_X, + vector: list = None, + assigned_to_all_surfaces: bool = True, + assigned_to_all_solids: bool = True, + comment: str = '', + params: dict = None, + model = Model): + """ + Result Section defined by 2 points and vector + + Args: + no (int, mandatory): Number + coordinate_system (int, mandatory): Coordinate system number + show_section_in_direction (enum, mandatory): Show section in direction + show_values_on_isolines (bool, mandatory): Show values on isolines option + first_point_coordinates (list, mandatory): First point coordinates + second_point_coordinates (list, mandatory): Second point coordinates + projection (enum, mandatory): Projection in direction + vector (list, optional): Vector if projection is VECTOR + assigned_to_all_surfaces (bool, optional) = Assigned to all surface + assigned_to_all_solids (bool, optional) Assigned to all solids + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ + + # Client model | Result Section + clientObject = model.clientModel.factory.create('ns0:result_section') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Result Section No. + clientObject.no = no + + # Result Section Coordinate System + clientObject.coordinate_system = coordinate_system + + # Result Section Show Section in Direction + clientObject.show_results_in_direction = show_section_in_direction.name + + # Result Section Show Values on Isolines + clientObject.show_values_on_isolines_enabled = show_values_on_isolines + + # Result Section First Point Coordinates + clientObject.first_point_coordinate_1 = first_point_coordinates[0] + clientObject.first_point_coordinate_2 = first_point_coordinates[1] + clientObject.first_point_coordinate_3 = first_point_coordinates[2] + + # Result Section Second Point Coordinates + clientObject.second_point_coordinate_1 = second_point_coordinates[0] + clientObject.second_point_coordinate_2 = second_point_coordinates[1] + clientObject.second_point_coordinate_3 = second_point_coordinates[2] + + # Result Section Projection + clientObject.projection_in_direction = projection.name + + # Result Section Projection Vector + if projection == ResultSectionProjection.PROJECTION_IN_VECTOR: + clientObject.vector_coordinate_1 = vector[0] + clientObject.vector_coordinate_2 = vector[1] + clientObject.vector_coordinate_3 = vector[2] + + # Assigned to all surfaces + if assigned_to_all_surfaces: + clientObject.assigned_to_surfaces = '0' + else: + clientObject.assigned_to_surfaces = '' + + # Assigned to all solids + if assigned_to_all_solids: + clientObject.assigned_to_solids = '0' + else: + clientObject.assigned_to_solids = '' + + # Comment + #clientObject.comment = comment + + # Adding optional parameters via dictionary + if params: + for key in params: + clientObject[key] = params[key] + + # Add Result Section to client model + model.clientModel.service.set_result_section(clientObject) + + @staticmethod + def Line( + no: int = 1, + show_section_in_direction = ResultSectionResultDirection.SHOW_RESULTS_IN_LOCAL_PLUS_Z, + show_values_on_isolines: bool = False, + lines: str = '1', + assigned_to_all_surfaces: bool = True, + assigned_to_all_solids: bool = True, + comment: str = '', + params: dict = None, + model = Model): + """ + Result Section defined by line + + Args: + no (int, mandatory): Number + type (enum, mandatory): _description_. Defaults to ResultSectionType.TYPE_2_POINTS_AND_VECTOR. + show_section_in_direction (enum, mandatory): _description_. Defaults to ResultSectionResultDirection.SHOW_RESULTS_IN_LOCAL_PLUS_Z. + show_values_on_isolines (bool, mandatory): _description_. Defaults to False. + lines (int, mandatory): Lines + assigned_to_all_surfaces (bool, optional) = Assigned to all surface + assigned_to_all_solids (bool, optional) Assigned to all solids + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ # Client model | Result Section clientObject = model.clientModel.factory.create('ns0:result_section') @@ -16,8 +223,32 @@ def __init__(self, # Result Section No. clientObject.no = no + # Result Section Type + clientObject.type = ResultSectionType.TYPE_LINE.name + + # Result Section Show Section in Direction + clientObject.show_results_in_direction = show_section_in_direction.name + + # Result Section Show Values on Isolines Option + clientObject.show_values_on_isolines_enabled = show_values_on_isolines + + # Result Section Lines + clientObject.lines = ConvertToDlString(lines) + + # Assigned to all surfaces + if assigned_to_all_surfaces: + clientObject.assigned_to_surfaces = '0' + else: + clientObject.assigned_to_surfaces = '' + + # Assigned to all solids + if assigned_to_all_solids: + clientObject.assigned_to_solids = '0' + else: + clientObject.assigned_to_solids = '' + # Comment - clientObject.comment = comment + #clientObject.comment = comment # Adding optional parameters via dictionary if params: diff --git a/RFEM/SpecialObjects/structureModification.py b/RFEM/SpecialObjects/structureModification.py index 6f72b343..3f26b1d7 100644 --- a/RFEM/SpecialObjects/structureModification.py +++ b/RFEM/SpecialObjects/structureModification.py @@ -1,11 +1,63 @@ from RFEM.initModel import Model, clearAtributes +from enum import Enum + +class Modification_Type(Enum): + MULTIPLY_FACTOR, DIVISION_FACTOR = range(2) +class MemberHingeSide(Enum): + Start, End = range(2) class StructureModification(): + material_item = {'no': 1, 'material_name': 1, 'modification_type': 'MULTIPLY_FACTOR', 'E_and_G': 1.0, 'comment': ''} + section_item = {'no': 1, 'section_name': 'IPN 300', 'A': 1.0, 'A_y':1.0, 'A_z': 1.0, 'J': 1.0, 'I_y': 1.0, 'I_z': 1.0} + member_item = {} + surface_item = {} + member_hinge_item = {'no': 1, 'member_side': 'Start', 'C_u_x': 0, 'C_u_y': 0, 'C_u_z': 0, 'C_phi_x': 0, 'C_phi_y': 0, 'C_phi_z': 0} + line_hinge_item = {'no': 1, 'C_u_x': 1, 'C_u_y': 1, 'C_u_z': 1, 'C_phi_x': 0, 'C_phi_y': 0, 'C_phi_z': 0} + def __init__(self, no: int = 1, + modify_stiffnesses_materials: bool = False, + modify_stiffnesses_sections: bool = False, + modify_stiffnesses_members: bool = False, + modify_stiffnesses_surfaces: bool = False, + modify_stiffnesses_member_hinges: bool = False, + modify_stiffnesses_nodal_supports: bool = False, + modify_stiffness_timber_members_due_moisture_class: bool = False, + nonlinearities_disabled_material_nonlinearity_models: bool = False, + nonlinearities_disabled_solid_types_contact_or_surfaces_contact: bool = False, + modify_stiffnesses_materials_list: list = None, + modify_stiffnesses_sections_list: list = None, + modify_stiffnesses_members_list: list = None, + modify_stiffnesses_surfaces_list: list = None, + modify_stiffnesses_member_hinges_list: list = None, + modify_stiffnesses_nodal_supports_list: list = None, comment: str = '', params: dict = None, model = Model): + """ + Structural Modification + + Args: + no (int, mandatory): _description_. Defaults to 1. + modify_stiffnesses_materials (bool, optional): Material + modify_stiffnesses_sections (bool, optional): _description_. Defaults to False. + modify_stiffnesses_members (bool, optional): _description_. Defaults to False. + modify_stiffnesses_surfaces (bool, optional): _description_. Defaults to False. + modify_stiffnesses_member_hinges (bool, optional): _description_. Defaults to False. + modify_stiffnesses_nodal_supports (bool, optional): _description_. Defaults to False. + modify_stiffness_timber_members_due_moisture_class (bool, optional): _description_. Defaults to False. + nonlinearities_disabled_material_nonlinearity_models (bool, optional): _description_. Defaults to False. + nonlinearities_disabled_solid_types_contact_or_surfaces_contact (bool, optional): _description_. Defaults to False. + modify_stiffnesses_materials_list (list, optional): _description_. Defaults to None. + modify_stiffnesses_sections_list (list, optional): _description_. Defaults to None. + modify_stiffnesses_members_list (list, optional): _description_. Defaults to None. + modify_stiffnesses_surfaces_list (list, optional): _description_. Defaults to None. + modify_stiffnesses_member_hinges_list (list, optional): _description_. Defaults to None. + modify_stiffnesses_nodal_supports_list (list, optional): _description_. Defaults to None. + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ # Client model | Structure Modification clientObject = model.clientModel.factory.create('ns0:structure_modification') @@ -16,6 +68,25 @@ def __init__(self, # Structure Modification No. clientObject.no = no + # Modify Stiffneesses + clientObject.modify_stiffnesses_materials = modify_stiffnesses_materials + clientObject.modify_stiffnesses_sections = modify_stiffnesses_sections + clientObject.modify_stiffnesses_members = modify_stiffnesses_members + clientObject.modify_stiffnesses_surface = modify_stiffnesses_surfaces + clientObject.modify_stiffnesses_member_hinges = modify_stiffnesses_member_hinges + clientObject.modify_stiffnesses_nodal_supports = modify_stiffnesses_nodal_supports + clientObject.modify_stiffness_timber_members_due_moisture_class = modify_stiffness_timber_members_due_moisture_class + clientObject.nonlinearities_disabled_material_nonlinearity_models = nonlinearities_disabled_material_nonlinearity_models + clientObject.nonlinearities_disabled_solid_types_contact_or_surfaces_contact = nonlinearities_disabled_solid_types_contact_or_surfaces_contact + + # Modify Stiffneesses Tables + clientObject.modify_stiffnesses_material_table = modify_stiffnesses_materials_list + clientObject.modify_stiffnesses_sections_table = modify_stiffnesses_sections_list + clientObject.modify_stiffnesses_members_table = modify_stiffnesses_members_list + clientObject.modify_stiffnesses_surfaces_table = modify_stiffnesses_surfaces_list + clientObject.modify_stiffnesses_member_hinges_table = modify_stiffnesses_member_hinges_list + clientObject.modify_stiffnesses_nodal_supports_table = modify_stiffnesses_nodal_supports_list + # Comment clientObject.comment = comment diff --git a/RFEM/SpecialObjects/surfaceContact.py b/RFEM/SpecialObjects/surfaceContact.py index e6186eff..7ce47a59 100644 --- a/RFEM/SpecialObjects/surfaceContact.py +++ b/RFEM/SpecialObjects/surfaceContact.py @@ -1,11 +1,26 @@ -from RFEM.initModel import Model, clearAtributes +from RFEM.initModel import Model, clearAtributes, ConvertToDlString class SurfaceContact(): def __init__(self, no: int = 1, + surfaces_contact_type: int = 1, + surfaces_group_1: str = '1', + surfaces_group_2: str = '2', comment: str = '', params: dict = None, model = Model): + """ + Surface Contact + + Args: + no (int, optional): Number + surfaces_contact_type (int, optional): Surface Contact Number + surface_group_1 (str, optional): Surfaces Group 1 + surface_group_2 (str, optional): Surfaces Group 2 + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ # Client model | Surfaces Contact clientObject = model.clientModel.factory.create('ns0:surfaces_contact') @@ -16,6 +31,13 @@ def __init__(self, # Surfaces Contact No. clientObject.no = no + # Surface Contact Type + clientObject.surfaces_contact_type = surfaces_contact_type + + # Surface Numbers + clientObject.surfaces_group1 = ConvertToDlString(surfaces_group_1) + clientObject.surfaces_group2 = ConvertToDlString(surfaces_group_2) + # Comment clientObject.comment = comment diff --git a/RFEM/SpecialObjects/surfaceResultAdjustment.py b/RFEM/SpecialObjects/surfaceResultAdjustment.py index 9d4f84aa..fa1414f1 100644 --- a/RFEM/SpecialObjects/surfaceResultAdjustment.py +++ b/RFEM/SpecialObjects/surfaceResultAdjustment.py @@ -1,11 +1,37 @@ -from RFEM.initModel import Model, clearAtributes +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SurfaceResultsAdjustmentShape, SurfaceResultsAdjustmentType, SurfaceResultsAdjustmentProjection class SurfaceResultsAdjustment(): def __init__(self, no: int = 1, + shape = SurfaceResultsAdjustmentShape.SHAPE_RECTANGLE, + dimensions: list = None, + center_position: list = None, + adjustment_type_in_direction_u = SurfaceResultsAdjustmentType.AVERAGING_OF_MY_MXY_VY_NY_NXY, + adjustment_type_in_direction_v = SurfaceResultsAdjustmentType.AVERAGING_OF_MX_MXY_VX_NX_NXY, + projection = SurfaceResultsAdjustmentProjection.PERPENDICULAR, + projection_vector: list = None, + surfaces: str = '', comment: str = '', params: dict = None, model = Model): + """ + Surface Results Adjustment + + Args: + no (int, mandatory): Number + shape (enum, mandatory): Shape + dimensions (list, mandatory): Dimensions and angular rotation + center_position (list, optional): Center position + adjustment_type_in_direction_u (enum, optional): Adjustment type in direction u + adjustment_type_in_direction_v (enum, optional): Adjustment type in direction v + projection (enum, optional): Projection Direction + projection_vector (list, optional): Projection vector in case projection == VECTOR + surfaces (str, optional): Assigned to surfaces + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ # Client model | Surface Result Adjustment clientObject = model.clientModel.factory.create('ns0:surface_results_adjustment') @@ -16,6 +42,48 @@ def __init__(self, # Surface Result Adjustment No. clientObject.no = no + # Surface Result Adjustment Shape + clientObject.shape = shape.name + + # Surface Result Adjustment Dimensions + if shape == SurfaceResultsAdjustmentShape.SHAPE_RECTANGLE: + clientObject.dimension_1 = dimensions[0] + clientObject.dimension_2 = dimensions[1] + clientObject.angular_rotation = dimensions[2] + elif shape == SurfaceResultsAdjustmentShape.SHAPE_CIRCLE: + clientObject.dimension_1 = dimensions[0] + clientObject.angular_rotaSurfaceResultsAdjustmentShapetion = dimensions[1] + elif shape == SurfaceResultsAdjustmentShape.SHAPE_ELLIPSE: + clientObject.dimension_1 = dimensions[0] + clientObject.dimension_2 = dimensions[1] + clientObject.angular_rotation = dimensions[2] + + # Surface Result Adjustment Center Position + if center_position: + clientObject.center_position_x = center_position[0] + clientObject.center_position_y = center_position[1] + clientObject.center_position_z = center_position[2] + else: + clientObject.center_position_x = 0 + clientObject.center_position_y = 0 + clientObject.center_position_z = 0 + + # Surface Result Adjustment Type + clientObject.adjustment_type_in_direction_u = adjustment_type_in_direction_u.name + clientObject.adjustment_type_in_direction_v = adjustment_type_in_direction_v.name + + # Surface Result Adjustment Projection + clientObject.projection_in_direction_type = projection.name + + # Surface Result Adjustment Vector + if projection == SurfaceResultsAdjustmentProjection.VECTOR: + clientObject.vector_of_projection_in_direction_coordinates_x = projection_vector[0] + clientObject.vector_of_projection_in_direction_coordinates_y = projection_vector[1] + clientObject.vector_of_projection_in_direction_coordinates_z = projection_vector[2] + + # assigned to surfaces + clientObject.surfaces = ConvertToDlString(surfaces) + # Comment clientObject.comment = comment diff --git a/RFEM/TypesForSpecialObjects/surfaceContactType.py b/RFEM/TypesForSpecialObjects/surfaceContactType.py index f8d6889b..239ac2fc 100644 --- a/RFEM/TypesForSpecialObjects/surfaceContactType.py +++ b/RFEM/TypesForSpecialObjects/surfaceContactType.py @@ -1,21 +1,282 @@ from RFEM.initModel import Model, clearAtributes +from RFEM.enums import SurfaceContactPerpendicularType, SurfaceContactParallelType, SurfaceContactFrictionType class SurfaceContactType(): def __init__(self, no: int = 1, + perpendicular_contact = SurfaceContactPerpendicularType.FAILURE_UNDER_TENSION, + parallel_contact = SurfaceContactParallelType.FULL_FORCE_TRANSMISSION, + contact_parameters = None, comment: str = '', params: dict = None, model = Model): + """ + Surface Contact Type - # Client model | Surface Contact Type + Args: + no (int, optional): Numbers + perpendicular_contact (enum, optional): Contact parpendicualr to surfaces + parallel_contact (enum, optional): Contact paralles to surfaces + contact_parameters (list, optional): Contact parameters. + RIGID_FRICTION: [enum rigid_friction_type, rigid_friction_coefficient or rigid_friction_limit_stress] + ELASTIC_FRICTION: [elastic_friction_shear_stiffness, enum elastic_friction_type, elastic_friction_coefficient or elastic_friction_limit_stress] + ELASTIC_SURFACE: [elastic_behavior_shear_stiffness] + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + + Raises: + ValueError: There are no paramters for given parallel contact. + """ + + # Client model | Surface Contact + clientObject = model.clientModel.factory.create('ns0:surfaces_contact_type') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Contact No. + clientObject.no = no + + # Contact Perpendicular to Surface + clientObject.perpendicular_to_surface = perpendicular_contact.name + + # Contact Paralle to Surface + clientObject.parallel_to_surface = parallel_contact.name + + # Contact Parameters + if parallel_contact == SurfaceContactParallelType.RIGID_FRICTION: + clientObject.rigid_friction_type = contact_parameters[0].name + if contact_parameters[0] == SurfaceContactFrictionType.FRICTION_COEFFICIENT: + clientObject.rigid_friction_coefficient = contact_parameters[1] + elif contact_parameters[0] == SurfaceContactFrictionType.LIMIT_STRESS: + clientObject.rigid_friction_limit_stress = contact_parameters[1] + + elif parallel_contact == SurfaceContactParallelType.ELASTIC_FRICTION: + clientObject.elastic_friction_shear_stiffness = contact_parameters[0] + clientObject.elastic_friction_type = contact_parameters[1].name + if contact_parameters[1] == SurfaceContactFrictionType.FRICTION_COEFFICIENT: + clientObject.elastic_friction_coefficient = contact_parameters[2] + elif contact_parameters[1] == SurfaceContactFrictionType.LIMIT_STRESS: + clientObject.elastic_friction_limit_stress = contact_parameters[2] + + elif parallel_contact == SurfaceContactParallelType.ELASTIC_SURFACE: + clientObject.elastic_behavior_shear_stiffness = contact_parameters[0] + + elif contact_parameters: + raise ValueError(f'There are no parameters for contact {parallel_contact.name}') + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if params: + for key in params: + clientObject[key] = params[key] + + # Add Surface Contact to client model + model.clientModel.service.set_surfaces_contact_type(clientObject) + + @staticmethod + def FullForce( + no: int = 1, + perpendicular_contact = SurfaceContactPerpendicularType.FAILURE_UNDER_TENSION, + comment: str = '', + params: dict = None, + model = Model): + """ + Full Force Transmission Surface Contact Type + + Args: + no (int, optional): Numbers + perpendicular_contact (enum, optional): Contact parpendicualr to surfaces + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ + + # Client model | Surface Contact + clientObject = model.clientModel.factory.create('ns0:surfaces_contact_type') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Contact No. + clientObject.no = no + + # Contact Perpendicular to Surface + clientObject.perpendicular_to_surface = perpendicular_contact.name + + # Contact Paralle to Surface + clientObject.parallel_to_surface = SurfaceContactParallelType.FULL_FORCE_TRANSMISSION.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if params: + for key in params: + clientObject[key] = params[key] + + # Add Surface Contact to client model + model.clientModel.service.set_surfaces_contact_type(clientObject) + + @staticmethod + def RigidFriction( + no: int = 1, + perpendicular_contact = SurfaceContactPerpendicularType.FAILURE_UNDER_TENSION, + rigid_friction_type = SurfaceContactFrictionType.FRICTION_COEFFICIENT, + rigid_friction_value: float = 0.25, + comment: str = '', + params: dict = None, + model = Model): + """ + Rigid Friction Surface Contact Type + + Args: + no (int, optional): Number + perpendicular_contact (enum, optional): Contact parpendicualr to surfaces + rigid_friction_type (enum, optional): Rigid friction Type + rigid_friction_value (float, optional): Value of rigid_friction_coefficient or rigid_friction_limit_stress + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ + + # Client model | Surface Contact + clientObject = model.clientModel.factory.create('ns0:surfaces_contact_type') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Contact No. + clientObject.no = no + + # Contact Perpendicular to Surface + clientObject.perpendicular_to_surface = perpendicular_contact.name + + # Contact Paralle to Surface + clientObject.parallel_to_surface = SurfaceContactParallelType.RIGID_FRICTION.name + + # Rigid Friction Type + clientObject.rigid_friction_type = rigid_friction_type.name + + # Rigid Friction Type Value + if rigid_friction_type == SurfaceContactFrictionType.FRICTION_COEFFICIENT: + clientObject.rigid_friction_coefficient = rigid_friction_value + elif rigid_friction_type == SurfaceContactFrictionType.LIMIT_STRESS: + clientObject.rigid_friction_limit_stress = rigid_friction_value + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if params: + for key in params: + clientObject[key] = params[key] + + # Add Surface Contact to client model + model.clientModel.service.set_surfaces_contact_type(clientObject) + + @staticmethod + def ElasticFriction( + no: int = 1, + perpendicular_contact = SurfaceContactPerpendicularType.FAILURE_UNDER_TENSION, + shear_stiffness: float = 2000, + elastic_friction_type = SurfaceContactFrictionType.FRICTION_COEFFICIENT, + elastic_friction_value: float = 0.25, + comment: str = '', + params: dict = None, + model = Model): + """ + Elastic Friction Surface Contact Type + + Args: + no (int, optional): Number + perpendicular_contact (enum, optional): Contact parpendicualr to surfaces + elastic_friction_type (enum, optional): Elastic friction Type + elastic_friction_value (float, optional): Value of elastic_friction_coefficient or elastic_friction_limit_stress + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ + + # Client model | Surface Contact clientObject = model.clientModel.factory.create('ns0:surfaces_contact_type') # Clears object atributes | Sets all atributes to None clearAtributes(clientObject) - # Surface Contact Type No. + # Surface Contact No. clientObject.no = no + # Contact Perpendicular to Surface + clientObject.perpendicular_to_surface = perpendicular_contact.name + + # Contact Paralle to Surface + clientObject.parallel_to_surface = SurfaceContactParallelType.ELASTIC_FRICTION.name + + # Elastic Friction Type + clientObject.rigid_friction_type = elastic_friction_type.name + + # Elastic Friction Type Values + clientObject.elastic_friction_shear_stiffness = shear_stiffness + + clientObject.elastic_friction_type = elastic_friction_type.name + if elastic_friction_type == SurfaceContactFrictionType.FRICTION_COEFFICIENT: + clientObject.elastic_friction_coefficient = elastic_friction_value + elif elastic_friction_type == SurfaceContactFrictionType.LIMIT_STRESS: + clientObject.elastic_friction_limit_stress = elastic_friction_value + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if params: + for key in params: + clientObject[key] = params[key] + + # Add Surface Contact to client model + model.clientModel.service.set_surfaces_contact_type(clientObject) + + @staticmethod + def ElasticSurface( + no: int = 1, + perpendicular_contact = SurfaceContactPerpendicularType.FAILURE_UNDER_TENSION, + shear_stiffness: float = 2500, + comment: str = '', + params: dict = None, + model = Model): + """ + Elastic Friction Surface Contact Type + + Args: + no (int, optional): Number + perpendicular_contact (enum, optional): Contact parpendicualr to surfaces + shear_stiffness (float, optional): Shear stiffness value + comment (str, optional): Comment + params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary + model (class, optional): Model instance + """ + + # Client model | Surface Contact + clientObject = model.clientModel.factory.create('ns0:surfaces_contact_type') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Contact No. + clientObject.no = no + + # Contact Perpendicular to Surface + clientObject.perpendicular_to_surface = perpendicular_contact.name + + # Contact Paralle to Surface + clientObject.parallel_to_surface = SurfaceContactParallelType.ELASTIC_SURFACE.name + + # Elastic Surface Shear Stiffness + clientObject.elastic_behavior_shear_stiffness = shear_stiffness + # Comment clientObject.comment = comment @@ -24,5 +285,5 @@ def __init__(self, for key in params: clientObject[key] = params[key] - # Add Surface Contact Type to client model + # Add Surface Contact to client model model.clientModel.service.set_surfaces_contact_type(clientObject) diff --git a/RFEM/enums.py b/RFEM/enums.py index cc993d3b..277ee38e 100644 --- a/RFEM/enums.py +++ b/RFEM/enums.py @@ -1794,7 +1794,6 @@ class SolidContactPerpendicularType(Enum): ''' FULL_FORCE_TRANSMISSION, FAILURE_UNDER_COMPRESSION, FAILURE_UNDER_TENSION = range(3) - class SolidContactParallelType(Enum): ''' Solid Contact Parallel To Surfaces @@ -1808,6 +1807,61 @@ class NodalMeshRefinementType(Enum): ''' TYPE_CIRCULAR, TYPE_RECTANGULAR = range(2) +class SurfaceResultsAdjustmentShape(Enum): + ''' + Surface Result Adjustment Shape Type + ''' + SHAPE_RECTANGLE, SHAPE_CIRCLE, SHAPE_ELLIPSE = range(3) + +class SurfaceResultsAdjustmentType(Enum): + ''' + Surface Result Adjustment Type. ZERO left out intentionaly. + ''' + AVERAGING_OF_MY_MXY_VY_NY_NXY, AVERAGING_OF_MX_MXY_VX_NX_NXY, USER_DEFINED, NONE = range(4) + +class SurfaceResultsAdjustmentProjection(Enum): + ''' + Surface Result Adjustment Projection + ''' + PERPENDICULAR, GLOBAL_IN_X, GLOBAL_IN_Y, GLOBAL_IN_Z, VECTOR = range(5) + +class ResultSectionType(Enum): + ''' + Result Section Type + ''' + TYPE_2_POINTS_AND_VECTOR, TYPE_LINE = range(2) + +class ResultSectionProjection(Enum): + ''' + Resul Section Projection + ''' + PROJECTION_IN_GLOBAL_X, PROJECTION_IN_GLOBAL_Y, PROJECTION_IN_GLOBAL_Z, PROJECTION_IN_VECTOR = range(4) + +class ResultSectionResultDirection(Enum): + ''' + Result Section Result Direction + ''' + SHOW_RESULTS_IN_LOCAL_PLUS_Z, SHOW_RESULTS_IN_LOCAL_MINUS_Z, SHOW_RESULTS_IN_LOCAL_PLUS_Y, SHOW_RESULTS_IN_GLOBAL_PLUS_X, SHOW_RESULTS_IN_GLOBAL_MINUS_X, \ + SHOW_RESULTS_IN_GLOBAL_PLUS_Y, SHOW_RESULTS_IN_GLOBAL_MINUS_Y, SHOW_RESULTS_IN_GLOBAL_PLUS_Z, SHOW_RESULTS_IN_GLOBAL_MINUS_Z = range(9) + +class SurfaceContactPerpendicularType(Enum): + ''' + Surface Contact Perpendicular To Surfaces + ''' + FULL_FORCE_TRANSMISSION, FAILURE_UNDER_COMPRESSION, FAILURE_UNDER_TENSION = range(3) + +class SurfaceContactParallelType(Enum): + ''' + Surface Contact Parallel To Surfaces + ''' + FULL_FORCE_TRANSMISSION, RIGID_FRICTION, ELASTIC_FRICTION, ELASTIC_SURFACE = range(4) + +class SurfaceContactFrictionType(Enum): + ''' + Rigid Friction Type + ''' + LIMIT_STRESS, FRICTION_COEFFICIENT = range(2) + class ActionCategoryType(Enum): ''' Load Case Action Category diff --git a/UnitTests/test_SpecialObjects.py b/UnitTests/test_SpecialObjects.py new file mode 100644 index 00000000..78bf496a --- /dev/null +++ b/UnitTests/test_SpecialObjects.py @@ -0,0 +1,99 @@ +import sys +import os +PROJECT_ROOT = os.path.abspath(os.path.join( + os.path.dirname(__file__), + os.pardir) +) +sys.path.append(PROJECT_ROOT) + +from RFEM.initModel import Model +from RFEM.BasicObjects.material import Material +from RFEM.BasicObjects.thickness import Thickness +from RFEM.BasicObjects.node import Node +from RFEM.BasicObjects.line import Line +from RFEM.BasicObjects.surface import Surface +from RFEM.SpecialObjects.intersection import Instersection +from RFEM.SpecialObjects.surfaceResultAdjustment import SurfaceResultsAdjustment +from RFEM.SpecialObjects.surfaceContact import SurfaceContact +from RFEM.SpecialObjects.resultSection import ResultSection +from RFEM.SpecialObjects.structureModification import StructureModification +from RFEM.TypesForSpecialObjects.surfaceContactType import SurfaceContactType +from RFEM.enums import SurfaceResultsAdjustmentShape, SurfaceResultsAdjustmentType, SurfaceResultsAdjustmentProjection +from RFEM.enums import SurfaceContactPerpendicularType, SurfaceContactParallelType, SurfaceContactFrictionType +from RFEM.enums import ResultSectionType, ResultSectionProjection, ResultSectionResultDirection + +# Rigid Links tested separately in test_RigidLinks.py + +if Model.clientModel is None: + Model() + +def test_special_objects(): + Model.clientModel.service.delete_all() + Model.clientModel.service.begin_modification() + + # Create Material + Material(1, 'S235') + + # Create Thickness + Thickness(1, '1', 1, 0.01) + + # Create Nodes + Node(1, 0.0, 0.0, 0.0) + Node(2, 0.0, 2.0, 0.0) + Node(3, 2.0, 2.0, 0.0) + Node(4, 2.0, 0.0, 0.0) + Node(5, 0.0, 4.0, 0.0) + Node(6, 2.0, 4.0, 0.0) + + Node(7, 0.0, 0.0, 1) + Node(8, 0.0, 2.0, 1) + Node(9, 2.0, 2.0, 1) + Node(10, 2.0, 0.0, 1) + Node(11, 0.0, 4.0, 1) + Node(12, 2.0, 4.0, 1) + + # Create Lines + Line(1, '1 2') + Line(2, '2 3') + Line(3, '3 4') + Line(4, '4 1') + Line(5, '2 5') + Line(6, '5 6') + Line(7, '6 3') + + Line(8, '7 8') + Line(9, '8 9') + Line(10, '9 10') + Line(11, '10 7') + Line(12, '8 11') + Line(13, '11 12') + Line(14, '12 9') + + # Create Surfaces + Surface(1, '1 2 3 4', 1) + Surface(2, '2 5 6 7', 1) + + Surface(3, '8 9 10 11', 1) + Surface(4, '12 13 14 9', 1) + + Instersection() + + SurfaceResultsAdjustment(1,SurfaceResultsAdjustmentShape.SHAPE_RECTANGLE, [1,1.2,0]) + + SurfaceContactType(1, SurfaceContactPerpendicularType.FULL_FORCE_TRANSMISSION, SurfaceContactParallelType.ELASTIC_FRICTION, [2000, SurfaceContactFrictionType.FRICTION_COEFFICIENT, 0.25]) + SurfaceContactType.FullForce(2) + SurfaceContactType.RigidFriction(3) + SurfaceContactType.ElasticFriction(4) + SurfaceContactType.ElasticSurface(5) + + SurfaceContact(1, 1, '1', '3') + + ResultSection(1,ResultSectionType.TYPE_2_POINTS_AND_VECTOR, ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_X,True,[1, [1,0,0], [0,2,0], ResultSectionProjection.PROJECTION_IN_VECTOR, [1,1,1]],) + ResultSection.Line(2,ResultSectionResultDirection.SHOW_RESULTS_IN_LOCAL_PLUS_Z,False, '2') + ResultSection.TwoPointsAndVector(3,1,ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_Y,False, [10,0,0], [5,5,5], ResultSectionProjection.PROJECTION_IN_GLOBAL_X) + ResultSection.TwoPointsAndVector(4,1,ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_Y,False, [10,0,0], [5,5,5], ResultSectionProjection.PROJECTION_IN_VECTOR, [-1,1,-1]) + + StructureModification() + + + Model.clientModel.service.finish_modification() \ No newline at end of file From 23201238844df78e1454e0cb8c913f17c8c43f40 Mon Sep 17 00:00:00 2001 From: MichalO Date: Thu, 5 May 2022 11:06:59 +0200 Subject: [PATCH 2/4] updated and finished tests unit tests: 147 passed, 9 skipped in 199.99s --- RFEM/SpecialObjects/resultSection.py | 5 - RFEM/SpecialObjects/structureModification.py | 232 ++++++++++++++----- UnitTests/test_SpecialObjects.py | 69 +++++- 3 files changed, 237 insertions(+), 69 deletions(-) diff --git a/RFEM/SpecialObjects/resultSection.py b/RFEM/SpecialObjects/resultSection.py index b147e2fd..e4953dbb 100644 --- a/RFEM/SpecialObjects/resultSection.py +++ b/RFEM/SpecialObjects/resultSection.py @@ -10,7 +10,6 @@ def __init__(self, parameters: list = None, assigned_to_all_surfaces: bool = True, assigned_to_all_solids: bool = True, - comment: str = '', params: dict = None, model = Model): """ @@ -30,7 +29,6 @@ def __init__(self, [1, [1,0,0], [0,2,0], ResultSectionProjection.PROJECTION_IN_VECTOR, [1,1,1]] assigned_to_all_surfaces (bool, optional) = Assigned to all surface assigned_to_all_solids (bool, optional) Assigned to all solids - comment (str, optional): Comment params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary model (class, optional): Model instance """ @@ -82,9 +80,6 @@ def __init__(self, else: clientObject.assigned_to_solids = '' - # Comment - #clientObject.comment = comment - # Adding optional parameters via dictionary if params: for key in params: diff --git a/RFEM/SpecialObjects/structureModification.py b/RFEM/SpecialObjects/structureModification.py index 3f26b1d7..5a914cb7 100644 --- a/RFEM/SpecialObjects/structureModification.py +++ b/RFEM/SpecialObjects/structureModification.py @@ -1,91 +1,209 @@ from RFEM.initModel import Model, clearAtributes -from enum import Enum - -class Modification_Type(Enum): - MULTIPLY_FACTOR, DIVISION_FACTOR = range(2) -class MemberHingeSide(Enum): - Start, End = range(2) class StructureModification(): - material_item = {'no': 1, 'material_name': 1, 'modification_type': 'MULTIPLY_FACTOR', 'E_and_G': 1.0, 'comment': ''} + material_item = {'no': 1, 'material_name': 1, 'modification_type': 'DIVISION_FACTOR', 'E_and_G': 1.5, 'comment': 'comment'} section_item = {'no': 1, 'section_name': 'IPN 300', 'A': 1.0, 'A_y':1.0, 'A_z': 1.0, 'J': 1.0, 'I_y': 1.0, 'I_z': 1.0} - member_item = {} - surface_item = {} - member_hinge_item = {'no': 1, 'member_side': 'Start', 'C_u_x': 0, 'C_u_y': 0, 'C_u_z': 0, 'C_phi_x': 0, 'C_phi_y': 0, 'C_phi_z': 0} - line_hinge_item = {'no': 1, 'C_u_x': 1, 'C_u_y': 1, 'C_u_z': 1, 'C_phi_x': 0, 'C_phi_y': 0, 'C_phi_z': 0} + member_item = {'no': 2, 'member_modification': 1, 'members':'11', 'comment': ''} + surface_item = {'no': 1, 'surface_modification': 1, 'surfaces':'2', 'comment': ''} + member_hinge_item = {'no': 1, 'member_side': 'Start', 'C_u_x': 1, 'C_u_y': 0, 'C_u_z': 0, 'C_phi_x': 0, 'C_phi_y': 0, 'C_phi_z': 0} + line_hinge_item = {'no': 1, 'C_u_x': 1, 'C_u_y': 0, 'C_u_z': 0, 'C_phi_x': 0, 'C_phi_y': 0, 'C_phi_z': 0} + nodal_support_item = {'C_u_X': 1, 'C_u_Y': 0, 'C_u_Z': 0, 'C_phi_X': 0, 'C_phi_Y': 0, 'C_phi_Z': 0} + line_support_item = {'C_u_X': 1, 'C_u_Y': 0, 'C_u_Z': 0, 'C_phi_X': 0, 'C_phi_Y': 0, 'C_phi_Z': 0} + member_support_item = {'C_u_x': 1, 'C_u_y': 0, 'C_u_z': 0, 'C_s_x': 0, 'C_s_y': 0, 'C_s_z': 0, 'C_phi_x': 0} + surface_support_item = {'C_u_X': 1, 'C_u_Y': 0, 'C_u_Z': 0, 'C_v_xz': 0, 'C_v_yz': 0} + modify_stiffness = {'modify_stiffnesses_gamma_m': False, + 'modify_stiffnesses_materials': False, + 'modify_stiffnesses_sections': False, + 'modify_stiffnesses_members': False, + 'modify_stiffnesses_surfaces': False, + 'modify_stiffnesses_member_hinges': False, + 'modify_stiffnesses_line_hinges': False, + 'modify_stiffnesses_nodal_supports': False, + 'modify_stiffnesses_line_supports': False, + 'modify_stiffnesses_member_supports': False, + 'modify_stiffnesses_surface_supports': False, + 'modify_stiffness_member_reinforcement': False, + 'modify_stiffness_surface_reinforcement': False, + 'modify_stiffness_timber_members_due_moisture_class': False, + 'nonlinearities_disabled_material_nonlinearity_models': False, + 'nonlinearities_disabled_material_temperature_nonlinearities': False, + 'nonlinearities_disabled_line_hinges': False, + 'nonlinearities_disabled_member_types': False, + 'nonlinearities_disabled_member_nonlinearities': False, + 'nonlinearities_disabled_solid_types_contact_or_surfaces_contact': False, + 'nonlinearities_disabled_member_hinges': False, + 'nonlinearities_disabled_nodal_supports': False, + 'nonlinearities_disabled_line_supports': False, + 'nonlinearities_disabled_member_supports': False, + 'nonlinearities_disabled_surface_supports': False, + 'deactivate_members_enabled': False} def __init__(self, no: int = 1, - modify_stiffnesses_materials: bool = False, - modify_stiffnesses_sections: bool = False, - modify_stiffnesses_members: bool = False, - modify_stiffnesses_surfaces: bool = False, - modify_stiffnesses_member_hinges: bool = False, - modify_stiffnesses_nodal_supports: bool = False, - modify_stiffness_timber_members_due_moisture_class: bool = False, - nonlinearities_disabled_material_nonlinearity_models: bool = False, - nonlinearities_disabled_solid_types_contact_or_surfaces_contact: bool = False, + modify_stiffnesses: dict = modify_stiffness, modify_stiffnesses_materials_list: list = None, modify_stiffnesses_sections_list: list = None, modify_stiffnesses_members_list: list = None, modify_stiffnesses_surfaces_list: list = None, modify_stiffnesses_member_hinges_list: list = None, + modify_stiffnesses_line_hinges_list: list = None, modify_stiffnesses_nodal_supports_list: list = None, + modify_stiffnesses_line_supports_list: list = None, + modify_stiffnesses_member_supports_list: list = None, + modify_stiffnesses_surface_supports_list: list = None, comment: str = '', params: dict = None, model = Model): """ Structural Modification + Modify only objects allready existing and used/assigned in the model. + TODO: US-9960 Deactivate objects requires Object Selection object. Args: - no (int, mandatory): _description_. Defaults to 1. - modify_stiffnesses_materials (bool, optional): Material - modify_stiffnesses_sections (bool, optional): _description_. Defaults to False. - modify_stiffnesses_members (bool, optional): _description_. Defaults to False. - modify_stiffnesses_surfaces (bool, optional): _description_. Defaults to False. - modify_stiffnesses_member_hinges (bool, optional): _description_. Defaults to False. - modify_stiffnesses_nodal_supports (bool, optional): _description_. Defaults to False. - modify_stiffness_timber_members_due_moisture_class (bool, optional): _description_. Defaults to False. - nonlinearities_disabled_material_nonlinearity_models (bool, optional): _description_. Defaults to False. - nonlinearities_disabled_solid_types_contact_or_surfaces_contact (bool, optional): _description_. Defaults to False. - modify_stiffnesses_materials_list (list, optional): _description_. Defaults to None. - modify_stiffnesses_sections_list (list, optional): _description_. Defaults to None. - modify_stiffnesses_members_list (list, optional): _description_. Defaults to None. - modify_stiffnesses_surfaces_list (list, optional): _description_. Defaults to None. - modify_stiffnesses_member_hinges_list (list, optional): _description_. Defaults to None. - modify_stiffnesses_nodal_supports_list (list, optional): _description_. Defaults to None. + no (int, optional): Number + modify_stiffnesses (dict, optional): + modify_stiffnesses_materials_list (list, optional): + modify_stiffnesses_sections_list (list, optional): + modify_stiffnesses_members_list (list, optional): + modify_stiffnesses_surfaces_list (list, optional): + modify_stiffnesses_member_hinges_list (list, optional): + modify_stiffnesses_line_hinges_list (list, optional): + modify_stiffnesses_nodal_supports_list (list, optional): + modify_stiffnesses_line_supports_list (list, optional): + modify_stiffnesses_member_supports_list (list, optional): + modify_stiffnesses_surface_supports_list (list, optional): comment (str, optional): Comment params (dict, optional): Any WS Parameter relevant to the object and its value in form of a dictionary model (class, optional): Model instance """ # Client model | Structure Modification - clientObject = model.clientModel.factory.create('ns0:structure_modification') + clientObject = None + try: + clientObject = model.clientModel.service.get_structure_modification(no) + except: + clientObject = model.clientModel.factory.create('ns0:structure_modification') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) - # Clears object atributes | Sets all atributes to None - clearAtributes(clientObject) + # Structure Modification No. + clientObject.no = no - # Structure Modification No. - clientObject.no = no + # Modify Stiffneesses + clientObject.modify_stiffnesses_gamma_m = modify_stiffnesses['modify_stiffnesses_gamma_m'] + clientObject.modify_stiffnesses_materials = modify_stiffnesses['modify_stiffnesses_materials'] + clientObject.modify_stiffnesses_sections = modify_stiffnesses['modify_stiffnesses_sections'] + clientObject.modify_stiffnesses_members = modify_stiffnesses['modify_stiffnesses_members'] + clientObject.modify_stiffnesses_surfaces = modify_stiffnesses['modify_stiffnesses_surfaces'] + clientObject.modify_stiffnesses_member_hinges = modify_stiffnesses['modify_stiffnesses_member_hinges'] + clientObject.modify_stiffnesses_line_hinges = modify_stiffnesses['modify_stiffnesses_line_hinges'] + clientObject.modify_stiffnesses_nodal_supports = modify_stiffnesses['modify_stiffnesses_nodal_supports'] + clientObject.modify_stiffnesses_line_supports = modify_stiffnesses['modify_stiffnesses_line_supports'] + clientObject.modify_stiffnesses_member_supports = modify_stiffnesses['modify_stiffnesses_member_supports'] + clientObject.modify_stiffnesses_surface_supports = modify_stiffnesses['modify_stiffnesses_surface_supports'] + clientObject.modify_stiffness_member_reinforcement = modify_stiffnesses['modify_stiffness_member_reinforcement'] + clientObject.modify_stiffness_surface_reinforcement = modify_stiffnesses['modify_stiffness_surface_reinforcement'] + clientObject.modify_stiffness_timber_members_due_moisture_class = modify_stiffnesses['modify_stiffness_timber_members_due_moisture_class'] + clientObject.nonlinearities_disabled_material_nonlinearity_models = modify_stiffnesses['nonlinearities_disabled_material_nonlinearity_models'] + clientObject.nonlinearities_disabled_material_temperature_nonlinearities = modify_stiffnesses['nonlinearities_disabled_material_temperature_nonlinearities'] + clientObject.nonlinearities_disabled_line_hinges = modify_stiffnesses['nonlinearities_disabled_line_hinges'] + clientObject.nonlinearities_disabled_member_types = modify_stiffnesses['nonlinearities_disabled_member_types'] + clientObject.nonlinearities_disabled_member_nonlinearities = modify_stiffnesses['nonlinearities_disabled_member_nonlinearities'] + clientObject.nonlinearities_disabled_solid_types_contact_or_surfaces_contact = modify_stiffnesses['nonlinearities_disabled_solid_types_contact_or_surfaces_contact'] + clientObject.nonlinearities_disabled_member_hinges = modify_stiffnesses['nonlinearities_disabled_member_hinges'] + clientObject.nonlinearities_disabled_nodal_supports = modify_stiffnesses['nonlinearities_disabled_nodal_supports'] + clientObject.nonlinearities_disabled_line_supports = modify_stiffnesses['nonlinearities_disabled_line_supports'] + clientObject.nonlinearities_disabled_member_supports = modify_stiffnesses['nonlinearities_disabled_member_supports'] + clientObject.nonlinearities_disabled_surface_supports = modify_stiffnesses['nonlinearities_disabled_surface_supports'] + clientObject.deactivate_members_enabled = modify_stiffnesses['deactivate_members_enabled'] - # Modify Stiffneesses - clientObject.modify_stiffnesses_materials = modify_stiffnesses_materials - clientObject.modify_stiffnesses_sections = modify_stiffnesses_sections - clientObject.modify_stiffnesses_members = modify_stiffnesses_members - clientObject.modify_stiffnesses_surface = modify_stiffnesses_surfaces - clientObject.modify_stiffnesses_member_hinges = modify_stiffnesses_member_hinges - clientObject.modify_stiffnesses_nodal_supports = modify_stiffnesses_nodal_supports - clientObject.modify_stiffness_timber_members_due_moisture_class = modify_stiffness_timber_members_due_moisture_class - clientObject.nonlinearities_disabled_material_nonlinearity_models = nonlinearities_disabled_material_nonlinearity_models - clientObject.nonlinearities_disabled_solid_types_contact_or_surfaces_contact = nonlinearities_disabled_solid_types_contact_or_surfaces_contact + model.clientModel.service.set_structure_modification(clientObject) + clientObject = model.clientModel.service.get_structure_modification(no) # Modify Stiffneesses Tables - clientObject.modify_stiffnesses_material_table = modify_stiffnesses_materials_list - clientObject.modify_stiffnesses_sections_table = modify_stiffnesses_sections_list - clientObject.modify_stiffnesses_members_table = modify_stiffnesses_members_list - clientObject.modify_stiffnesses_surfaces_table = modify_stiffnesses_surfaces_list - clientObject.modify_stiffnesses_member_hinges_table = modify_stiffnesses_member_hinges_list - clientObject.modify_stiffnesses_nodal_supports_table = modify_stiffnesses_nodal_supports_list + if modify_stiffnesses['modify_stiffnesses_materials']: + for i in modify_stiffnesses_materials_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_material_table[0][idx].modification_type = i['modification_type'] + clientObject.modify_stiffnesses_material_table[0][idx].E_and_G = i['E_and_G'] + clientObject.modify_stiffnesses_material_table[0][idx].comment = i['comment'] + if modify_stiffnesses['modify_stiffnesses_sections']: + for i in modify_stiffnesses_sections_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_sections_table[0][idx].A = i['A'] + clientObject.modify_stiffnesses_sections_table[0][idx].A_y = i['A_y'] + clientObject.modify_stiffnesses_sections_table[0][idx].A_z = i['A_z'] + clientObject.modify_stiffnesses_sections_table[0][idx].J = i['J'] + clientObject.modify_stiffnesses_sections_table[0][idx].I_Y = i['I_y'] + clientObject.modify_stiffnesses_sections_table[0][idx].I_z = i['I_z'] + if modify_stiffnesses['modify_stiffnesses_members']: + for i in modify_stiffnesses_members_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_members_table[0][idx].member_modification = i['member_modification'] + clientObject.modify_stiffnesses_members_table[0][idx].members = i['members'] + clientObject.modify_stiffnesses_members_table[0][idx].comment = i['comment'] + if modify_stiffnesses['modify_stiffnesses_surfaces']: + for i in modify_stiffnesses_surfaces_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_surfaces_table[0][idx].surface_modification = i['surface_modification'] + clientObject.modify_stiffnesses_surfaces_table[0][idx].surfaces = i['surfaces'] + clientObject.modify_stiffnesses_surfaces_table[0][idx].comment = i['comment'] + if modify_stiffnesses['modify_stiffnesses_member_hinges']: + for i in modify_stiffnesses_member_hinges_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_member_hinges_table[0][idx].member_side = i['member_side'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_phi_y = i['C_phi_y'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_phi_z = i['C_phi_z'] + if modify_stiffnesses['modify_stiffnesses_line_hinges']: + for i in modify_stiffnesses_line_hinges_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_phi_y = i['C_phi_y'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_phi_z = i['C_phi_z'] + if modify_stiffnesses['modify_stiffnesses_nodal_supports']: + for i in modify_stiffnesses_nodal_supports_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_phi_y = i['C_phi_y'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_phi_z = i['C_phi_z'] + if modify_stiffnesses['modify_stiffnesses_line_supports']: + for i in modify_stiffnesses_line_supports_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_line_supports_table[0][idx].C_u_X = i['C_u_X'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].C_u_Y = i['C_u_Y'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].C_u_Z = i['C_u_Z'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].C_phi_X = i['C_phi_X'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].C_phi_Y = i['C_phi_Y'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].C_phi_Z = i['C_phi_Z'] + if modify_stiffnesses['modify_stiffnesses_member_supports']: + for i in modify_stiffnesses_member_supports_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_s_x = i['C_s_x'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_s_y = i['C_s_y'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_s_z = i['C_s_z'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].C_phi_x = i['C_phi_x'] + if modify_stiffnesses['modify_stiffnesses_surface_supports']: + for i in modify_stiffnesses_surface_supports_list: + idx = i['no']-1 + clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_u_X = i['C_u_X'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_u_Y = i['C_u_Y'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_u_Z = i['C_u_Z'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_v_xz = i['C_v_xz'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_v_yz = i['C_v_yz'] # Comment clientObject.comment = comment diff --git a/UnitTests/test_SpecialObjects.py b/UnitTests/test_SpecialObjects.py index 78bf496a..0e1bdbe5 100644 --- a/UnitTests/test_SpecialObjects.py +++ b/UnitTests/test_SpecialObjects.py @@ -11,6 +11,8 @@ from RFEM.BasicObjects.thickness import Thickness from RFEM.BasicObjects.node import Node from RFEM.BasicObjects.line import Line +from RFEM.BasicObjects.section import Section +from RFEM.BasicObjects.member import Member from RFEM.BasicObjects.surface import Surface from RFEM.SpecialObjects.intersection import Instersection from RFEM.SpecialObjects.surfaceResultAdjustment import SurfaceResultsAdjustment @@ -20,7 +22,9 @@ from RFEM.TypesForSpecialObjects.surfaceContactType import SurfaceContactType from RFEM.enums import SurfaceResultsAdjustmentShape, SurfaceResultsAdjustmentType, SurfaceResultsAdjustmentProjection from RFEM.enums import SurfaceContactPerpendicularType, SurfaceContactParallelType, SurfaceContactFrictionType -from RFEM.enums import ResultSectionType, ResultSectionProjection, ResultSectionResultDirection +from RFEM.enums import ResultSectionType, ResultSectionProjection, ResultSectionResultDirection, SurfaceStiffnessModificationType +from RFEM.TypesForSurfaces.surfaceStiffnessModification import SurfaceStiffnessModification +from RFEM.TypesForMembers.memberStiffnessModification import MemberStiffnessModification # Rigid Links tested separately in test_RigidLinks.py @@ -69,6 +73,10 @@ def test_special_objects(): Line(13, '11 12') Line(14, '12 9') + Line(15, '6 9') + Section() + Member(1,4, 9, 0, 1) + # Create Surfaces Surface(1, '1 2 3 4', 1) Surface(2, '2 5 6 7', 1) @@ -76,9 +84,9 @@ def test_special_objects(): Surface(3, '8 9 10 11', 1) Surface(4, '12 13 14 9', 1) - Instersection() + Instersection(1, 1, 2) - SurfaceResultsAdjustment(1,SurfaceResultsAdjustmentShape.SHAPE_RECTANGLE, [1,1.2,0]) + SurfaceResultsAdjustment(1,SurfaceResultsAdjustmentShape.SHAPE_RECTANGLE, [1.1,1.2,0]) SurfaceContactType(1, SurfaceContactPerpendicularType.FULL_FORCE_TRANSMISSION, SurfaceContactParallelType.ELASTIC_FRICTION, [2000, SurfaceContactFrictionType.FRICTION_COEFFICIENT, 0.25]) SurfaceContactType.FullForce(2) @@ -93,7 +101,54 @@ def test_special_objects(): ResultSection.TwoPointsAndVector(3,1,ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_Y,False, [10,0,0], [5,5,5], ResultSectionProjection.PROJECTION_IN_GLOBAL_X) ResultSection.TwoPointsAndVector(4,1,ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_Y,False, [10,0,0], [5,5,5], ResultSectionProjection.PROJECTION_IN_VECTOR, [-1,1,-1]) - StructureModification() - - - Model.clientModel.service.finish_modification() \ No newline at end of file + SurfaceStiffnessModification(1, SurfaceStiffnessModificationType.TYPE_TOTAL_STIFFNESS_FACTOR, factors=[1.09]) + MemberStiffnessModification() + + modify = StructureModification.modify_stiffness + modify['modify_stiffnesses_materials'] = True + StructureModification(1, modify, [StructureModification.material_item]) + + Model.clientModel.service.finish_modification() + + intersection = Model.clientModel.service.get_intersection(1) + assert intersection.surface_a == 1 + assert intersection.surface_b == 2 + + sra = Model.clientModel.service.get_surface_results_adjustment(1) + assert sra.shape == SurfaceResultsAdjustmentShape.SHAPE_RECTANGLE.name + assert sra.dimension_1 == 1.1 + assert sra.dimension_2 == 1.2 + + surface_contact = Model.clientModel.service.get_surfaces_contact(1) + assert surface_contact.surfaces_group1 == '1' + assert surface_contact.surfaces_group2 == '3' + assert surface_contact.surfaces_contact_type == 1 + + rs1 = Model.clientModel.service.get_result_section(1) + assert rs1.show_values_on_isolines_enabled == True + assert rs1.coordinate_system == 1 + assert rs1.first_point_coordinate_1 == 1 + assert rs1.first_point_coordinate_2 == 0 + assert rs1.second_point_coordinate_1 == 0 + assert rs1.second_point_coordinate_2 == 2 + assert rs1.projection_in_direction == ResultSectionProjection.PROJECTION_IN_VECTOR.name + assert rs1.vector_coordinate_1 == 1 + assert rs1.vector_coordinate_2 == 1 + assert rs1.vector_coordinate_3 == 1 + + rs2 = Model.clientModel.service.get_result_section(2) + assert rs2.type == ResultSectionType.TYPE_LINE.name + assert rs2.lines == '2' + + rs3 = Model.clientModel.service.get_result_section(3) + assert rs3.type == ResultSectionType.TYPE_2_POINTS_AND_VECTOR.name + assert rs3.second_point_coordinate_1 == 5 + + rs4 = Model.clientModel.service.get_result_section(4) + assert rs4.type == ResultSectionType.TYPE_2_POINTS_AND_VECTOR.name + assert rs4.first_point_coordinate_1 == 10 + assert rs4.second_point_coordinate_1 == 5 + + structure_modification = Model.clientModel.service.get_structure_modification(1) + assert structure_modification.modify_stiffnesses_materials == True + assert structure_modification.modify_stiffnesses_sections == False From 0175a0936508cd012ea191187f741d303f15a15a Mon Sep 17 00:00:00 2001 From: MichalO Date: Wed, 18 May 2022 13:44:34 +0200 Subject: [PATCH 3/4] updated for XML restructuring --- RFEM/SpecialObjects/structureModification.py | 104 +++++++++---------- 1 file changed, 52 insertions(+), 52 deletions(-) diff --git a/RFEM/SpecialObjects/structureModification.py b/RFEM/SpecialObjects/structureModification.py index 5a914cb7..c4e22178 100644 --- a/RFEM/SpecialObjects/structureModification.py +++ b/RFEM/SpecialObjects/structureModification.py @@ -125,85 +125,85 @@ def __init__(self, if modify_stiffnesses['modify_stiffnesses_materials']: for i in modify_stiffnesses_materials_list: idx = i['no']-1 - clientObject.modify_stiffnesses_material_table[0][idx].modification_type = i['modification_type'] - clientObject.modify_stiffnesses_material_table[0][idx].E_and_G = i['E_and_G'] - clientObject.modify_stiffnesses_material_table[0][idx].comment = i['comment'] + clientObject.modify_stiffnesses_material_table[0][idx].row.modification_type = i['modification_type'] + clientObject.modify_stiffnesses_material_table[0][idx].row.E_and_G = i['E_and_G'] + clientObject.modify_stiffnesses_material_table[0][idx].row.comment = i['comment'] if modify_stiffnesses['modify_stiffnesses_sections']: for i in modify_stiffnesses_sections_list: idx = i['no']-1 - clientObject.modify_stiffnesses_sections_table[0][idx].A = i['A'] - clientObject.modify_stiffnesses_sections_table[0][idx].A_y = i['A_y'] - clientObject.modify_stiffnesses_sections_table[0][idx].A_z = i['A_z'] - clientObject.modify_stiffnesses_sections_table[0][idx].J = i['J'] - clientObject.modify_stiffnesses_sections_table[0][idx].I_Y = i['I_y'] - clientObject.modify_stiffnesses_sections_table[0][idx].I_z = i['I_z'] + clientObject.modify_stiffnesses_sections_table[0][idx].row.A = i['A'] + clientObject.modify_stiffnesses_sections_table[0][idx].row.A_y = i['A_y'] + clientObject.modify_stiffnesses_sections_table[0][idx].row.A_z = i['A_z'] + clientObject.modify_stiffnesses_sections_table[0][idx].row.J = i['J'] + clientObject.modify_stiffnesses_sections_table[0][idx].row.I_Y = i['I_y'] + clientObject.modify_stiffnesses_sections_table[0][idx].row.I_z = i['I_z'] if modify_stiffnesses['modify_stiffnesses_members']: for i in modify_stiffnesses_members_list: idx = i['no']-1 - clientObject.modify_stiffnesses_members_table[0][idx].member_modification = i['member_modification'] - clientObject.modify_stiffnesses_members_table[0][idx].members = i['members'] - clientObject.modify_stiffnesses_members_table[0][idx].comment = i['comment'] + clientObject.modify_stiffnesses_members_table[0][idx].row.member_modification = i['member_modification'] + clientObject.modify_stiffnesses_members_table[0][idx].row.members = i['members'] + clientObject.modify_stiffnesses_members_table[0][idx].row.comment = i['comment'] if modify_stiffnesses['modify_stiffnesses_surfaces']: for i in modify_stiffnesses_surfaces_list: idx = i['no']-1 - clientObject.modify_stiffnesses_surfaces_table[0][idx].surface_modification = i['surface_modification'] - clientObject.modify_stiffnesses_surfaces_table[0][idx].surfaces = i['surfaces'] - clientObject.modify_stiffnesses_surfaces_table[0][idx].comment = i['comment'] + clientObject.modify_stiffnesses_surfaces_table[0][idx].row.surface_modification = i['surface_modification'] + clientObject.modify_stiffnesses_surfaces_table[0][idx].row.surfaces = i['surfaces'] + clientObject.modify_stiffnesses_surfaces_table[0][idx].row.comment = i['comment'] if modify_stiffnesses['modify_stiffnesses_member_hinges']: for i in modify_stiffnesses_member_hinges_list: idx = i['no']-1 - clientObject.modify_stiffnesses_member_hinges_table[0][idx].member_side = i['member_side'] - clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_u_x = i['C_u_x'] - clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_u_y = i['C_u_y'] - clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_u_z = i['C_u_z'] - clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_phi_x = i['C_phi_x'] - clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_phi_y = i['C_phi_y'] - clientObject.modify_stiffnesses_member_hinges_table[0][idx].C_phi_z = i['C_phi_z'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.member_side = i['member_side'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.C_phi_y = i['C_phi_y'] + clientObject.modify_stiffnesses_member_hinges_table[0][idx].row.C_phi_z = i['C_phi_z'] if modify_stiffnesses['modify_stiffnesses_line_hinges']: for i in modify_stiffnesses_line_hinges_list: idx = i['no']-1 - clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_u_x = i['C_u_x'] - clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_u_y = i['C_u_y'] - clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_u_z = i['C_u_z'] - clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_phi_x = i['C_phi_x'] - clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_phi_y = i['C_phi_y'] - clientObject.modify_stiffnesses_line_hinges_table[0][idx].C_phi_z = i['C_phi_z'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].row.C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].row.C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].row.C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].row.C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].row.C_phi_y = i['C_phi_y'] + clientObject.modify_stiffnesses_line_hinges_table[0][idx].row.C_phi_z = i['C_phi_z'] if modify_stiffnesses['modify_stiffnesses_nodal_supports']: for i in modify_stiffnesses_nodal_supports_list: idx = i['no']-1 - clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_u_x = i['C_u_x'] - clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_u_y = i['C_u_y'] - clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_u_z = i['C_u_z'] - clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_phi_x = i['C_phi_x'] - clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_phi_y = i['C_phi_y'] - clientObject.modify_stiffnesses_nodal_supports_table[0][idx].C_phi_z = i['C_phi_z'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].row.C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].row.C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].row.C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].row.C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].row.C_phi_y = i['C_phi_y'] + clientObject.modify_stiffnesses_nodal_supports_table[0][idx].row.C_phi_z = i['C_phi_z'] if modify_stiffnesses['modify_stiffnesses_line_supports']: for i in modify_stiffnesses_line_supports_list: idx = i['no']-1 - clientObject.modify_stiffnesses_line_supports_table[0][idx].C_u_X = i['C_u_X'] - clientObject.modify_stiffnesses_line_supports_table[0][idx].C_u_Y = i['C_u_Y'] - clientObject.modify_stiffnesses_line_supports_table[0][idx].C_u_Z = i['C_u_Z'] - clientObject.modify_stiffnesses_line_supports_table[0][idx].C_phi_X = i['C_phi_X'] - clientObject.modify_stiffnesses_line_supports_table[0][idx].C_phi_Y = i['C_phi_Y'] - clientObject.modify_stiffnesses_line_supports_table[0][idx].C_phi_Z = i['C_phi_Z'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].row.C_u_X = i['C_u_X'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].row.C_u_Y = i['C_u_Y'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].row.C_u_Z = i['C_u_Z'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].row.C_phi_X = i['C_phi_X'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].row.C_phi_Y = i['C_phi_Y'] + clientObject.modify_stiffnesses_line_supports_table[0][idx].row.C_phi_Z = i['C_phi_Z'] if modify_stiffnesses['modify_stiffnesses_member_supports']: for i in modify_stiffnesses_member_supports_list: idx = i['no']-1 - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_u_x = i['C_u_x'] - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_u_y = i['C_u_y'] - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_u_z = i['C_u_z'] - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_s_x = i['C_s_x'] - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_s_y = i['C_s_y'] - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_s_z = i['C_s_z'] - clientObject.modify_stiffnesses_member_supports_table[0][idx].C_phi_x = i['C_phi_x'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_u_x = i['C_u_x'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_u_y = i['C_u_y'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_u_z = i['C_u_z'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_s_x = i['C_s_x'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_s_y = i['C_s_y'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_s_z = i['C_s_z'] + clientObject.modify_stiffnesses_member_supports_table[0][idx].row.C_phi_x = i['C_phi_x'] if modify_stiffnesses['modify_stiffnesses_surface_supports']: for i in modify_stiffnesses_surface_supports_list: idx = i['no']-1 - clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_u_X = i['C_u_X'] - clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_u_Y = i['C_u_Y'] - clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_u_Z = i['C_u_Z'] - clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_v_xz = i['C_v_xz'] - clientObject.modify_stiffnesses_surface_supports_table[0][idx].C_v_yz = i['C_v_yz'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].row.C_u_X = i['C_u_X'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].row.C_u_Y = i['C_u_Y'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].row.C_u_Z = i['C_u_Z'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].row.C_v_xz = i['C_v_xz'] + clientObject.modify_stiffnesses_surface_supports_table[0][idx].row.C_v_yz = i['C_v_yz'] # Comment clientObject.comment = comment From cb0b1cd5736a793bff8317d5799851777061a89f Mon Sep 17 00:00:00 2001 From: MichalO Date: Wed, 18 May 2022 14:09:52 +0200 Subject: [PATCH 4/4] Result section test correction tested on latest GM unit tests: 147 passed, 9 skipped in 169.79s --- UnitTests/test_SpecialObjects.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/UnitTests/test_SpecialObjects.py b/UnitTests/test_SpecialObjects.py index 0e1bdbe5..910fa186 100644 --- a/UnitTests/test_SpecialObjects.py +++ b/UnitTests/test_SpecialObjects.py @@ -96,7 +96,7 @@ def test_special_objects(): SurfaceContact(1, 1, '1', '3') - ResultSection(1,ResultSectionType.TYPE_2_POINTS_AND_VECTOR, ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_X,True,[1, [1,0,0], [0,2,0], ResultSectionProjection.PROJECTION_IN_VECTOR, [1,1,1]],) + ResultSection(1,ResultSectionType.TYPE_2_POINTS_AND_VECTOR, ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_X,True,[1, [1,0,0], [0,2,0], ResultSectionProjection.PROJECTION_IN_VECTOR, [1,1,1]], True, False) ResultSection.Line(2,ResultSectionResultDirection.SHOW_RESULTS_IN_LOCAL_PLUS_Z,False, '2') ResultSection.TwoPointsAndVector(3,1,ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_Y,False, [10,0,0], [5,5,5], ResultSectionProjection.PROJECTION_IN_GLOBAL_X) ResultSection.TwoPointsAndVector(4,1,ResultSectionResultDirection.SHOW_RESULTS_IN_GLOBAL_MINUS_Y,False, [10,0,0], [5,5,5], ResultSectionProjection.PROJECTION_IN_VECTOR, [-1,1,-1])