diff --git a/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py b/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py index 9241bd68..c043c92e 100644 --- a/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py +++ b/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py @@ -1,11 +1,21 @@ from RFEM.initModel import * -from RFEM.enums import SetType +from RFEM.enums import StabilityAnalysisSettingsAnalysisType +from RFEM.enums import StabilityAnalysisSettingsEigenvalueMethod +from RFEM.enums import StabilityAnalysisSettingsMatrixType +from RFEM.enums import StabilityAnalysisSettingsStoppingOfLoadIncreasingResult class StabilityAnalysisSettings(): def __init__(self, no: int = 1, + name: str = None, comment: str = '', params: dict = {}): + ''' + Creates default stability analysis settings with no further options. + Stability analysis type is Eigenvalue by default. + Eigenvalue method is Lanczos by default. + Matrix type is Standard by default. + ''' # Client model | Stability Analysis Settings clientObject = clientModel.factory.create('ns0:stability_analysis_settings') @@ -16,9 +26,374 @@ def __init__(self, # Stability Analysis Settings No. clientObject.no = no + # Name + if name != None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.EIGENVALUE_METHOD.name + + # Number of Lowest Eigenvalues + clientObject.number_of_lowest_eigenvalues = 4 + + # Eigenvalue Method + clientObject.eigenvalue_method = StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS.name + + # Matrix Type + clientObject.matrix_type = StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + clientModel.service.set_stability_analysis_settings(clientObject) + + def EigenvalueMethod(self, + no: int = 1, + name: str = None, + number_of_lowest_eigenvalues: int = 4, + considered_favored_effect: bool = True, + critical_load_factor = None, + minimum_initial_strain = 1e-05, + local_torsional_rotations = None, + eigenvalue_method = StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS, + matrix_type = StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD, + comment: str = '', + params: dict = {}): + ''' + Args: + no (int): + name (str, optional): Stability Analysis Name + number_of_lowest_eigenvalues (int): Number of Lowest Eigenvalues + considered_favored_effect (bool): Considered Favored Effect + critical_load_factor (int, optional): + For find_eigenvectors_beyond_critical_load_factor == False: + critical_load_factor = None + For find_eigenvectors_beyond_critical_load_factor == True: + critical_load_factor = int + minimum_initial_strain (optional): + For minimum initial strain application: + minimum_initial_strain != 0 or minimum_initial_strain != None + For no minimum initial strain application: + minimum_initial_strain == 0 or minimum_initial_strain == None + local_torsional_rotations (optional): + For no local torsional rotations display: + local_torsional_rotations = None + For local torsional rotations display: + local_torsional_rotations = double + eigenvalue_method (enum): Eigenvalue Method Enumeration + matrix_type (enum): Matrix Type Enumeration + comment (str, optional): + params (dict, optional): + ''' + # Client model | Stability Analysis Settings + clientObject = clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name != None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.EIGENVALUE_METHOD.name + + # Number of Lowest Eigenvalues + clientObject.number_of_lowest_eigenvalues = number_of_lowest_eigenvalues + + # Considered Favored Effect + clientObject.considered_favored_effect = considered_favored_effect + + # Finding Eigenvectors Beyond Critical Load Factor + if critical_load_factor != None: + clientObject.find_eigenvectors_beyond_critical_load_factor = True + clientObject.critical_load_factor = critical_load_factor + + # Minimum Initial Strain + if minimum_initial_strain == None or minimum_initial_strain == 0: + clientObject.activate_minimum_initial_prestress = False + elif minimum_initial_strain != None or minimum_initial_strain != 0: + clientObject.activate_minimum_initial_prestress = True + clientObject.minimum_initial_strain = minimum_initial_strain + + # Local Torsional Relations + if local_torsional_rotations != None: + clientObject.display_local_torsional_rotations = True + clientObject.local_torsional_rotations + + # Eigenvalue Method + clientObject.eigenvalue_method = eigenvalue_method.name + + # Matrix Type + clientObject.matrix_type = matrix_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + clientModel.service.set_stability_analysis_settings(clientObject) + + def IncrementalyMethodWithEigenvalue(self, + no: int = 1, + name: str = None, + number_of_lowest_eigenvalues: int = 4, + considered_favored_effect: bool = True, + critical_load_factor = None, + minimum_initial_strain = 1e-05, + local_torsional_rotations = None, + incrementally_increasing_loading = [1.0, 0.1, 10, 100], + stopping_of_load_increasing = None, + save_results_of_all_increments: bool = False, + eigenvalue_method = StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS, + matrix_type = StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD, + comment: str = '', + params: dict = {}): + ''' + Args: + no (int): + name (str, optional): Stability Analysis Name + number_of_lowest_eigenvalues (int): Number of Lowest Eigenvalues + considered_favored_effect (bool): Considered Favored Effect + critical_load_factor (int, optional): + For find_eigenvectors_beyond_critical_load_factor == False: + critical_load_factor = None + For find_eigenvectors_beyond_critical_load_factor == True: + critical_load_factor = int + minimum_initial_strain (optional): + For minimum initial strain application: + minimum_initial_strain != 0 or minimum_initial_strain != None + For no minimum initial strain application: + minimum_initial_strain == None + local_torsional_rotations (optional): + For no local torsional rotations display: + local_torsional_rotations = None + For local torsional rotations display: + local_torsional_rotations = double + incrementally_increasing_loading (list): [initial_load_factor, load_factor_increment, refinement_of_the_last_load_increment, maximum_number_of_load_increments] + stopping_of_load_increasing (list, optional): + For stopping of load increasing deactivated: + stopping_of_load_increasing : None + For result u: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U, limit_result_displacement, limit_node] + For result uX: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_X, limit_result_displacement, limit_node] + For result uY: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Y, limit_result_displacement, limit_node] + For result uZ: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Z, limit_result_displacement, limit_node] + For result phi: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI, limit_result_rotation, limit_node] + For result phiX: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_X, limit_result_rotation, limit_node] + For result phiY: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Y, limit_result_rotation, limit_node] + For result phiZ: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Z, limit_result_rotation, limit_node] + save_results_of_all_increments (bool, optional): Save Results of All Increments + eigenvalue_method (enum): Eigenvalue Method Enumeration + matrix_type (enum): Matrix Type Enumeration + comment (str, optional): + params (dict, optional): + ''' + # Client model | Stability Analysis Settings + clientObject = clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name != None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.INCREMENTALY_METHOD_WITH_EIGENVALUE.name + + # Number of Lowest Eigenvalues + clientObject.number_of_lowest_eigenvalues = number_of_lowest_eigenvalues + + # Considered Favored Effect + clientObject.considered_favored_effect = considered_favored_effect + + # Finding Eigenvectors Beyond Critical Load Factor + if critical_load_factor != None: + clientObject.find_eigenvectors_beyond_critical_load_factor = True + clientObject.critical_load_factor = critical_load_factor + + # Minimum Initial Strain + if minimum_initial_strain == None or minimum_initial_strain == 0: + clientObject.activate_minimum_initial_prestress = False + elif minimum_initial_strain != None or minimum_initial_strain != 0: + clientObject.activate_minimum_initial_prestress = True + clientObject.minimum_initial_strain = minimum_initial_strain + + # Local Torsional Relations + if local_torsional_rotations != None: + clientObject.display_local_torsional_rotations = True + clientObject.local_torsional_rotations + + # Increase Loading + if len(incrementally_increasing_loading) != 4: + raise Exception('WARNING: The incrementally increasing loading parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.initial_load_factor = incrementally_increasing_loading[0] + clientObject.load_factor_increment = incrementally_increasing_loading[1] + clientObject.refinement_of_the_last_load_increment = incrementally_increasing_loading[2] + clientObject.maximum_number_of_load_increments = incrementally_increasing_loading[3] + + # Stopping of Load-Increasing + if stopping_of_load_increasing != None: + if len(stopping_of_load_increasing) != 3: + raise Exception('WARNING: For active stopping of load-increasing, the stopping of load increasing parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.activate_stopping_of_load_increasing = True + clientObject.stopping_of_load_increasing_result = stopping_of_load_increasing[0].name + if stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Z': + clientObject.stopping_of_load_increasing_limit_result_displacement = stopping_of_load_increasing[1] + elif stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Z': + clientObject.stopping_of_load_increasing_limit_result_rotation = stopping_of_load_increasing[1] + clientObject.stopping_of_load_increasing_limit_node = stopping_of_load_increasing[2] + + # Save Results of All Increments + clientObject.save_results_of_all_increments = save_results_of_all_increments + + # Eigenvalue Method + clientObject.eigenvalue_method = eigenvalue_method.name + + # Matrix Type + clientObject.matrix_type = matrix_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + clientModel.service.set_stability_analysis_settings(clientObject) + + def IncrementalyMethodWithoutEigenvalue(self, + no: int = 1, + name: str = None, + minimum_initial_strain = 1e-05, + local_torsional_rotations = None, + incrementally_increasing_loading = [1.0, 0.1, 10, 100], + stopping_of_load_increasing = None, + save_results_of_all_increments: bool = False, + comment: str = '', + params: dict = {}): + ''' + Args: + no (int): + name (str, optional): Stability Analysis Name + minimum_initial_strain (optional): + For minimum initial strain application: + minimum_initial_strain != 0 or minimum_initial_strain != None + For no minimum initial strain application: + minimum_initial_strain == 0 or minimum_initial_strain == None + local_torsional_rotations (optional): + For no local torsional rotations display: + local_torsional_rotations = None + For local torsional rotations display: + local_torsional_rotations = double + incrementally_increasing_loading (list): [initial_load_factor, load_factor_increment, refinement_of_the_last_load_increment, maximum_number_of_load_increments] + stopping_of_load_increasing (list, optional): + For stopping of load increasing deactivated: + stopping_of_load_increasing : None + For result u: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U, limit_result_displacement, limit_node] + For result uX: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_X, limit_result_displacement, limit_node] + For result uY: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Y, limit_result_displacement, limit_node] + For result uZ: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Z, limit_result_displacement, limit_node] + For result phi: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI, limit_result_rotation, limit_node] + For result phiX: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_X, limit_result_rotation, limit_node] + For result phiY: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Y, limit_result_rotation, limit_node] + For result phiZ: + stopping_of_load_increasing : [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Z, limit_result_rotation, limit_node] + save_results_of_all_increments (bool, optional): Save Results of All Increments + comment (str, optional): + params (dict, optional): + ''' + # Client model | Stability Analysis Settings + clientObject = clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name != None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.INCREMENTALY_METHOD_WITHOUT_EIGENVALUE.name + + # Minimum Initial Strain + if minimum_initial_strain == None or minimum_initial_strain == 0: + clientObject.activate_minimum_initial_prestress = False + elif minimum_initial_strain != None or minimum_initial_strain != 0: + clientObject.activate_minimum_initial_prestress = True + clientObject.minimum_initial_strain = minimum_initial_strain + + # Local Torsional Relations + if local_torsional_rotations != None: + clientObject.display_local_torsional_rotations = True + clientObject.local_torsional_rotations + + # Increase Loading + if len(incrementally_increasing_loading) != 4: + raise Exception('WARNING: The incrementally increasing loading parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.initial_load_factor = incrementally_increasing_loading[0] + clientObject.load_factor_increment = incrementally_increasing_loading[1] + clientObject.refinement_of_the_last_load_increment = incrementally_increasing_loading[2] + clientObject.maximum_number_of_load_increments = incrementally_increasing_loading[3] + + # Stopping of Load-Increasing + if stopping_of_load_increasing != None: + if len(stopping_of_load_increasing) != 3: + raise Exception('WARNING: For active stopping of load-increasing, the stopping of load increasing parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.activate_stopping_of_load_increasing = True + clientObject.stopping_of_load_increasing_result = stopping_of_load_increasing[0].name + if stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Z': + clientObject.stopping_of_load_increasing_limit_result_displacement = stopping_of_load_increasing[1] + elif stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Z': + clientObject.stopping_of_load_increasing_limit_result_rotation = stopping_of_load_increasing[1] + clientObject.stopping_of_load_increasing_limit_node = stopping_of_load_increasing[2] + + # Save Results of All Increments + clientObject.save_results_of_all_increments = save_results_of_all_increments + + # Comment + clientObject.comment = comment + # Adding optional parameters via dictionary for key in params: clientObject[key] = params[key] # Add Stability Analysis Settings to client model - clientModel.service.set_stability_analysis_settings(clientObject) \ No newline at end of file + clientModel.service.set_stability_analysis_settings(clientObject) diff --git a/RFEM/enums.py b/RFEM/enums.py index 14b039ed..58da510c 100644 --- a/RFEM/enums.py +++ b/RFEM/enums.py @@ -181,6 +181,9 @@ class ThicknessDirection(Enum): THICKNESS_DIRECTION_IN_Y, THICKNESS_DIRECTION_IN_Z = range(5) class ThicknessSelfWeightDefinitionType(Enum): + ''' + Thickness Self Weight Definition Type | Enum + ''' SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, \ SELF_WEIGHT_DEFINED_VIA_WEIGHT = range(3) class ThicknessShapeOrthotropySelfWeightDefinitionType(Enum): @@ -192,12 +195,13 @@ class ThicknessStiffnessMatrixSelfWeightDefinitionType(Enum): SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY, \ SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY = range(3) class ThicknessOrthotropyType(Enum): + ''' + Thickness Orthotropy Type | Enum + ''' ORTHOTROPIC_THICKNESS_TYPE_BIDIRECTIONAL_RIBBED_PLATE, ORTHOTROPIC_THICKNESS_TYPE_COUPLING, \ ORTHOTROPIC_THICKNESS_TYPE_EFFECTIVE_THICKNESS, ORTHOTROPIC_THICKNESS_TYPE_GRILLAGE, \ ORTHOTROPIC_THICKNESS_TYPE_HOLLOW_CORE_SLAB, ORTHOTROPIC_THICKNESS_TYPE_TRAPEZOIDAL_SHEET, \ ORTHOTROPIC_THICKNESS_TYPE_UNIDIRECTIONAL_RIBBED_PLATE = range(7) - - class LineLoadDirection(Enum): ''' @@ -208,12 +212,10 @@ class LineLoadDirection(Enum): LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,\ LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z = range(9) - class MemberLoadEccentricityHorizontalAlignment(Enum): ''' Member Load Eccentricity Horizontal Alignment ''' - ALIGN_LEFT, ALIGN_MIDDLE, ALIGN_NONE, ALIGN_TOP = range(4) @@ -221,14 +223,12 @@ class MemberLoadEccentricityVerticalAlignment(Enum): ''' Member Load Eccentricity Vertical Alignment ''' - ALIGN_LEFT, ALIGN_MIDDLE, ALIGN_NONE, ALIGN_TOP = range(4) class MemberLoadEccentricitySectionMiddle(Enum): ''' Member Load Eccentricity Section Middle ''' - LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, LOAD_ECCENTRICITY_SECTION_MIDDLE_NONE, LOAD_ECCENTRICITY_SECTION_MIDDLE_SHEAR_CENTER = range(3) class MemberLoadFormFindingDefinitionType(Enum): @@ -633,6 +633,34 @@ class CqsDampingRule(Enum): ''' CONSTANT_FOR_EACH_MODE, DIFFERENT_FOR_EACH_MODE = range(2) +class StabilityAnalysisSettingsAnalysisType(Enum): + ''' + Stability Analysis Settings Analysis Type | Enum + ''' + EIGENVALUE_METHOD, INCREMENTALY_METHOD_WITHOUT_EIGENVALUE, \ + INCREMENTALY_METHOD_WITH_EIGENVALUE = range(3) + +class StabilityAnalysisSettingsEigenvalueMethod(Enum): + ''' + Stability Analysis Settings Eigenvalue Method | Enum + ''' + EIGENVALUE_METHOD_ICG_ITERATION, EIGENVALUE_METHOD_LANCZOS, \ + EIGENVALUE_METHOD_ROOTS_OF_CHARACTERISTIC_POLYNOMIAL, \ + EIGENVALUE_METHOD_SUBSPACE_ITERATION, E_EIGENVALUE_METHOD_SHIFTED_INVERSE_POWER_METHOD = range(5) + +class StabilityAnalysisSettingsMatrixType(Enum): + ''' + Stability Analysis Settings Matrix Type | Enum + ''' + MATRIX_TYPE_STANDARD, MATRIX_TYPE_UNIT = range(2) + +class StabilityAnalysisSettingsStoppingOfLoadIncreasingResult(Enum): + ''' + Stability Analysis Settings Stopping Of Load Increasing Result | Enum + ''' + RESULT_TYPE_DISPLACEMENT_U, RESULT_TYPE_DISPLACEMENT_U_X, RESULT_TYPE_DISPLACEMENT_U_Y, \ + RESULT_TYPE_DISPLACEMENT_U_Z, RESULT_TYPE_ROTATION_PHI, RESULT_TYPE_ROTATION_PHI_X, \ + RESULT_TYPE_ROTATION_PHI_Y, RESULT_TYPE_ROTATION_PHI_Z = range(8) class LineType(Enum): ''' Line Type | Enum @@ -715,4 +743,4 @@ class CqsDampingRule(Enum): ''' Spectal Analysis Settings Damping for CQC Rule ''' - CONSTANT_FOR_EACH_MODE, DIFFERENT_FOR_EACH_MODE = range(2) \ No newline at end of file + CONSTANT_FOR_EACH_MODE, DIFFERENT_FOR_EACH_MODE = range(2) diff --git a/UnitTests/test_stabilitysettings.py b/UnitTests/test_stabilitysettings.py new file mode 100644 index 00000000..064f3eb3 --- /dev/null +++ b/UnitTests/test_stabilitysettings.py @@ -0,0 +1,136 @@ +import sys +sys.path.append(".") +from RFEM.enums import * +from RFEM.dataTypes import * +from RFEM.initModel import * +from RFEM.LoadCasesAndCombinations.stabilityAnalysisSettings import * + +def test_stability_analysis_settings_init(): + + clientModel.service.reset() + clientModel.service.begin_modification() + + StabilityAnalysisSettings() + + clientModel.service.finish_modification() + + stability_analysis_settings = clientModel.service.get_stability_analysis_settings(1) + + assert stability_analysis_settings.analysis_type == 'EIGENVALUE_METHOD' + assert stability_analysis_settings.activate_minimum_initial_prestress == True + assert stability_analysis_settings.eigenvalue_method == 'EIGENVALUE_METHOD_LANCZOS' + assert stability_analysis_settings.calculate_without_loading_for_instability == False + assert stability_analysis_settings.considered_favored_effect == True + assert stability_analysis_settings.display_local_torsional_rotations == False + assert stability_analysis_settings.find_eigenvectors_beyond_critical_load_factor == False + assert stability_analysis_settings.matrix_type == 'MATRIX_TYPE_STANDARD' + assert stability_analysis_settings.minimum_initial_strain == 1e-05 + assert stability_analysis_settings.number_of_lowest_eigenvalues == 4 + +def test_stability_analysis_settings_eigenvalue_method(): + + clientModel.service.reset() + clientModel.service.begin_modification() + + StabilityAnalysisSettings.EigenvalueMethod(StabilityAnalysisSettings, no= 1, + name= 'Eigenvalue Method Test', + number_of_lowest_eigenvalues= 5, + considered_favored_effect= False, + critical_load_factor= 10, + minimum_initial_strain= 0.000025, + local_torsional_rotations= 0.2, + eigenvalue_method= StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_ROOTS_OF_CHARACTERISTIC_POLYNOMIAL, + matrix_type= StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_UNIT, + comment= 'Test Comment') + + clientModel.service.finish_modification() + + stability_analysis_settings = clientModel.service.get_stability_analysis_settings(1) + + assert stability_analysis_settings.analysis_type == 'EIGENVALUE_METHOD' + assert stability_analysis_settings.activate_minimum_initial_prestress == True + assert stability_analysis_settings.eigenvalue_method == 'EIGENVALUE_METHOD_ROOTS_OF_CHARACTERISTIC_POLYNOMIAL' + assert stability_analysis_settings.calculate_without_loading_for_instability == False + assert stability_analysis_settings.considered_favored_effect == False + assert stability_analysis_settings.display_local_torsional_rotations == True + assert stability_analysis_settings.find_eigenvectors_beyond_critical_load_factor == True + assert stability_analysis_settings.critical_load_factor == 10 + assert stability_analysis_settings.matrix_type == 'MATRIX_TYPE_UNIT' + assert stability_analysis_settings.minimum_initial_strain == 2.5e-05 + assert stability_analysis_settings.number_of_lowest_eigenvalues == 5 + +def test_stability_analysis_settings_incrementaly_method_with_eigenvalue(): + + clientModel.service.reset() + clientModel.service.begin_modification() + + StabilityAnalysisSettings.IncrementalyMethodWithEigenvalue(StabilityAnalysisSettings, no= 1, + name= 'Incrementaly Method with Eigenvalue Test', + number_of_lowest_eigenvalues= 5, + considered_favored_effect= True, + critical_load_factor= 11, + minimum_initial_strain= None, + local_torsional_rotations= None, + incrementally_increasing_loading= [2, 0.2, 12, 200], + stopping_of_load_increasing= [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U, 0.1, 0], + save_results_of_all_increments= True, + eigenvalue_method= StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS, + matrix_type= StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD, + comment= 'Test Comment') + + clientModel.service.finish_modification() + + stability_analysis_settings = clientModel.service.get_stability_analysis_settings(1) + + assert stability_analysis_settings.analysis_type == 'INCREMENTALY_METHOD_WITH_EIGENVALUE' + assert stability_analysis_settings.activate_minimum_initial_prestress == False + assert stability_analysis_settings.activate_stopping_of_load_increasing == True + assert stability_analysis_settings.eigenvalue_method == 'EIGENVALUE_METHOD_LANCZOS' + assert stability_analysis_settings.calculate_without_loading_for_instability == False + assert stability_analysis_settings.considered_favored_effect == True + assert stability_analysis_settings.display_local_torsional_rotations == False + assert stability_analysis_settings.find_eigenvectors_beyond_critical_load_factor == True + assert stability_analysis_settings.critical_load_factor == 11 + assert stability_analysis_settings.initial_load_factor == 2 + assert stability_analysis_settings.load_factor_increment == 0.2 + assert stability_analysis_settings.matrix_type == 'MATRIX_TYPE_STANDARD' + assert stability_analysis_settings.maximum_number_of_load_increments == 200 + assert stability_analysis_settings.number_of_lowest_eigenvalues == 5 + assert stability_analysis_settings.refinement_of_the_last_load_increment == 12 + assert stability_analysis_settings.save_results_of_all_increments == True + assert stability_analysis_settings.stopping_of_load_increasing_limit_node == 0 + assert stability_analysis_settings.stopping_of_load_increasing_limit_result_displacement == 0.1 + assert stability_analysis_settings.stopping_of_load_increasing_result == 'RESULT_TYPE_DISPLACEMENT_U' + +def test_stability_analysis_settings_incrementaly_method_without_eigenvalue(): + + clientModel.service.reset() + clientModel.service.begin_modification() + + StabilityAnalysisSettings.IncrementalyMethodWithoutEigenvalue(StabilityAnalysisSettings, no= 1, + name= 'Incrementaly Method with Eigenvalue Test', + minimum_initial_strain= 0, + local_torsional_rotations= 0.2, + incrementally_increasing_loading= [1, 0.25, 5, 125], + save_results_of_all_increments= False, + comment= 'Test Comment') + + clientModel.service.finish_modification() + + stability_analysis_settings = clientModel.service.get_stability_analysis_settings(1) + + assert stability_analysis_settings.analysis_type == 'INCREMENTALY_METHOD_WITHOUT_EIGENVALUE' + assert stability_analysis_settings.activate_minimum_initial_prestress == False + assert stability_analysis_settings.activate_stopping_of_load_increasing == False + assert stability_analysis_settings.display_local_torsional_rotations == True + assert stability_analysis_settings.local_torsional_rotations == 0.2 + assert stability_analysis_settings.initial_load_factor == 1 + assert stability_analysis_settings.load_factor_increment == 0.25 + assert stability_analysis_settings.maximum_number_of_load_increments == 125 + assert stability_analysis_settings.refinement_of_the_last_load_increment == 5 + assert stability_analysis_settings.save_results_of_all_increments == False + +test_stability_analysis_settings_init() +test_stability_analysis_settings_eigenvalue_method() +test_stability_analysis_settings_incrementaly_method_with_eigenvalue() +test_stability_analysis_settings_incrementaly_method_without_eigenvalue() \ No newline at end of file