From 7f42460e540c3ebee2a6e2e4862648c58fc551f3 Mon Sep 17 00:00:00 2001 From: KaratasD Date: Thu, 21 Oct 2021 16:20:02 +0200 Subject: [PATCH 1/3] configurations_added --- .vscode/settings.json | 1 - Examples/concreteDesign_test.py | 60 ++++++ .../ConcreteServiceabilityConfigurations.py | 65 +++++++ .../ConcreteUltimateConfigurations.py | 65 +++++++ RFEM/ConcreteDesign/__init__.py | 1 + .../ConcreteDurability.py | 182 ++++++++++++++++++ .../ConcreteEffectiveLength.py | 82 ++++++++ RFEM/TypesforConcreteDesign/__init__.py | 1 + RFEM/enums.py | 138 +++++++++++++ 9 files changed, 594 insertions(+), 1 deletion(-) create mode 100644 Examples/concreteDesign_test.py create mode 100644 RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py create mode 100644 RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py create mode 100644 RFEM/ConcreteDesign/__init__.py create mode 100644 RFEM/TypesforConcreteDesign/ConcreteDurability.py create mode 100644 RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py create mode 100644 RFEM/TypesforConcreteDesign/__init__.py diff --git a/.vscode/settings.json b/.vscode/settings.json index 689f352d..c91bb56d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,4 @@ { - "python.linting.pylintEnabled": true, "python.linting.enabled": true, "python.linting.pydocstyleEnabled": false, "python.testing.pytestArgs": [ diff --git a/Examples/concreteDesign_test.py b/Examples/concreteDesign_test.py new file mode 100644 index 00000000..1115748f --- /dev/null +++ b/Examples/concreteDesign_test.py @@ -0,0 +1,60 @@ +import sys +sys.path.append(".") +from RFEM.BasicObjects.member import Member +from RFEM.BasicObjects.node import Node +from RFEM.BasicObjects.section import Section +from RFEM.enums import * +from RFEM.initModel import * +from RFEM.BasicObjects.material import Material +from RFEM.TypesforConcreteDesign.ConcreteDurability import ConcreteDurability +from RFEM.ConcreteDesign.ConcreteUltimateConfigurations import ConcreteUltimateConfiguration +from RFEM.ConcreteDesign.ConcreteServiceabilityConfigurations import ConcreteServiceabilityConfiguration +from RFEM.TypesforConcreteDesign.ConcreteEffectiveLength import ConcreteEffectiveLength + + +if __name__ == '__main__': + + clientModel.service.begin_modification() + + Material(1, 'C30/37') + Section(1, 'R_M1 500/500', 1) + + Node(1, 0, 0, 0) + Node(2, 5, 0, 0) + + Member(1, MemberType.TYPE_BEAM, 1, 2, 0, 1, 1) + + # Concrete Durabilities + ConcreteDurability(1, "XC 1", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [False], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(2, "XC 2", '1', '', '', [False, True, True, True], [DurabilityCorrosionCarbonation.CORROSION_INDUCED_BY_CARBONATION_TYPE_DRY_OR_PERMANENTLY_WET, DurabilityCorrosionChlorides.CORROSION_INDUCED_BY_CHLORIDES_TYPE_MODERATE_HUMIDITY, DurabilityCorrosionSeaWater.CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_AIRBORNE_SALT], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [False], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(3, "XC 3", '1', '', '', [True, False, False, False], [], [True, True, True], [DurabilityFreezeThawAttack.FREEZE_THAW_ATTACK_TYPE_MODERATE_SATURATION_NO_DEICING, DurabilityChemicalAttack.CHEMICAL_ATTACK_TYPE_SLIGHTLY_AGGRESSIVE, DurabilityCorrosionWear.CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_MODERATE], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [False], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(4, "XC 4", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, True, True, True, True], [False], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(5, "XC 5", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.DEFINED, DurabilityStructuralClass.S4], [False], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(6, "XC 6", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [True, DurabilityStainlessSteelType.STANDARD], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(7, "XC 7", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [True, DurabilityStainlessSteelType.DEFINED, 0.012], [False], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(8, "XC 8", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [True, DurabilityStainlessSteelType.DEFINED, 0.012], [True, DurabilityAdditionalProtectionType.STANDARD], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(9, "XC 9", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [True, DurabilityStainlessSteelType.DEFINED, 0.012], [True, DurabilityAdditionalProtectionType.DEFINED, 0.02], [DurabilityAllowanceDeviationType.STANDARD, False]) + + ConcreteDurability(10, "XC 10", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [True, DurabilityStainlessSteelType.DEFINED, 0.012], [True, DurabilityAdditionalProtectionType.DEFINED, 0.02], [DurabilityAllowanceDeviationType.STANDARD, True, DurabilityConcreteCast.AGAINST_PREPARED_GROUND]) + + ConcreteDurability(11, "XC 11", '1', '', '', [True, False, False, False], [], [False, False, False], [], [DurabilityStructuralClassType.STANDARD, False, False, False, False], [True, DurabilityStainlessSteelType.DEFINED, 0.012], [True, DurabilityAdditionalProtectionType.DEFINED, 0.02], [DurabilityAllowanceDeviationType.DEFINED, 0.008]) + + # Concrete Ultimate Configuration + ConcreteUltimateConfiguration(1, 'ULS', '1') + + # Concrete Serviceability Configuration + ConcreteServiceabilityConfiguration(1, 'SLS', '1') + + # Concrete Effective Lengths + ConcreteEffectiveLength() + + print("Ready!") + clientModel.service.finish_modification() \ No newline at end of file diff --git a/RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py b/RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py new file mode 100644 index 00000000..758a40dd --- /dev/null +++ b/RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py @@ -0,0 +1,65 @@ +from RFEM.initModel import * +from RFEM.enums import * + +class ConcreteServiceabilityConfiguration(): + + def __init__(self, + no: int = 1, + name: str = 'SLS', + members = '1', + member_sets = '', + surfaces = '', + surface_sets = '', + nodes = '', + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Configuration Tag + name (str): User Defined Name + members (str): Assigned Members + member_sets (str): Assigned Member Sets + surfaces (str): Assigned Surfaces + surface_sets (str): Assigned Surface Sets + nodes (str): Assigned Nodes + comment (str, optional): Comment + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = clientModel.factory.create('ns0:sls_configuration') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.assigned_to_members = ConvertToDlString(members) + + # Assigned Member Sets + clientObject.assigned_to_member_sets = ConvertToDlString(member_sets) + + # Assigned Surfaces + clientObject.assigned_to_surfaces = ConvertToDlString(surfaces) + + # Assigned Surface Sets + clientObject.assigned_to_surface_sets = ConvertToDlString(surface_sets) + + #Assinged Nodes + clientObject.assigned_to_nodes = ConvertToDlString(nodes) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + clientModel.service.set_sls_configuration(clientObject) \ No newline at end of file diff --git a/RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py b/RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py new file mode 100644 index 00000000..20404af3 --- /dev/null +++ b/RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py @@ -0,0 +1,65 @@ +from RFEM.initModel import * +from RFEM.enums import * + +class ConcreteUltimateConfiguration(): + + def __init__(self, + no: int = 1, + name: str = 'ULS', + members = '1', + member_sets = '', + surfaces = '', + surface_sets = '', + nodes = '', + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Configuration Tag + name (str): User Defined Name + members (str): Assigned Members + member_sets (str): Assigned Member Sets + surfaces (str): Assigned Surfaces + surface_sets (str): Assigned Surface Sets + nodes (str): Assigned Nodes + comment (str, optional): Comment + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = clientModel.factory.create('ns0:uls_configuration') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.assigned_to_members = ConvertToDlString(members) + + # Assigned Member Sets + clientObject.assigned_to_member_sets = ConvertToDlString(member_sets) + + # Assigned Surfaces + clientObject.assigned_to_surfaces = ConvertToDlString(surfaces) + + # Assigned Surface Sets + clientObject.assigned_to_surface_sets = ConvertToDlString(surface_sets) + + #Assinged Nodes + clientObject.assigned_to_nodes = ConvertToDlString(nodes) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + clientModel.service.set_uls_configuration(clientObject) \ No newline at end of file diff --git a/RFEM/ConcreteDesign/__init__.py b/RFEM/ConcreteDesign/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/RFEM/ConcreteDesign/__init__.py @@ -0,0 +1 @@ + diff --git a/RFEM/TypesforConcreteDesign/ConcreteDurability.py b/RFEM/TypesforConcreteDesign/ConcreteDurability.py new file mode 100644 index 00000000..4a44ab61 --- /dev/null +++ b/RFEM/TypesforConcreteDesign/ConcreteDurability.py @@ -0,0 +1,182 @@ +from os import name +from RFEM.initModel import * +from RFEM.enums import * +from enum import * + +class ConcreteDurability(): + + def __init__(self, + no: int = 1, + name: str = "XC 1", + members_no: str = "1", + member_sets_no: str = "1", + surfaces_no: str = "1", + exposure_classes_reinforcement = [True, False, False, False], + exposure_classes_reinforcement_types = [], + exposure_classes_concrete = [False, False, False], + exposure_classes_concrete_types = [], + structural_class = [DurabilityStructuralClassType.STANDARD, False, False, False, False], + stainless_steel_reduction = [False], + additional_protection_reduction = [False], + allowance_deviation = [DurabilityAllowanceDeviationType.STANDARD, False], + comment: str = '', + params: dict = {}): + + # Client model | Concrete Durabilities + clientObject = clientModel.factory.create('ns0:concrete_durability') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.members = ConvertToDlString(members_no) + + # Assigned Member Sets + clientObject.member_sets = ConvertToDlString(member_sets_no) + + # Assigned Surfaces + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Exposure Classes for Reinforcement + clientObject.no_risk_of_corrosion_or_attack_enabled = exposure_classes_reinforcement[0] + clientObject.corrosion_induced_by_carbonation_enabled = exposure_classes_reinforcement[1] + clientObject.corrosion_induced_by_chlorides_enabled = exposure_classes_reinforcement[2] + clientObject.corrosion_induced_by_chlorides_from_sea_water_enabled = exposure_classes_reinforcement[3] + + if all(exposure_classes_reinforcement) == True: + raise Exception("WARNING: At least one reinforcement exposure class must be selected.") + + for i in exposure_classes_reinforcement: + if type(i) == bool: + pass + else: + raise Exception('WARNING: The type of parameters should be bool. Kindly check list inputs for completeness and correctness.') + + if exposure_classes_reinforcement[0] == True: + clientObject.no_risk_of_corrosion_or_attack = "VERY_DRY" + for i in exposure_classes_reinforcement[1:]: + if i == True: + raise Exception('WARNING: If No Risk of Corrosion is True, other parameters cannot be selected. Kindly check list inputs for completeness and correctness.') + else: + pass + + if exposure_classes_reinforcement[1] : + clientObject.corrosion_induced_by_carbonation = exposure_classes_reinforcement_types[0].name + if exposure_classes_reinforcement[2]: + clientObject.corrosion_induced_by_chlorides = exposure_classes_reinforcement_types[1].name + if exposure_classes_reinforcement[3]: + clientObject.corrosion_induced_by_chlorides_from_sea_water = exposure_classes_reinforcement_types[2].name + + # Exposure Classes for Concrete + for i in exposure_classes_concrete: + if type(i) == bool: + pass + else: + raise Exception('WARNING: The type of parameters should be bool. Kindly check list inputs for completeness and correctness.') + + if exposure_classes_concrete[0]: + clientObject.freeze_thaw_attack_enabled = True + clientObject.freeze_thaw_attack = exposure_classes_concrete_types[0].name + if exposure_classes_concrete[1]: + clientObject.chemical_attack_enabled = True + clientObject.chemical_attack = exposure_classes_concrete_types[1].name + if exposure_classes_concrete[2]: + clientObject.concrete_corrosion_induced_by_wear_enabled = True + clientObject.concrete_corrosion_induced_by_wear = exposure_classes_concrete_types[2].name + + # Structural Class + clientObject.structural_class_type = structural_class[0].name + + if structural_class[0].name == "STANDARD": + for i in structural_class[1:]: + if type(i) == bool: + pass + else: + raise Exception('WARNING: The type of last three parameters should be bool. Kindly check list inputs for completeness and correctness.') + + clientObject.increase_design_working_life_from_50_to_100_years_enabled = structural_class[1] + clientObject.position_of_reinforcement_not_affected_by_construction_process_enabled = structural_class[2] + clientObject.special_quality_control_of_production_enabled = structural_class[3] + clientObject.air_entrainment_of_more_than_4_percent_enabled = structural_class[4] + elif structural_class[0].name == "DEFINED": + clientObject.userdefined_structural_class = structural_class[1].name + + # Stainless Steel Concrete Cover Reduction + clientObject.stainless_steel_enabled = stainless_steel_reduction[0] + + if type(stainless_steel_reduction[0]) == bool: + pass + else: + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + if stainless_steel_reduction[0] == False: + pass + else: + clientObject.stainless_steel_type = stainless_steel_reduction[1].name + + if stainless_steel_reduction[1].name == "STANDARD": + pass + elif stainless_steel_reduction[1].name == "DEFINED": + clientObject.stainless_steel_factor = stainless_steel_reduction[2] + + # Additional Protection Concrete Cover Reduction + clientObject.additional_protection_enabled = additional_protection_reduction[0] + + if type(additional_protection_reduction[0]) == bool: + pass + else: + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + if additional_protection_reduction[0] == False: + pass + else: + clientObject.additional_protection_type = additional_protection_reduction[1].name + + if additional_protection_reduction[1].name == "STANDARD": + pass + elif additional_protection_reduction[1].name == "DEFINED": + clientObject.additional_protection_factor = additional_protection_reduction[2] + + # Allowance for Deviation + clientObject.allowance_of_deviation_type = allowance_deviation[0].name + + if allowance_deviation[0].name == "STANDARD": + clientObject.concrete_cast_enabled = allowance_deviation[1] + + if type(allowance_deviation[1]) == bool: + pass + else: + raise Exception('WARNING: The type of the second parameter should be bool. Kindly check list inputs for completeness and correctness.') + + if allowance_deviation[1]: + clientObject.concrete_cast = allowance_deviation[2].name + else: + pass + + elif allowance_deviation[0].name == "DEFINED": + clientObject.userdefined_allowance_of_deviation_factor = allowance_deviation[1] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + clientModel.service.set_concrete_durability(clientObject) + + + + + + + + diff --git a/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py b/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py new file mode 100644 index 00000000..8d390628 --- /dev/null +++ b/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py @@ -0,0 +1,82 @@ +from os import name +from RFEM.initModel import * +from RFEM.enums import * +from enum import * + +class ConcreteEffectiveLength(): + + def __init__(self, + no: int = 1, + name: str = "EL 1", + members_no: str = "1", + member_sets_no: str = "1", + flexural_buckling_about_y = [True, ConcreteEffectiveLengthAxisY.STRUCTURE_TYPE_UNBRACED], + flexural_buckling_about_z = [True, ConcreteEffectiveLengthsAxisZ.STRUCTURE_TYPE_UNBRACED], + nodal_supports = [[0, EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, + True, EffectiveLengthEccentricityType.eccentricity_type, 0, 0, 0, 0, + SupportStatus.SUPPORT_STATUS_YES, RestraintTypeAboutX.SUPPORT_STATUS_NO, + RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "2"], + [0, EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, + True, EffectiveLengthEccentricityType.eccentricity_type, 0, 0, 0, 0, + SupportStatus.SUPPORT_STATUS_YES, RestraintTypeAboutX.SUPPORT_STATUS_NO, + RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "2"]], + factors = [[1, 1, 1]], + comment: str = '', + params: dict = {}): + + # Client model | Concrete Durabilities + clientObject = clientModel.factory.create('ns0:concrete_effective_lengths') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.members = ConvertToDlString(members_no) + + # Assigned Member Sets + clientObject.member_sets = ConvertToDlString(member_sets_no) + + # Flexural Buckling + clientObject.flexural_buckling_about_y = flexural_buckling_about_y[0] + clientObject.structure_type_about_axis_y = flexural_buckling_about_y[1] + + if type(flexural_buckling_about_y[0]) == bool: + pass + else: + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + clientObject.flexural_buckling_about_z = flexural_buckling_about_z[0] + clientObject.structure_type_about_axis_z = flexural_buckling_about_z[1] + + if type(flexural_buckling_about_z[0]) == bool: + pass + else: + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + # Factors + clientObject.concrete_effective_lengths_factors = factors + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + clientModel.service.set_concrete_effective_lengths(clientObject) + + + + + + + + diff --git a/RFEM/TypesforConcreteDesign/__init__.py b/RFEM/TypesforConcreteDesign/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/RFEM/TypesforConcreteDesign/__init__.py @@ -0,0 +1 @@ + diff --git a/RFEM/enums.py b/RFEM/enums.py index c45201ad..e8dbbfd8 100644 --- a/RFEM/enums.py +++ b/RFEM/enums.py @@ -669,3 +669,141 @@ class export_to_ifc_axis_type(Enum): class export_to_ifc_export_type(Enum): E_EXPORT_IFC4_REFERENCE_VIEW, E_EXPORT_IFC4_STRUCTURAL_ANALYSIS_VIEW = range(2) + +class DurabilityCorrosionCarbonation(Enum): + ''' + Concrete Durability Corrosion Induced by Carbonation + ''' + CORROSION_INDUCED_BY_CARBONATION_TYPE_CYCLIC_WET_AND_DRY, CORROSION_INDUCED_BY_CARBONATION_TYPE_DRY_OR_PERMANENTLY_WET,\ + CORROSION_INDUCED_BY_CARBONATION_TYPE_MODERATE_HUMIDITY, CORROSION_INDUCED_BY_CARBONATION_TYPE_WET_RARELY_DRY = range(4) + +class DurabilityCorrosionChlorides(Enum): + ''' + Concrete Durability Corrosion Induced by Chlorides + ''' + CORROSION_INDUCED_BY_CHLORIDES_TYPE_CYCLIC_WET_AND_DRY, CORROSION_INDUCED_BY_CHLORIDES_TYPE_MODERATE_HUMIDITY, CORROSION_INDUCED_BY_CHLORIDES_TYPE_WET_RARELY_DRY = range(3) + +class DurabilityCorrosionSeaWater(Enum): + ''' + Concrete Durability Corrosion Induced by Chlorised From Sea Water + ''' + CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_AIRBORNE_SALT, CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_PERMANENTLY_SUBMERGED,\ + CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_SPLASH_AND_SPRAY_ZONES = range(3) + +class DurabilityFreezeThawAttack(Enum): + ''' + Concrete Durability Freeze Thaw Attack + ''' + FREEZE_THAW_ATTACK_TYPE_HIGH_SATURATION_DEICING, FREEZE_THAW_ATTACK_TYPE_HIGH_SATURATION_NO_DEICING,\ + FREEZE_THAW_ATTACK_TYPE_MODERATE_SATURATION_DEICING, FREEZE_THAW_ATTACK_TYPE_MODERATE_SATURATION_NO_DEICING = range(4) + +class DurabilityChemicalAttack(Enum): + ''' + Concrete Durability Chemical Attack + ''' + CHEMICAL_ATTACK_TYPE_HIGHLY_AGGRESSIVE, CHEMICAL_ATTACK_TYPE_MODERATELY_AGGRESSIVE, CHEMICAL_ATTACK_TYPE_SLIGHTLY_AGGRESSIVE = range(3) + +class DurabilityCorrosionWear(Enum): + ''' + Concrete Durability Concrete Corrosion Induced by the Wear + ''' + CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_HIGH, CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_MODERATE, CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_VERY_HIGH = range(3) + +class DurabilityStructuralClassType(Enum): + ''' + Concrete Durability Structural Class Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityStructuralClass(Enum): + ''' + Concrete Durability User Defined Structural Class + ''' + S1, S2, S3, S4, S5, S6 = range(6) + +class DurabilityMaxWaterToCementRatio(Enum): + ''' + Concrete Durability Maximum Equivalent Water To Cement Ratio + ''' + ZERO_POINT_FIVE, ZERO_POINT_FIVE_FIVE, ZERO_POINT_FOUR, ZERO_POINT_FOUR_FIVE, ZERO_POINT_NINE, ZERO_POINT_SIX, ZERO_POINT_THREE_FIVE = range(7) + +class DurabilityConcreteCoverType(Enum): + ''' + Concrete Durability Increase of Minimum Concrete Cover Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityStainlessSteelType(Enum): + ''' + Concrete Durability Additional Protection Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityAdditionalProtectionType(Enum): + ''' + Concrete Durability Additional Protection Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityAllowanceDeviationType(Enum): + ''' + Concrete Durability Allowance of Deviation Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityConcreteCast(Enum): + ''' + Concrete Durability Concrete Cast + ''' + AGAINST_PREPARED_GROUND, DIRECTLY_AGAINST_SOIL = range(2) + +class ConcreteEffectiveLengthsAxisZ(Enum): + ''' + Concrete Effective Lengths Structure Type About Axis Z + ''' + STRUCTURE_TYPE_BRACED, STRUCTURE_TYPE_UNBRACED = range(2) + +class ConcreteEffectiveLengthAxisY(Enum): + ''' + Concrete Effective Lengths Structure Type About Axis Y + ''' + STRUCTURE_TYPE_BRACED, STRUCTURE_TYPE_UNBRACED = range(2) + +class EffectiveLengthSupportType(Enum): + ''' + Effective Length Nodal Support Type + ''' + SUPPORT_TYPE_FIXED_ALL, SUPPORT_TYPE_FIXED_IN_Y, SUPPORT_TYPE_FIXED_IN_Z, SUPPORT_TYPE_FIXED_IN_Z_AND_TORSION,\ + SUPPORT_TYPE_FIXED_IN_Z_AND_TORSION_AND_WARPING, SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION, SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION_AND_WARPING,\ + SUPPORT_TYPE_INDIVIDUALLY, SUPPORT_TYPE_NONE, SUPPORT_TYPE_RESTRAINT_ABOUT_X = range(10) + +class EffectiveLengthEccentricityType(Enum): + ''' + Effective Length Eccentricity Type + ''' + ECCENTRICITY_TYPE_AT_LOWER_FLANGE, ECCENTRICITY_TYPE_AT_UPPER_FLANGE, ECCENTRICITY_TYPE_NONE, ECCENTRICITY_TYPE_USER_VALUE = range(4) + +class SupportStatus(Enum): + ''' + Support Status + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class RestraintTypeAboutX(Enum): + ''' + Restraint About X Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class RestraintTypeAboutZ(Enum): + ''' + Restraint About X Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class RestraintTypeWarping(Enum): + ''' + Restraint About Warping + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + From 318880e7143e8b47a91355e3a4fdd14f996514b6 Mon Sep 17 00:00:00 2001 From: KaratasD Date: Tue, 26 Oct 2021 09:41:11 +0200 Subject: [PATCH 2/3] types_for_concrete_design --- .../ConcreteDurability.py | 19 +- .../ConcreteEffectiveLength.py | 68 ++++++- .../ConcreteReinforcementDirections.py | 65 ++++++ .../ConcreteSurfaceReinforcements.py | 191 ++++++++++++++++++ RFEM/enums.py | 44 ++++ .../test_concreteDesign.py | 19 ++ 6 files changed, 395 insertions(+), 11 deletions(-) create mode 100644 RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py create mode 100644 RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py rename Examples/concreteDesign_test.py => UnitTests/test_concreteDesign.py (52%) diff --git a/RFEM/TypesforConcreteDesign/ConcreteDurability.py b/RFEM/TypesforConcreteDesign/ConcreteDurability.py index 4a44ab61..f0464475 100644 --- a/RFEM/TypesforConcreteDesign/ConcreteDurability.py +++ b/RFEM/TypesforConcreteDesign/ConcreteDurability.py @@ -4,7 +4,6 @@ from enum import * class ConcreteDurability(): - def __init__(self, no: int = 1, name: str = "XC 1", @@ -21,6 +20,24 @@ def __init__(self, allowance_deviation = [DurabilityAllowanceDeviationType.STANDARD, False], comment: str = '', params: dict = {}): + """ + Args: + no (int): Concrete Durability Tag + name (str): User Defined Name + members_no (str): Assigned Members + member_sets_no (str): Assigned Member Sets + surfaces_no (str): Assigned Surfaces + exposure_classes_reinforcement (list): Exposure Classes Reinforcement Parameters + exposure_classes_reinforcement_types (list): Exposure Classes Reinforcement Parameters + exposure_classes_concrete (list): Exposure Classes Concrete Parameters + exposure_classes_concrete_types (list): Exposure Classes Concrete Parameters + structural_class (list): Structural Class Parameters + stainless_steel_reduction (list): Stainless Steel Reduction Parameters + additional_protection_reduction (list): Additional Protection Reduction + allowance_deviation (list): Allowance Deviation Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + """ # Client model | Concrete Durabilities clientObject = clientModel.factory.create('ns0:concrete_durability') diff --git a/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py b/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py index 8d390628..600398e9 100644 --- a/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py +++ b/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py @@ -4,7 +4,6 @@ from enum import * class ConcreteEffectiveLength(): - def __init__(self, no: int = 1, name: str = "EL 1", @@ -12,17 +11,37 @@ def __init__(self, member_sets_no: str = "1", flexural_buckling_about_y = [True, ConcreteEffectiveLengthAxisY.STRUCTURE_TYPE_UNBRACED], flexural_buckling_about_z = [True, ConcreteEffectiveLengthsAxisZ.STRUCTURE_TYPE_UNBRACED], - nodal_supports = [[0, EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, - True, EffectiveLengthEccentricityType.eccentricity_type, 0, 0, 0, 0, + nodal_supports = [[EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, + True, 0, EffectiveLengthEccentricityType.ECCENTRICITY_TYPE_NONE, 0, 0, 0, 0, SupportStatus.SUPPORT_STATUS_YES, RestraintTypeAboutX.SUPPORT_STATUS_NO, - RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "2"], - [0, EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, - True, EffectiveLengthEccentricityType.eccentricity_type, 0, 0, 0, 0, + RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "1"], + [EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, + True, 0, EffectiveLengthEccentricityType.ECCENTRICITY_TYPE_NONE, 0, 0, 0, 0, SupportStatus.SUPPORT_STATUS_YES, RestraintTypeAboutX.SUPPORT_STATUS_NO, RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "2"]], - factors = [[1, 1, 1]], + factors = [[1, 1]], comment: str = '', params: dict = {}): + """ + Args: + no (int): Effective Length Tag + name (str): User Defined Name + members_no (str): Assigned Members + member_sets_no (str): Assigned Member Sets + flexural_buckling_about_y (list): Flexural Buckling About Y Option + flexural_buckling_about_z (list): Flexural Buckling About Z Option + nodal_supports (list): Nodal Support Table + factors (list): Factors Table + comment (str, optional): Comments + params (dict, optional): Parameters + + nodal_supports = [[support_type, support_in_z, support_spring_in_y, eccentricity_type, + eccentricity_ez, restraint_spring_about_x, + restraint_spring_about_z, restraint_spring_warping, support_in_y_type, + restraint_about_x_type, restraint_about_z_type, restraint_warping_type, nodes], ...] + + factors = [[flexural_buckling_y, flexural_buckling_z]] + """ # Client model | Concrete Durabilities clientObject = clientModel.factory.create('ns0:concrete_effective_lengths') @@ -52,17 +71,46 @@ def __init__(self, else: raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') - clientObject.flexural_buckling_about_z = flexural_buckling_about_z[0] - clientObject.structure_type_about_axis_z = flexural_buckling_about_z[1] + clientObject.flexural_buckling_about_y = flexural_buckling_about_y[0] + clientObject.structure_type_about_axis_y = flexural_buckling_about_y[1].name if type(flexural_buckling_about_z[0]) == bool: pass else: raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + clientObject.flexural_buckling_about_z = flexural_buckling_about_z[0] + clientObject.structure_type_about_axis_z = flexural_buckling_about_z[1].name + # Factors - clientObject.concrete_effective_lengths_factors = factors + clientObject.factors = clientModel.factory.create('ns0:concrete_effective_lengths.factors') + for i in range(len(factors)): + mlvlp = clientModel.factory.create('ns0:concrete_effective_lengths_factors') + mlvlp.no = i+1 + mlvlp.flexural_buckling_y = factors[i][0] + mlvlp.flexural_buckling_z = factors[i][1] + clientObject.factors.concrete_effective_lengths_factors.append(mlvlp) + # Nodal Supports + clientObject.nodal_supports = clientModel.factory.create('ns0:concrete_effective_lengths.nodal_supports') + for i in range(len(nodal_supports)): + mlvlp = clientModel.factory.create('ns0:concrete_effective_lengths_nodal_supports') + mlvlp.no = i+1 + mlvlp.support_type = nodal_supports[i][0].name + mlvlp.support_in_z = nodal_supports[i][1] + mlvlp.support_spring_in_y = nodal_supports[i][2] + mlvlp.eccentricity_type = nodal_supports[i][3].name + mlvlp.eccentricity_ez = nodal_supports[i][4] + mlvlp.restraint_spring_about_x = nodal_supports[i][5] + mlvlp.restraint_spring_about_z = nodal_supports[i][6] + mlvlp.restraint_warping_type = nodal_supports[i][7] + mlvlp.support_in_y_type = nodal_supports[i][8].name + mlvlp.restraint_about_x_type = nodal_supports[i][9].name + mlvlp.restraint_about_z_type = nodal_supports[i][10].name + mlvlp.restraint_warping_type = nodal_supports[i][11].name + mlvlp.nodes = nodal_supports[i][12] + clientObject.nodal_supports.concrete_effective_lengths_nodal_supports.append(mlvlp) + # Comment clientObject.comment = comment diff --git a/RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py b/RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py new file mode 100644 index 00000000..d6f96b6b --- /dev/null +++ b/RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py @@ -0,0 +1,65 @@ +from RFEM.initModel import * +from RFEM.enums import * +from enum import * +import math + +class ConcreteReinforcementDirection(): + def __init__(self, + no: int = 1, + name: str = "RD 1", + surfaces = "1", + reinforcement_direction_type = ReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_X, + rotation_parameters = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Reinforcement Direction Tag + name (str): User Defined Name + surfaces (str): Assigned Surfaces + reinforcement_direction_type (enum): Reinforcement Direction Enumeration + rotation_parameters (list): Rotation Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = clientModel.factory.create('ns0:reinforcement_direction') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Reinforcement Direction Type + clientObject.reinforcement_direction_type = reinforcement_direction_type.name + + if reinforcement_direction_type.name == "REINFORCEMENT_DIRECTION_TYPE_ROTATED": + clientObject.first_reinforcement_angle = rotation_parameters[0] * math.pi/180 + clientObject.second_reinforcement_angle = rotation_parameters[1] * math.pi/180 + + # Assigned Surfaces + clientObject.surfaces = ConvertToDlString(surfaces) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + clientModel.service.set_reinforcement_direction(clientObject) + + + + + + + + diff --git a/RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py b/RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py new file mode 100644 index 00000000..553636f5 --- /dev/null +++ b/RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py @@ -0,0 +1,191 @@ +from RFEM.initModel import * +from RFEM.enums import * +from enum import * +import math + +class ConcreteSurfaceReinforcements(): + def __init__(self, + no: int = 1, + name: str = "RD 1", + surfaces = "1", + material = "2", + location_type = SurfaceReinforcementLocationType.LOCATION_TYPE_ON_SURFACE, + reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_REBARS, + reinforcement_type_parameters = [0.01, 0.15, False], + cover_offset = [True, True, 0, 0], + reinforcement_direction = SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, + reinforcement_direction_parameters = [SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1], + reinforcement_location = [], + reinforcement_acting_region = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Surface Reinforcement Tag + name (str): User Defined Name + surfaces (str): Assigned Surfaces + material (str): Reinforcement Material + location_type (enum): Location Type Enumeration + reinforcement_type (enum): Reinforcement Type Enumeration + reinforcement_type_parameters (list): Reinforcement Type Parameters + cover_offset (list): Cover Offset Parameters + reinforcement_direction (enum): Reinforcement Direction Enumeration + reinforcement_direction_parameters (list): Reinforcement Direction Parameters + reinforcement_location (list): Reinforcement Location Parameters + reinforcement_acting_region (list): Reinforcement Acting Region Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + + for reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_REBARS: + reinforcement_type_parameters = [rebar_diameter, rebar_spacing, additional_transverse_reinforcement_enabled] + if additional_transverse_reinforcement_enabled == True: + reinforcement_type_parameters = [rebar_diameter, rebar_spacing, additional_transverse_reinforcement_enabled, additional_rebar_diameter, additional_rebar_spacing] + for reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS: + reinforcement_type_parameters = [stirrup_diameter, stirrup_spacing] + for reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_MESH: + reinforcement_type_parameters = [mesh_product_range, mesh_shape, mesh_name] + + cover_offset = [alignment_top_enabled, alignment_bottom_enabled, additional_offset_to_concrete_cover_top, additional_offset_to_concrete_cover_bottom] + """ + + # Client model | Concrete Durabilities + clientObject = clientModel.factory.create('ns0:surface_reinforcement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Surfaces + clientObject.surfaces = ConvertToDlString(surfaces) + + # Material + clientObject.material = material + + # Location Type + clientObject.location_type = location_type.name + + # Reinforcement Type + clientObject.reinforcement_type = reinforcement_type.name + if reinforcement_type.name == "REINFORCEMENT_TYPE_REBARS": + clientObject.rebar_diameter = reinforcement_type_parameters[0] + clientObject.rebar_spacing = reinforcement_type_parameters[1] + + clientObject.additional_transverse_reinforcement_enabled = reinforcement_type_parameters[2] + if type(reinforcement_type_parameters[2]) == bool: + pass + else: + raise Exception("WARNING: Last parameter should be type bool for cover_offset. Kindly check list inputs completeness and correctness.") + + if reinforcement_type_parameters[2] == False: + pass + else: + clientObject.additional_rebar_diameter = reinforcement_type_parameters[3] + clientObject.additional_rebar_spacing = reinforcement_type_parameters[4] + elif reinforcement_type.name == "REINFORCEMENT_TYPE_STIRRUPS": + clientObject.stirrup_diameter = reinforcement_type_parameters[0] + clientObject.stirrup_spacing = reinforcement_type_parameters[1] + elif reinforcement_type.name == "REINFORCEMENT_TYPE_MESH": + clientObject.mesh_product_range = reinforcement_type_parameters[0] + clientObject.mesh_shape = reinforcement_type_parameters[1] + clientObject.mesh_name = reinforcement_type_parameters[2] + + # Concrete Cover Assignment + if type(cover_offset[0]) == bool and type(cover_offset[1]) == bool: + pass + else: + raise Exception("WARNING: First two parameters should be type bool for cover_offset. Kindly check list inputs completeness and correctness.") + clientObject.alignment_top_enabled = cover_offset[0] + clientObject.alignment_bottom_enabled = cover_offset[1] + + if cover_offset[0]: + clientObject.additional_offset_to_concrete_cover_top = cover_offset[2] + if cover_offset[1]: + clientObject.additional_offset_to_concrete_cover_bottom = cover_offset[3] + + # Reinforcement Direction + if location_type.name == "LOCATION_TYPE_ON_SURFACE": + clientObject.reinforcement_direction_type = reinforcement_direction.name + if reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION": + clientObject.design_reinforcement_direction = reinforcement_direction_parameters[0].name + elif reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS": + clientObject.first_direction_point_1 = reinforcement_direction_parameters[0] + clientObject.first_direction_point_2 = reinforcement_direction_parameters[1] + clientObject.second_direction_point_1 = reinforcement_direction_parameters[2] + clientObject.second_direction_point_2 = reinforcement_direction_parameters[3] + clientObject.projection_coordinate_system = reinforcement_direction_parameters[4] + clientObject.projection_plane = reinforcement_direction_parameters[5].name + else: + clientObject.reinforcement_direction_type = reinforcement_direction.name + if reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION": + clientObject.design_reinforcement_direction = reinforcement_direction_parameters[0].name + clientObject.projection_coordinate_system = reinforcement_direction_parameters[1] + clientObject.projection_plane = reinforcement_direction_parameters[2].name + elif reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS": + clientObject.first_direction_point_1 = reinforcement_direction_parameters[0] + clientObject.first_direction_point_2 = reinforcement_direction_parameters[1] + clientObject.second_direction_point_1 = reinforcement_direction_parameters[2] + clientObject.second_direction_point_2 = reinforcement_direction_parameters[3] + clientObject.projection_coordinate_system = reinforcement_direction_parameters[4] + clientObject.projection_plane = reinforcement_direction_parameters[5].name + + # Reinforcement Location + if location_type.name == "LOCATION_TYPE_ON_SURFACE": + pass + elif location_type.name == "LOCATION_TYPE_FREE_RECTANGULAR": + clientObject.location_rectangle_type = reinforcement_location[0].name + if reinforcement_location[0].name == "RECTANGLE_TYPE_CORNER_POINTS": + clientObject.location_first_x = reinforcement_location[1] + clientObject.location_first_y = reinforcement_location[2] + clientObject.location_second_x = reinforcement_location[3] + clientObject.location_second_y = reinforcement_location[4] + clientObject.location_rotation = reinforcement_location[5]*math.pi/180 + elif reinforcement_location[0].name == "RECTANGLE_TYPE_CENTER_AND_SIDES": + clientObject.location_center_x = reinforcement_location[1] + clientObject.location_center_y = reinforcement_location[2] + clientObject.location_center_side_a = reinforcement_location[3] + clientObject.location_center_side_b = reinforcement_location[4] + clientObject.location_rotation = reinforcement_location[5] *math.pi/180 + elif location_type.name == "LOCATION_TYPE_FREE_CIRCULAR": + clientObject.location_center_x = reinforcement_location[0] + clientObject.location_center_y = reinforcement_location[1] + clientObject.location_radius = reinforcement_location[2] + elif location_type.name == "LOCATION_TYPE_FREE_POLYGON": + clientObject.polygon_points = clientModel.factory.create('ns0:surface_reinforcement.polygon_points') + for i in range(len(reinforcement_location)): + mlvlp = clientModel.factory.create('ns0:surface_reinforcement_polygon_points') + mlvlp.no = i+1 + mlvlp.first_coordinate = reinforcement_location[i][0] + mlvlp.second_coordinate = reinforcement_location[i][1] + mlvlp.comment = reinforcement_location[i][2] + clientObject.polygon_points.surface_reinforcement_polygon_points.append(mlvlp) + + # Reinforcement Acting Region + if location_type.name == "LOCATION_TYPE_ON_SURFACE": + pass + else: + clientObject.acting_region_from = reinforcement_acting_region[0] + clientObject.acting_region_to = reinforcement_acting_region[1] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + clientModel.service.set_surface_reinforcement(clientObject) + + + + + + + + diff --git a/RFEM/enums.py b/RFEM/enums.py index e8dbbfd8..27747793 100644 --- a/RFEM/enums.py +++ b/RFEM/enums.py @@ -807,3 +807,47 @@ class RestraintTypeWarping(Enum): ''' SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) +class ReinforcementDirectionType(Enum): + ''' + Reinforcement Direction Type + ''' + REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_X, REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_Y, REINFORCEMENT_DIRECTION_TYPE_ROTATED = range(3) + +class SurfaceReinforcementLocationType(Enum): + ''' + Surface Reinforcement Location Type + ''' + LOCATION_TYPE_FREE_CIRCULAR, LOCATION_TYPE_FREE_POLYGON, LOCATION_TYPE_FREE_RECTANGULAR, LOCATION_TYPE_ON_SURFACE = range(4) + +class SurfaceReinforcementType(Enum): + ''' + Surface Reinforcement Type + ''' + REINFORCEMENT_TYPE_MESH, REINFORCEMENT_TYPE_REBARS, REINFORCEMENT_TYPE_STIRRUPS = range(3) + +class SurfaceReinforcementDirectionType(Enum): + ''' + Surface Reinforcement Direction Type + ''' + REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS = range(2) + +class SurfaceReinforcementDesignDirection(Enum): + ''' + Surface Design Reinforcement Direction + ''' + DESIGN_REINFORCEMENT_DIRECTION_A_S_1, DESIGN_REINFORCEMENT_DIRECTION_A_S_2 = range(2) + +class SurfaceReinforcementProjectionPlane(Enum): + ''' + Surface Reinforcement Projection Plane + ''' + + PROJECTION_PLANE_XY_OR_UV, PROJECTION_PLANE_XZ_OR_UW, PROJECTION_PLANE_YZ_OR_VW = range(3) + +class SurfaceReinforcementLocationRectangleType(Enum): + ''' + Surface Reinforcement Location Type + ''' + RECTANGLE_TYPE_CENTER_AND_SIDES, RECTANGLE_TYPE_CORNER_POINTS = range(2) + + diff --git a/Examples/concreteDesign_test.py b/UnitTests/test_concreteDesign.py similarity index 52% rename from Examples/concreteDesign_test.py rename to UnitTests/test_concreteDesign.py index 1115748f..1c757925 100644 --- a/Examples/concreteDesign_test.py +++ b/UnitTests/test_concreteDesign.py @@ -10,6 +10,8 @@ from RFEM.ConcreteDesign.ConcreteUltimateConfigurations import ConcreteUltimateConfiguration from RFEM.ConcreteDesign.ConcreteServiceabilityConfigurations import ConcreteServiceabilityConfiguration from RFEM.TypesforConcreteDesign.ConcreteEffectiveLength import ConcreteEffectiveLength +from RFEM.TypesforConcreteDesign.ConcreteReinforcementDirections import ConcreteReinforcementDirection +from RFEM.TypesforConcreteDesign.ConcreteSurfaceReinforcements import ConcreteSurfaceReinforcements if __name__ == '__main__': @@ -17,6 +19,7 @@ clientModel.service.begin_modification() Material(1, 'C30/37') + Material(2, 'B550S(A)') Section(1, 'R_M1 500/500', 1) Node(1, 0, 0, 0) @@ -56,5 +59,21 @@ # Concrete Effective Lengths ConcreteEffectiveLength() + # Concrete Reinforcement Direction + ConcreteReinforcementDirection(1, 'RD 1', "", ReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_X) + ConcreteReinforcementDirection(2, 'RD 2', "", ReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_Y) + ConcreteReinforcementDirection(3, 'RD 3', "", ReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_ROTATED, [30, 60]) + + # Concrete Surface Reinforcements + ConcreteSurfaceReinforcements() + ConcreteSurfaceReinforcements(2, "RD 2", "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_ON_SURFACE, SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS, [0.01, 0.15]) + ConcreteSurfaceReinforcements(3, "RD 3", "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_ON_SURFACE, SurfaceReinforcementType.REINFORCEMENT_TYPE_MESH, ["Germany - 1997-01-01", "Q-Mesh", "Q131A"]) + ConcreteSurfaceReinforcements(4, "RD 4", "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_ON_SURFACE, reinforcement_direction=SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS, reinforcement_direction_parameters=[1, 2, 3, 4, "1", SurfaceReinforcementProjectionPlane.PROJECTION_PLANE_XY_OR_UV]) + ConcreteSurfaceReinforcements(5, "RD 5", "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_ON_SURFACE, reinforcement_direction=SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, reinforcement_direction_parameters=[SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1, "1", SurfaceReinforcementProjectionPlane.PROJECTION_PLANE_XY_OR_UV], reinforcement_location=[SurfaceReinforcementLocationRectangleType.RECTANGLE_TYPE_CORNER_POINTS, 1, 2, 3, 4, 35], reinforcement_acting_region=["-inf", "+inf"]) + ConcreteSurfaceReinforcements(6, 'RD 6', "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_FREE_RECTANGULAR, SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS, [0.01, 0.15], reinforcement_direction =SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, reinforcement_direction_parameters = [SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1, "1", SurfaceReinforcementProjectionPlane.PROJECTION_PLANE_XY_OR_UV], reinforcement_location=[SurfaceReinforcementLocationRectangleType.RECTANGLE_TYPE_CORNER_POINTS, 1, 2, 3, 4, 35], reinforcement_acting_region=["-inf", "+inf"]) + ConcreteSurfaceReinforcements(7, 'RD 7', "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_FREE_RECTANGULAR, SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS, [0.01, 0.15], reinforcement_direction=SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, reinforcement_direction_parameters = [SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1, "1", SurfaceReinforcementProjectionPlane.PROJECTION_PLANE_XY_OR_UV], reinforcement_location=[SurfaceReinforcementLocationRectangleType.RECTANGLE_TYPE_CENTER_AND_SIDES, 2, 3, 2, 2, 35], reinforcement_acting_region=["-inf", "+inf"]) + ConcreteSurfaceReinforcements(8, 'RD 8', "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_FREE_CIRCULAR, SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS, [0.01, 0.15], reinforcement_direction=SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, reinforcement_direction_parameters = [SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1, "1", SurfaceReinforcementProjectionPlane.PROJECTION_PLANE_XY_OR_UV], reinforcement_location=[1, 2, 3], reinforcement_acting_region=["-inf", "+inf"]) + ConcreteSurfaceReinforcements(9, 'RD 9', "", "2", SurfaceReinforcementLocationType.LOCATION_TYPE_FREE_POLYGON, SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS, [0.01, 0.15], reinforcement_direction=SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, reinforcement_direction_parameters = [SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1, "1", SurfaceReinforcementProjectionPlane.PROJECTION_PLANE_XY_OR_UV], reinforcement_location=[[1, 1, ""], [2, 2, ""], [3, 2, ""]], reinforcement_acting_region=["-inf", "+inf"]) + print("Ready!") clientModel.service.finish_modification() \ No newline at end of file From e681778b1d6b89502639b4c9a4b65cf1028d24ac Mon Sep 17 00:00:00 2001 From: KaratasD Date: Tue, 26 Oct 2021 09:48:39 +0200 Subject: [PATCH 3/3] concrete_design_tests --- RFEM/enums.py | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/RFEM/enums.py b/RFEM/enums.py index 27747793..6654410d 100644 --- a/RFEM/enums.py +++ b/RFEM/enums.py @@ -670,6 +670,60 @@ class export_to_ifc_export_type(Enum): E_EXPORT_IFC4_REFERENCE_VIEW, E_EXPORT_IFC4_STRUCTURAL_ANALYSIS_VIEW = range(2) +class ModelType(Enum): + ''' + Model Type | Enum + ''' + E_MODEL_TYPE_1D_X_3D, E_MODEL_TYPE_1D_X_AXIAL, E_MODEL_TYPE_2D_XY_3D, \ + E_MODEL_TYPE_2D_XY_PLATE, E_MODEL_TYPE_2D_XZ_3D, E_MODEL_TYPE_2D_XZ_PLANE_STRAIN, \ + E_MODEL_TYPE_2D_XZ_PLANE_STRESS, E_MODEL_TYPE_3D = range(8) +class ModalSolutionMethod(Enum): + ''' + Modal Analysis Settings Solution Method + ''' + METHOD_ICG_ITERATION, METHOD_LANCZOS, METHOD_ROOT_OF_CHARACTERISTIC_POLYNOMIAL, METHOD_SUBSPACE_ITERATION, SOLUTION_METHOD_SHIFTED_INVERSE_POWER_METHOD = range(5) + +class ModalMassConversionType(Enum): + ''' + Modal Analysis Settings Mass Conversion Type + ''' + MASS_CONVERSION_TYPE_FULL_LOADS_AS_MASS, MASS_CONVERSION_TYPE_Z_COMPONENTS_OF_LOADS, MASS_CONVERSION_TYPE_Z_COMPONENTS_OF_LOADS_IN_DIRECTION_OF_GRAVITY = range(3) + +class ModalMassMatrixType(Enum): + ''' + Modal Analysis Settings Mass Matrix Type + ''' + MASS_MATRIX_TYPE_CONSISTENT, MASS_MATRIX_TYPE_DIAGONAL, MASS_MATRIX_TYPE_DIAGONAL_WITH_TORSIONAL_ELEMENTS, MASS_MATRIX_TYPE_UNIT = range(4) + +class ModalModeNumberMethod(Enum): + ''' + Modal Analysis Settings Number of Modes Method + ''' + NUMBER_OF_MODES_METHOD_EFFECTIVE_MASS_FACTORS, NUMBER_OF_MODES_METHOD_MAXIMUM_FREQUENCY, NUMBER_OF_MODES_METHOD_USER_DEFINED = range(3) + +class ModalNeglectMasses(Enum): + ''' + Modal Analysis Settings Neglect Masses + ''' + E_NEGLECT_MASSES_IN_ALL_FIXED_SUPPORTS, E_NEGLECT_MASSES_NO_NEGLECTION, E_NEGLECT_MASSES_USER_DEFINED = range(3) +class PeriodicResponseCombinationRule(Enum): + ''' + Spectral Analysis Settings Combination Rule For Periodic Responses + ''' + ABSOLUTE_SUM, CQC, SRSS = range(3) + +class DirectionalComponentCombinationRule(Enum): + ''' + Spectral Analysis Settings Combination Rule For Directional Components + ''' + ABSOLUTE_SUM, SCALED_SUM, SRSS = range(3) + +class CqsDampingRule(Enum): + ''' + Spectal Analysis Settings Damping for CQC Rule + ''' + CONSTANT_FOR_EACH_MODE, DIFFERENT_FOR_EACH_MODE = range(2) + class DurabilityCorrosionCarbonation(Enum): ''' Concrete Durability Corrosion Induced by Carbonation