From 59cd3da7d0761cb1e8c09250085a4f3eda0daa8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Fri, 14 Jan 2022 17:01:41 +0100 Subject: [PATCH 1/7] DocStrings Update: BasicObjects All files within BasicObjects complete with appropriate DocStrings (formatting according to node.py as agreed). --- DocStrings - Bjoern Pruefungen.py | 18 ++++ Examples/Cantilever/Demo1.py | 36 ++++---- RFEM/BasicObjects/bracing.py | 43 +++++++++ RFEM/BasicObjects/frame.py | 17 ++++ RFEM/BasicObjects/line.py | 130 ++++++++++++++++++++++----- RFEM/BasicObjects/lineSet.py | 25 ++++++ RFEM/BasicObjects/material.py | 8 ++ RFEM/BasicObjects/memberSet.py | 25 ++++++ RFEM/BasicObjects/opening.py | 12 ++- RFEM/BasicObjects/section.py | 9 ++ RFEM/BasicObjects/solid.py | 45 ++++++++++ RFEM/BasicObjects/solidSet.py | 27 ++++++ RFEM/BasicObjects/surface.py | 114 +++++++++++++++++------- RFEM/BasicObjects/surfaceSet.py | 26 ++++++ RFEM/BasicObjects/thickness.py | 142 ++++++++++++++++-------------- 15 files changed, 538 insertions(+), 139 deletions(-) create mode 100644 DocStrings - Bjoern Pruefungen.py diff --git a/DocStrings - Bjoern Pruefungen.py b/DocStrings - Bjoern Pruefungen.py new file mode 100644 index 00000000..bd763e4b --- /dev/null +++ b/DocStrings - Bjoern Pruefungen.py @@ -0,0 +1,18 @@ +from RFEM.initModel import * +from RFEM.enums import * +from RFEM.BasicObjects.node import * +from RFEM.BasicObjects.line import * + +Model(False) +Model.clientModel.service.begin_modification('new') + +Node(1, 0, 0, 0) +Node(2, 0, -5, 0) +Node(3, 0, 5, 0) +Node(4, 5, 0, 0) + +Line.Circle(1, 1, '2', [0,0,0], 5) +Line.Circle(1, 2, '3', [0,10,0], 5, [0,1,0]) +Line.Circle(1, 3, '1', [0,10,0], 10) + +Model.clientModel.service.finish_modification() \ No newline at end of file diff --git a/Examples/Cantilever/Demo1.py b/Examples/Cantilever/Demo1.py index 9a842f77..80f78941 100644 --- a/Examples/Cantilever/Demo1.py +++ b/Examples/Cantilever/Demo1.py @@ -39,29 +39,29 @@ NodalSupport(1, '1', NodalSupportType.FIXED) StaticAnalysisSettings.GeometricallyLinear(0, 1, "Linear") - StaticAnalysisSettings.SecondOrderPDelta(0, 2, "SecondOrder") - StaticAnalysisSettings.LargeDeformation(0, 3, "LargeDeformation") + # StaticAnalysisSettings.SecondOrderPDelta(0, 2, "SecondOrder") + # StaticAnalysisSettings.LargeDeformation(0, 3, "LargeDeformation") LoadCase(1, 'Self-Weight', [True, 0.0, 0.0, 1.0]) NodalLoad(1, 1, '2', LoadDirectionType.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W, f*1000) Model.clientModel.service.finish_modification() - Calculate_all() + #Calculate_all() # model status - modelStatus = Model.clientModel.service.get_model_info() - print("Model is calculated" if modelStatus.property_has_results else "Model is not calculated") - print("Model contains printout report" if modelStatus.property_has_printout_report else "Model has not printout report") - print ("Model contains " + str(modelStatus.property_node_count) + " nodes") - print ("Model contains " + str(modelStatus.property_line_count) + " lines") - print ("Model contains " + str(modelStatus.property_member_count) + " members") - print ("Model contains " + str(modelStatus.property_surface_count) + " surfaces") - print ("Model contains " + str(modelStatus.property_solid_count) + " solids") - print ("Model contains " + str(modelStatus.property_lc_count) + " load cases") - print ("Model contains " + str(modelStatus.property_co_count) + " load combinations") - print ("Model contains " + str(modelStatus.property_rc_count) + " result classes") - print ("Model weight " + str(modelStatus.property_weight)) - print ("Model dimension x " + str(modelStatus.property_dimensions.x)) - print ("Model dimension y " + str(modelStatus.property_dimensions.y)) - print ("Model dimension z " + str(modelStatus.property_dimensions.z)) + # modelStatus = Model.clientModel.service.get_model_info() + # print("Model is calculated" if modelStatus.property_has_results else "Model is not calculated") + # print("Model contains printout report" if modelStatus.property_has_printout_report else "Model has not printout report") + # print ("Model contains " + str(modelStatus.property_node_count) + " nodes") + # print ("Model contains " + str(modelStatus.property_line_count) + " lines") + # print ("Model contains " + str(modelStatus.property_member_count) + " members") + # print ("Model contains " + str(modelStatus.property_surface_count) + " surfaces") + # print ("Model contains " + str(modelStatus.property_solid_count) + " solids") + # print ("Model contains " + str(modelStatus.property_lc_count) + " load cases") + # print ("Model contains " + str(modelStatus.property_co_count) + " load combinations") + # print ("Model contains " + str(modelStatus.property_rc_count) + " result classes") + # print ("Model weight " + str(modelStatus.property_weight)) + # print ("Model dimension x " + str(modelStatus.property_dimensions.x)) + # print ("Model dimension y " + str(modelStatus.property_dimensions.y)) + # print ("Model dimension z " + str(modelStatus.property_dimensions.z)) diff --git a/RFEM/BasicObjects/bracing.py b/RFEM/BasicObjects/bracing.py index f7979cd2..80a4ec19 100644 --- a/RFEM/BasicObjects/bracing.py +++ b/RFEM/BasicObjects/bracing.py @@ -13,6 +13,19 @@ # comment: str = '', # params: dict = {}): +# ''' +# Args: +# no (int): Bracing Tag +# member_type (enum): Bracing Type Enumeration +# start_node_no (int): Start Node +# end_node_no (int): End Node +# rotation_angle (float): Rotation Angle +# start_section_no (int): Tag of Start Section +# end_section_no (int): End of End Section +# comment (str, optional): Comment +# params (dict, optional): Parameters +# ''' + # # Client model | Bracing # clientObject = Model.clientModel.factory.create('ns0:bracing') @@ -69,6 +82,21 @@ # comment: str = '', # params: dict = {}): +# ''' +# Args: +# no (int): Bracing Tag +# bracing_type (enum): Bracing Type Enumeration +# start_node_no (int): Start Node +# end_node_no (int): End Node +# rotation_angle (float): Rotation Angle +# start_section_no (int): Tag of Start Section +# end_section_no (int): End of End Section +# start_bracing_hinge_no (int): Hinge at Bracing Start +# end_bracing_hinge_no (int): Hinge at Bracing End +# comment (str, optional): Comment +# params (dict, optional): Parameters +# ''' + # # Client model | Bracing # clientObject = Model.clientModel.factory.create('ns0:bracing') @@ -125,6 +153,21 @@ # comment: str = '', # params: dict = {}): +# ''' +# Args: +# no (int): Bracing Tag +# bracing_type (enum): Bracing Type Enumeration +# start_node_no (int): Start Node +# end_node_no (int): End Node +# rotation_angle (float): Rotation Angle +# start_section_no (int): Tag of Start Section +# end_section_no (int): End of End Section +# start_bracing_hinge_no (int): Hinge at Bracing Start +# end_bracing_hinge_no (int): Hinge at Bracing End +# comment (str, optional): Comment +# params (dict, optional): Parameters +# ''' + # # Client model | Bracing # clientObject = Model.clientModel.factory.create('ns0:bracing') diff --git a/RFEM/BasicObjects/frame.py b/RFEM/BasicObjects/frame.py index 7a945307..b8eeae03 100644 --- a/RFEM/BasicObjects/frame.py +++ b/RFEM/BasicObjects/frame.py @@ -16,6 +16,23 @@ # comment: str = '', # params: dict = {}): +# ''' +# Args: +# number_of_frames (int): Number of Frames +# span_l (int): Span Length +# height_h (int): Frame Height +# column_cross_section (int): Tag of Column Section +# column_member_type (enum): Column Member Type Enumeration +# girder_cross_section (int): Tag of Girder Section +# girder_member_type (enum): Girder Member Type Enumeration +# support_type (enum): Column to Girder Connection Type Enumeration +# insertion_point_x (int): Insertion Point x +# insertion_point_y (int): Insertion Point y +# insertion_point_z (int): Insertion Point z +# comment (str, optional): Comment +# params (dict, optional): Parameters +# ''' + # # Client model | Frame # clientObject = clientModel.factory.create('ns0:member') diff --git a/RFEM/BasicObjects/line.py b/RFEM/BasicObjects/line.py index 323cf884..56897495 100644 --- a/RFEM/BasicObjects/line.py +++ b/RFEM/BasicObjects/line.py @@ -8,6 +8,14 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Nodes Defining Line + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -36,6 +44,14 @@ def Polyline(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Nodes Defining Polyline + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -63,12 +79,22 @@ def Polyline(self, def Arc(self, no: int = 1, - nodes_no: list = [1,2], + nodes_no: str = '1 2', control_point: list = [10,0,0], # X,Y,Z alpha_adjustment_target = LineArcAlphaAdjustmentTarget.ALPHA_ADJUSTMENT_TARGET_BEGINNING_OF_ARC, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Nodes Defining Arc + control_point (list): Control Point for Arc in [X, Y, Z] + alpha_adjustment_target (enum): Line Arc Alpha Adjustment Target Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -103,12 +129,23 @@ def Arc(self, def Circle(self, no: int = 1, nodes_no: str = '1', - center_of_cirle = [20,0,0], - circle_radius = 1, - point_of_normal_to_circle_plane = [1,0,0], + center_of_cirle: list = [20,0,0], + circle_radius: float = 1.0, + point_of_normal_to_circle_plane: list = [1,0,0], comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Nodes on Line of Circle + center_of_circle (list): Cartesian Co-Ordinates of Circle Centre [X, Y, Z] + circle_radius (float): Magnitude of Circle Radius + point_of_normal_to_circle_plane (list): Vector from Circle Centre to this Point [X, Y, Z] defines Vector Normal to Circle Plane + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -147,15 +184,27 @@ def Circle(self, Model.clientModel.service.set_line(clientObject) def EllipticalArc(self, - no: int = 72, - p1_control_point = [0,-6,0], - p2_control_point = [20,-6,0], - p3_control_point = [10,10,3], - arc_angle_alpha = 0, - arc_angle_beta = 3.141592653589793, + no: int = 1, + p1_control_point: list = [0,-6,0], + p2_control_point: list = [20,-6,0], + p3_control_point: list = [10,10,3], + arc_angle_alpha: float = 0, + arc_angle_beta: float = 3.141592653589793, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + p1_control_point (list): Control Point 1 [X, Y, Z] + p2_control_point (list): Control Point 2 [X, Y, Z] + p3_control_point (list): Control Point 3 [X, Y, Z] + arc_angle_alpha (float): Alpha Arc Angle (in Radians) + arc_angle_beta (float): Beta Arc Angle (in Radians) + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -196,11 +245,20 @@ def EllipticalArc(self, def Ellipse(self, no: int = 1, - nodes_no: list = [5,10], - p3_control_point = [18,-4.8,0], + nodes_no: str = '1 2', + ellipse_control_point: list = [18,-4.8,0], comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Node Tags on Line of Ellipse + ellipse_control_point (list): Ellipse Control Point [X, Y, Z] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -219,9 +277,9 @@ def Ellipse(self, clientObject.type = LineType.TYPE_ELLIPSE.name # Control point - clientObject.ellipse_control_point_x = p3_control_point[0] - clientObject.ellipse_control_point_y = p3_control_point[1] - clientObject.ellipse_control_point_z = p3_control_point[2] + clientObject.ellipse_control_point_x = ellipse_control_point[0] + clientObject.ellipse_control_point_y = ellipse_control_point[1] + clientObject.ellipse_control_point_z = ellipse_control_point[2] # Comment clientObject.comment = comment @@ -235,12 +293,22 @@ def Ellipse(self, def Parabola(self, no: int = 1, - nodes_no: list = [3, 8], - p3_control_point = [10,-3,0], - parabola_alpha = 0, + nodes_no: str = '1 2', + parabola_control_point: list = [10,-3,0], + parabola_alpha: float = 0, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Node Tags on Line of Parabola + parabola_control_point (list): Parabola Control Point [X, Y, Z] + parabola_alpha (float): Alpha Angle (in Radians) + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -261,9 +329,9 @@ def Parabola(self, clientObject.type = LineType.TYPE_PARABOLA.name # Control point - clientObject.parabola_control_point_x = p3_control_point[0] - clientObject.parabola_control_point_y = p3_control_point[1] - clientObject.parabola_control_point_z = p3_control_point[2] + clientObject.parabola_control_point_x = parabola_control_point[0] + clientObject.parabola_control_point_y = parabola_control_point[1] + clientObject.parabola_control_point_z = parabola_control_point[2] # Comment clientObject.comment = comment @@ -281,6 +349,14 @@ def Spline(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Node Tags on Line of Spline + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -314,6 +390,16 @@ def NURBS(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Tag + nodes_no (str): Node Tags on Line of NURBS Curve + control_points (list): Nested List of Respective Control Point's Cartesian Co-Ordinates + weights (list): Weights of Control Points + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line clientObject = Model.clientModel.factory.create('ns0:line') @@ -330,7 +416,7 @@ def NURBS(self, clientObject.type = LineType.TYPE_NURBS.name if len(control_points) != len(weights): - print("Number of control points must comply with number of weights!") + print("WARNING: The number of weigths prescribed must equal the number of control points defined.") nurbs_control_points = [] for i,j in enumerate(control_points): diff --git a/RFEM/BasicObjects/lineSet.py b/RFEM/BasicObjects/lineSet.py index db067259..137017fb 100644 --- a/RFEM/BasicObjects/lineSet.py +++ b/RFEM/BasicObjects/lineSet.py @@ -9,6 +9,15 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Set Tag + lines_no (str): Tags of Lines Contained Within Line Set + line_set_type (enum): Line Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line Set clientObject = Model.clientModel.factory.create('ns0:line_set') @@ -40,6 +49,14 @@ def ContinuousLines(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Set Tag + lines_no (str): Tags of Lines Contained Within Continuous Line Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line Set clientObject = Model.clientModel.factory.create('ns0:line_set') @@ -71,6 +88,14 @@ def GroupOfLines(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Line Set Tag + lines_no (str): Tags of Lines Contained Within Group of Lines Line Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Line Set clientObject = Model.clientModel.factory.create('ns0:line_set') diff --git a/RFEM/BasicObjects/material.py b/RFEM/BasicObjects/material.py index 16c10597..57a90b56 100644 --- a/RFEM/BasicObjects/material.py +++ b/RFEM/BasicObjects/material.py @@ -7,6 +7,14 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Material Tag + name (str): Name of Desired Material (As Named in RFEM Database) + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Material clientObject = Model.clientModel.factory.create('ns0:material') diff --git a/RFEM/BasicObjects/memberSet.py b/RFEM/BasicObjects/memberSet.py index c49e94f0..48934400 100644 --- a/RFEM/BasicObjects/memberSet.py +++ b/RFEM/BasicObjects/memberSet.py @@ -9,6 +9,15 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Member Set Tag + members_no (str): Tags of Members Contained Within Member Set + member_set_type (enum): Member Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Member Set clientObject = Model.clientModel.factory.create('ns0:member_set') @@ -40,6 +49,14 @@ def ContinuousMembers(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Member Set Tag + members_no (str): Tags of Members Contained Within Continuous Member Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Member Set clientObject = Model.clientModel.factory.create('ns0:member_set') @@ -71,6 +88,14 @@ def GroupOfmembers(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Member Set Tag + members_no (str): Tags of Members Contained Within Group of Members Member Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Member Set clientObject = Model.clientModel.factory.create('ns0:member_set') diff --git a/RFEM/BasicObjects/opening.py b/RFEM/BasicObjects/opening.py index 15679711..e9e0d5c9 100644 --- a/RFEM/BasicObjects/opening.py +++ b/RFEM/BasicObjects/opening.py @@ -2,11 +2,19 @@ class Opening(): def __init__(self, - no: int, - lines_no: str, + no: int = 1, + lines_no: str = '1 2 3 4', comment: str = '', params: dict = {}): + ''' + Args: + no (int): Opening Tag + lines_no (str): Tags of Lines defining Opening + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Opening clientObject = Model.clientModel.factory.create('ns0:opening') diff --git a/RFEM/BasicObjects/section.py b/RFEM/BasicObjects/section.py index b21e6120..967733a3 100644 --- a/RFEM/BasicObjects/section.py +++ b/RFEM/BasicObjects/section.py @@ -8,6 +8,15 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Section Tag + name (str): Name of Desired Section (As Named in RFEM Database) + material_no (int): Tag of Material assigned to Section + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Section clientObject = Model.clientModel.factory.create('ns0:section') diff --git a/RFEM/BasicObjects/solid.py b/RFEM/BasicObjects/solid.py index fb124974..c8460966 100644 --- a/RFEM/BasicObjects/solid.py +++ b/RFEM/BasicObjects/solid.py @@ -9,6 +9,15 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Tag + boundary_surfaces_no (str): Tags of Surfaces defining Solid + material_no (int): Tag of Material assigned to Solid + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid clientObject = Model.clientModel.factory.create('ns0:solid') @@ -41,6 +50,15 @@ def Standard(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Tag + boundary_surfaces_no (str): Tags of Surfaces defining Solid + material_no (int): Tag of Material assigned to Solid + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid clientObject = Model.clientModel.factory.create('ns0:solid') @@ -76,6 +94,15 @@ def Gas(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Tag + boundary_surfaces_no (str): Tags of Surfaces defining Gas + material_no (int): Tag of Material assigned to Solid + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid clientObject = Model.clientModel.factory.create('ns0:solid') @@ -111,6 +138,15 @@ def Contact(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Tag + boundary_surfaces_no (str): Tags of Surfaces defining Contact + material_no (int): Tag of Material assigned to Solid + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid clientObject = Model.clientModel.factory.create('ns0:solid') @@ -146,6 +182,15 @@ def Soil(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Tag + boundary_surfaces_no (str): Tags of Surfaces defining Soil + material_no (int): Tag of Material assigned to Solid + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid clientObject = Model.clientModel.factory.create('ns0:solid') diff --git a/RFEM/BasicObjects/solidSet.py b/RFEM/BasicObjects/solidSet.py index 4f8cb0f7..1be5960c 100644 --- a/RFEM/BasicObjects/solidSet.py +++ b/RFEM/BasicObjects/solidSet.py @@ -9,6 +9,15 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Set Tag + solids_no (str): Tags of Solids Contained Within Solid Set + solid_set_type (enum): Solid Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid Set clientObject = Model.clientModel.factory.create('ns0:solid_set') @@ -41,6 +50,15 @@ def ContinuousSolids(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Set Tag + solids_no (str): Tags of Solids Contained Within Continuous Solid Set + solid_set_type (enum): Solid Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid Set clientObject = Model.clientModel.factory.create('ns0:solid_set') @@ -73,6 +91,15 @@ def GroupOfSolids(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Solid Set Tag + solids_no (str): Tags of Solids Contained Within Group of Solids Solid Set + solid_set_type (enum): Solid Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Solid Set clientObject = Model.clientModel.factory.create('ns0:solid_set') diff --git a/RFEM/BasicObjects/surface.py b/RFEM/BasicObjects/surface.py index 59566e49..c8658fe2 100644 --- a/RFEM/BasicObjects/surface.py +++ b/RFEM/BasicObjects/surface.py @@ -10,8 +10,12 @@ def __init__(self, params: dict = {}): ''' - Assigns surface without any further options. - Surface is a Standard planar surface by default. + Args: + no (int): Surface Tag + boundary_lines_no (str): Tags of Lines defining Surface + thickness (int): Tag of Thickness assigned to Surface + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Surface @@ -49,13 +53,20 @@ def Standard(self, params: dict = {}): ''' - for geometry_type = SurfaceGeometry.GEOMETRY_NURBS: + Args: + no (int): Surface Tag + geometry_type (enum): Surface Geometry Type Enumeration + geometry_type_parameters (list): Geometry Type Parameters + boundary_lines_no (str): Tags of Lines defining Standard Surface + thickness (int): Tag of Thickness assigned to Standard Surface + comment (str, optional): Comments + params (dict, optional): Parameters + + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - - for geometry_type = SurfaceGeometry.GEOMETRY_PLANE: + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: geometry_type_parameters = None - - for geometry_type = SurfaceGeometry.GEOMETRY_QUADRANGLE: + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' @@ -91,13 +102,19 @@ def WithoutThickness(self, params: dict = {}): ''' - for geometry_type = SurfaceGeometry.GEOMETRY_NURBS: + Args: + no (int): Surface Tag + geometry_type (enum): Surface Geometry Type Enumeration + geometry_type_parameters (list): Geometry Type Parameters + boundary_lines_no (str): Tags of Lines defining Without Thickness Surface + comment (str, optional): Comments + params (dict, optional): Parameters + + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - - for geometry_type = SurfaceGeometry.GEOMETRY_PLANE: + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: geometry_type_parameters = None - - for geometry_type = SurfaceGeometry.GEOMETRY_QUADRANGLE: + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' @@ -132,13 +149,19 @@ def Rigid(self, params: dict = {}): ''' - for geometry_type = SurfaceGeometry.GEOMETRY_NURBS: + Args: + no (int): Surface Tag + geometry_type (enum): Surface Geometry Type Enumeration + geometry_type_parameters (list): Geometry Type Parameters + boundary_lines_no (str): Tags of Lines defining Rigid Surface + comment (str, optional): Comments + params (dict, optional): Parameters + + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - - for geometry_type = SurfaceGeometry.GEOMETRY_PLANE: + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: geometry_type_parameters = None - - for geometry_type = SurfaceGeometry.GEOMETRY_QUADRANGLE: + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' @@ -174,13 +197,20 @@ def Membrane(self, params: dict = {}): ''' - for geometry_type = SurfaceGeometry.GEOMETRY_NURBS: + Args: + no (int): Surface Tag + geometry_type (enum): Surface Geometry Type Enumeration + geometry_type_parameters (list): Geometry Type Parameters + boundary_lines_no (str): Tags of Lines defining Membrane Surface + thickness (int): Tag of Thickness assigned to Membrane Surface + comment (str, optional): Comments + params (dict, optional): Parameters + + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - - for geometry_type = SurfaceGeometry.GEOMETRY_PLANE: + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: geometry_type_parameters = None - - for geometry_type = SurfaceGeometry.GEOMETRY_QUADRANGLE: + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' @@ -217,13 +247,20 @@ def WithoutMemberaneTension(self, params: dict = {}): ''' - for geometry_type = SurfaceGeometry.GEOMETRY_NURBS: + Args: + no (int): Surface Tag + geometry_type (enum): Surface Geometry Type Enumeration + geometry_type_parameters (list): Geometry Type Parameters + boundary_lines_no (str): Tags of Lines defining Without Membrane Tension Surface + thickness (int): Tag of Thickness assigned to Without Membrane Tension Surface + comment (str, optional): Comments + params (dict, optional): Parameters + + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - - for geometry_type = SurfaceGeometry.GEOMETRY_PLANE: + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: geometry_type_parameters = None - - for geometry_type = SurfaceGeometry.GEOMETRY_QUADRANGLE: + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' @@ -266,13 +303,26 @@ def LoadDistribution(self, params: dict = {}): ''' - for geometry_type = SurfaceGeometry.GEOMETRY_NURBS: + Args: + no (int): Surface Tag + boundary_lines_no (str): Tags of Lines defining Load Distribution Surface + load_transfer_direction (enum): Surface Load Transfer Direction Enumeration + surface_weight_enabled (bool): Activate/De-Activate Surface Weight + surface_weight (float): Magnitude of Surface Weight + excluded_members (str): Tag of Members to be excluded from Load Distribution + excluded_parallel_to_members (str): Tag of Members to which parallel Members are excluded from Load Distribution + excluded_lines (str): Tag of Lines to be excluded from Load Distribution + excluded_parallel_to_lines (str): Tag of Lines to which parallel Lines are excluded from Load Distribution + loaded_members (str): Tag of Loaded Members + loaded_lines (str): Tag of Loaded Lines + comment (str, optional): Comments + params (dict, optional): Parameters + + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - - for geometry_type = SurfaceGeometry.GEOMETRY_PLANE: + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: geometry_type_parameters = None - - for geometry_type = SurfaceGeometry.GEOMETRY_QUADRANGLE: + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' diff --git a/RFEM/BasicObjects/surfaceSet.py b/RFEM/BasicObjects/surfaceSet.py index 278d6510..c9fa58dc 100644 --- a/RFEM/BasicObjects/surfaceSet.py +++ b/RFEM/BasicObjects/surfaceSet.py @@ -9,6 +9,15 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Surfaces Set Tag + surfaces_no (str): Tags of Surfaces Contained Within Surface Set + surfaces_set_type (enum): Surface Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Surface Set clientObject = Model.clientModel.factory.create('ns0:surface_set') @@ -40,6 +49,15 @@ def ContinuousSurfaces(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Surfaces Set Tag + surfaces_no (str): Tags of Surfaces Contained Within Continuous Surface Set + surfaces_set_type (enum): Surface Set Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Surface Set clientObject = Model.clientModel.factory.create('ns0:surface_set') @@ -71,6 +89,14 @@ def GroupOfSurfaces(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Surfaces Set Tag + surfaces_no (str): Tags of Surfaces Contained Within Group of Surfaces Surface Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Surface Set clientObject = Model.clientModel.factory.create('ns0:surface_set') diff --git a/RFEM/BasicObjects/thickness.py b/RFEM/BasicObjects/thickness.py index 77cf8175..54c564b4 100644 --- a/RFEM/BasicObjects/thickness.py +++ b/RFEM/BasicObjects/thickness.py @@ -15,8 +15,13 @@ def __init__(self, params: dict = {}): ''' - Assigns thickness without any further options. - Thickness types is Uniform by default. + Args: + no (int): Thickness Tag + name (str): Thickness Name + material_no (int): Tag of Material assigned to Thickness + uniform_thickness_d (float): Magnitude of Thickness + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Thickness @@ -56,7 +61,7 @@ def Uniform(self, no: int = 1, name: str = None, material_no: int = 1, - properties = None, + properties = [0.2], comment: str = '', params: dict = {}): @@ -64,8 +69,8 @@ def Uniform(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - properties (list): [uniform_thickness] + material_no (int): Tag of Material assigned to Thickness + properties (list): Magnitude of Thickness [Thickness] comment (str, optional): Comments params (dict, optional): Parameters ''' @@ -117,10 +122,12 @@ def Variable_3Nodes(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - properties (list): [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3] + material_no (int): Tag of Material assigned to Thickness + properties (list): Properties for 3 Nodes Variable Thickness Definition (See Below) comment (str, optional): Comments params (dict, optional): Parameters + + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3] ''' # Client model | Thickness @@ -177,10 +184,12 @@ def Variable_2NodesAndDirection(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - properties (list): [thickness_d1, node_no_1, thickness_d2, node_no_2, direction] + material_no (int): Tag of Material assigned to Thickness + properties (list): Properties for 2 Nodes and Direction Variable Thickness Definition (See Below) comment (str, optional): Comments params (dict, optional): Parameters + + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, direction] ''' # Client model | Thickness @@ -234,10 +243,12 @@ def Variable_4SurfaceCorners(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - properties (list): [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3, thickness_d4, node_no_4] + material_no (int): Tag of Material assigned to Thickness + properties (list): Properties for 4 Surface Corners Variable Definition (See Below) comment (str, optional): Comments params (dict, optional): Parameters + + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3, thickness_d4, node_no_4] ''' # Client model | Thickness @@ -296,10 +307,12 @@ def Variable_Circle(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - properties (list): [thickness_circle_center_dC, thickness_circle_line_dR + material_no (int): Tag of Material assigned to Thickness + properties (list): Properties for Circular Thickness Definition (See Below) comment (str, optional): Comments params (dict, optional): Parameters + + properties = [thickness_circle_center_dC, thickness_circle_line_dR] ''' # Client model | Thickness @@ -348,15 +361,17 @@ def Layers(self, params: dict = {}): ''' - Available only for Special Solution Add-on Multilayer Surfaces. + NOTE: Available only for Special Solution Add-on Multilayer Surfaces. Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - properties (list): [[thickness_type, material, thickness, rotation, comment], ...] + material_no (int): Tag of Material assigned to Thickness + properties (list): Nested List of Layer Properties (See Below) comment (str, optional): Comments params (dict, optional): Parameters + + properties: [[thickness_type, material, thickness, rotation, comment], ...] ''' # Check if Multilayer Surfaces Add-on is ON. @@ -424,37 +439,35 @@ def ShapeOrthotropy(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number + material_no (int): Tag of Material assigned to Thickness orthotropy_type (enum): Thickness Orthotropy Type - - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_EFFECTIVE_THICKNESS: - parameters = [effective_thickness_x, effective_thickness_y] - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_COUPLING: - parameters = [coupling_thickness, coupling_spacing, coupling_width] - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_UNIDIRECTIONAL_RIBBED_PLATE: - parameters = [slab_thickness, rib_height, rib_spacing, rib_width] - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_BIDIRECTIONAL_RIBBED_PLATE: - parameters = [slab_thickness, rib_height_x, rib_height_y, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_TRAPEZOIDAL_SHEET: - parameters = [sheet_thickness, total_profile_height, rib_spacing, top_flange_width, bottom_flange_width] - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_HOLLOW_CORE_SLAB: - parameters = [slab_thickness, void_spacing, void_diameter] - For ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_GRILLAGE: - parameters = [slab_thickness, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] - - rotation_beta (float): - consideration_of_self_weight (list): - - For parameter defined self-weight: - consideration_of_self_weight : [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, fictitious_thickness] - For user-defined fictitious thickness self-weight: - consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, fictitious_thickness] - For user-defined self-weight: - consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_WEIGHT, self_weight] - - parameters (list): + rotation_beta (float): Rotation + consideration_of_self_weight (list): Consideration of Self-Weight Parameters + parameters (list): Parameters List of chosen Orthotropy Type comment (str, optional): Comments params (dict, optional): Parameters + + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_EFFECTIVE_THICKNESS: + parameters = [effective_thickness_x, effective_thickness_y] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_COUPLING: + parameters = [coupling_thickness, coupling_spacing, coupling_width] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_UNIDIRECTIONAL_RIBBED_PLATE: + parameters = [slab_thickness, rib_height, rib_spacing, rib_width] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_BIDIRECTIONAL_RIBBED_PLATE: + parameters = [slab_thickness, rib_height_x, rib_height_y, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_TRAPEZOIDAL_SHEET: + parameters = [sheet_thickness, total_profile_height, rib_spacing, top_flange_width, bottom_flange_width] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_HOLLOW_CORE_SLAB: + parameters = [slab_thickness, void_spacing, void_diameter] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_GRILLAGE: + parameters = [slab_thickness, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] + + for consideration_of_self_weight == 'parameter defined' + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, fictitious_thickness] + for consideration_of_self_weight == 'user-defined fictitious thickness' + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, fictitious_thickness] + for consideration_of_self_weight == 'user-defined' + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_WEIGHT, self_weight] ''' # Client model | Thickness @@ -569,31 +582,30 @@ def StiffnessMatrix(self, Args: no (int): Thickness Tag name (str): Thickness Name - material_no (int): Assigned Material Number - rotation_beta (float) - consideration_of_self_weight (list): - - For fictitious thickness and bulk density self-weight: - consideration_of_self_weight : [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY, fictitious_thickness, stiffness_matrix_bulk_density] - For fictitious thickness and area density self-weight: - consideration_of_self_weight : [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY, stiffness_matrix_bulk_density, stiffness_matrix_area_density] - For bulk density and area density self-weight: - consideration_of_self_weight : [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_BULK_DENSITY_AND_AREA_DENSITY, fictitious_thickness, stiffness_matrix_area_density] - + material_no (int): Tag of Material assigned to Thickness + rotation_beta (float): Rotation + consideration_of_self_weight (list): Self-Weight Consideration Parameters coefficient_of_thermal_expansion (float): Coefficient of Thermal Expansion - stiffness_matrix (list): + stiffness_matrix (list): Nested List of Stiffness Matrix Entries (See Below) + comment (str, optional): Comments + params (dict, optional): Parameters + + for consideration_of_self_weight == 'fictitious thickness and bulk density' + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY, fictitious_thickness, stiffness_matrix_bulk_density] + for consideration_of_self_weight == 'fictitious thickness and area density' + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY, stiffness_matrix_bulk_density, stiffness_matrix_area_density] + for consideration_of_self_weight == 'bulk density and area density' + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_BULK_DENSITY_AND_AREA_DENSITY, fictitious_thickness, stiffness_matrix_area_density] + stiffness_matrix: Element entry overview : [[Bending/Torsional Stiffness Elements (Nm)], - [Shear Stiffness Elements (N/m)], - [Membrane Stiffness Elements (N/m)], - [Eccentric Stiffness Elements (Nm/m)]] + [Shear Stiffness Elements (N/m)], + [Membrane Stiffness Elements (N/m)], + [Eccentric Stiffness Elements (Nm/m)]] Detailed element entry : [[D11, D12, D13, D22, D23, D33], - [D44, D45, D55], - [D66, D67, D68, D77, D78, D88], - [D16, D17, D18, D27, D28, D38]] - - comment (str, optional): Comments - params (dict, optional): Parameters + [D44, D45, D55], + [D66, D67, D68, D77, D78, D88], + [D16, D17, D18, D27, D28, D38]] ''' # Client model | Thickness From bb7370f2e62c387f1437e253cacd6e5131c3f49d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Fri, 14 Jan 2022 17:03:22 +0100 Subject: [PATCH 2/7] DocStrings Update: BasicObjects Remove Test File --- DocStrings - Bjoern Pruefungen.py | 18 ------------------ 1 file changed, 18 deletions(-) delete mode 100644 DocStrings - Bjoern Pruefungen.py diff --git a/DocStrings - Bjoern Pruefungen.py b/DocStrings - Bjoern Pruefungen.py deleted file mode 100644 index bd763e4b..00000000 --- a/DocStrings - Bjoern Pruefungen.py +++ /dev/null @@ -1,18 +0,0 @@ -from RFEM.initModel import * -from RFEM.enums import * -from RFEM.BasicObjects.node import * -from RFEM.BasicObjects.line import * - -Model(False) -Model.clientModel.service.begin_modification('new') - -Node(1, 0, 0, 0) -Node(2, 0, -5, 0) -Node(3, 0, 5, 0) -Node(4, 5, 0, 0) - -Line.Circle(1, 1, '2', [0,0,0], 5) -Line.Circle(1, 2, '3', [0,10,0], 5, [0,1,0]) -Line.Circle(1, 3, '1', [0,10,0], 10) - -Model.clientModel.service.finish_modification() \ No newline at end of file From f2b10405d0a67258b7810d6000e2508292110209 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Fri, 14 Jan 2022 17:05:38 +0100 Subject: [PATCH 3/7] DocStrings Update: BasicObjects Uncommented changes to Example Cantilever --- Examples/Cantilever/Demo1.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/Examples/Cantilever/Demo1.py b/Examples/Cantilever/Demo1.py index 80f78941..9a842f77 100644 --- a/Examples/Cantilever/Demo1.py +++ b/Examples/Cantilever/Demo1.py @@ -39,29 +39,29 @@ NodalSupport(1, '1', NodalSupportType.FIXED) StaticAnalysisSettings.GeometricallyLinear(0, 1, "Linear") - # StaticAnalysisSettings.SecondOrderPDelta(0, 2, "SecondOrder") - # StaticAnalysisSettings.LargeDeformation(0, 3, "LargeDeformation") + StaticAnalysisSettings.SecondOrderPDelta(0, 2, "SecondOrder") + StaticAnalysisSettings.LargeDeformation(0, 3, "LargeDeformation") LoadCase(1, 'Self-Weight', [True, 0.0, 0.0, 1.0]) NodalLoad(1, 1, '2', LoadDirectionType.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W, f*1000) Model.clientModel.service.finish_modification() - #Calculate_all() + Calculate_all() # model status - # modelStatus = Model.clientModel.service.get_model_info() - # print("Model is calculated" if modelStatus.property_has_results else "Model is not calculated") - # print("Model contains printout report" if modelStatus.property_has_printout_report else "Model has not printout report") - # print ("Model contains " + str(modelStatus.property_node_count) + " nodes") - # print ("Model contains " + str(modelStatus.property_line_count) + " lines") - # print ("Model contains " + str(modelStatus.property_member_count) + " members") - # print ("Model contains " + str(modelStatus.property_surface_count) + " surfaces") - # print ("Model contains " + str(modelStatus.property_solid_count) + " solids") - # print ("Model contains " + str(modelStatus.property_lc_count) + " load cases") - # print ("Model contains " + str(modelStatus.property_co_count) + " load combinations") - # print ("Model contains " + str(modelStatus.property_rc_count) + " result classes") - # print ("Model weight " + str(modelStatus.property_weight)) - # print ("Model dimension x " + str(modelStatus.property_dimensions.x)) - # print ("Model dimension y " + str(modelStatus.property_dimensions.y)) - # print ("Model dimension z " + str(modelStatus.property_dimensions.z)) + modelStatus = Model.clientModel.service.get_model_info() + print("Model is calculated" if modelStatus.property_has_results else "Model is not calculated") + print("Model contains printout report" if modelStatus.property_has_printout_report else "Model has not printout report") + print ("Model contains " + str(modelStatus.property_node_count) + " nodes") + print ("Model contains " + str(modelStatus.property_line_count) + " lines") + print ("Model contains " + str(modelStatus.property_member_count) + " members") + print ("Model contains " + str(modelStatus.property_surface_count) + " surfaces") + print ("Model contains " + str(modelStatus.property_solid_count) + " solids") + print ("Model contains " + str(modelStatus.property_lc_count) + " load cases") + print ("Model contains " + str(modelStatus.property_co_count) + " load combinations") + print ("Model contains " + str(modelStatus.property_rc_count) + " result classes") + print ("Model weight " + str(modelStatus.property_weight)) + print ("Model dimension x " + str(modelStatus.property_dimensions.x)) + print ("Model dimension y " + str(modelStatus.property_dimensions.y)) + print ("Model dimension z " + str(modelStatus.property_dimensions.z)) From b3819d944818241ca705c04541601caa05aa0750 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Fri, 14 Jan 2022 17:40:18 +0100 Subject: [PATCH 4/7] DocStrings Update: BasicObjects --- RFEM/BasicObjects/member.py | 336 ++++++++++++++++----------------- RFEM/BasicObjects/node.py | 10 +- RFEM/BasicObjects/surface.py | 72 +++---- RFEM/BasicObjects/thickness.py | 84 ++++----- 4 files changed, 232 insertions(+), 270 deletions(-) diff --git a/RFEM/BasicObjects/member.py b/RFEM/BasicObjects/member.py index b25e621c..2d243fbc 100644 --- a/RFEM/BasicObjects/member.py +++ b/RFEM/BasicObjects/member.py @@ -98,44 +98,41 @@ def Beam(self, start_node_no (int): Tag of Start Node end_node_no (int): Tag of End Node section_distribution_type (enum): Section Distribution Type Enumeration + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: + distribution_parameters = [section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, + section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, + section_alignment, section_internal] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_SADDLE: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment, section_internal] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, + section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, + section_alignment, section_internal] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters; 1 or 2 params + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] start_section_no (int): Tag of Start Section end_section_no (int): End of End Section distribution_parameters (list): Distribution Parameters comment (str, optional): Comment params (dict, optional): Parameters - - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: - distribution_parameters[section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, - section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, - section_alignment, section_internal] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_SADDLE: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment, section_internal] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, - section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, - section_alignment, section_internal] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -351,17 +348,16 @@ def Rigid(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -470,7 +466,7 @@ def Rib(self, params (dict, optional): Parameters for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: - distribution_parameters[section_alignment] + distribution_parameters[section_alignment] BJÖRN: Where is this parameter used? """ # Client model | Member @@ -583,18 +579,17 @@ def Truss(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] section_no (int): Section Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -698,18 +693,17 @@ def TrussOnlyN(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] section_no (int): Section Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -813,18 +807,17 @@ def Tension(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] section_no (int): Section Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -928,18 +921,17 @@ def Compression(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] section_no (int): Section Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1043,18 +1035,17 @@ def Buckling(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] section_no (int): Section Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1156,18 +1147,17 @@ def Cable(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] section_no (int): Section Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1266,49 +1256,46 @@ def ResultBeam(self, section_distribution_type (enum): Section Distribution Type Enumeration rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] start_section_no (int): Tag of Start Section end_section_no (int): Tag of End Section distribution_parameters (list): Distribution Parameters + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: + distribution_parameters = [section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, + section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, + section_alignment, section_internal] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_SADDLE: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment, section_internal] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, + section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, + section_alignment, section_internal] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER: + distribution_parameters = [section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] integration_parameters (list): Integration Parameters + for result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CUBOID_QUADRATIC": + integration_parameters = [result_beam_y_z] + for result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CUBOID_GENERAL": + integration_parameters = [result_beam_y_plus, result_beam_z_plus, result_beam_y_minus, result_beam_z_minus] + for result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CYLINDER": + integration_parameters = [result_beam_radius] comment (str, optional): Comment params (dict, optional): Parameters - - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: - distribution_parameters[section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, - section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, - section_alignment, section_internal] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_SADDLE: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment, section_internal] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_end_is_defined_as_relative, - section_distance_from_start_relative/absolute, section_distance_from_end_relative/absolute, - section_alignment, section_internal] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER: - distribution_parameters[section_distance_from_start_is_defined_as_relative, section_distance_from_start_relative/absolute, section_alignment] - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] - - for result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CUBOID_QUADRATIC": - integration_parameters[result_beam_y_z] - for result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CUBOID_GENERAL": - integration_parameters[result_beam_y_plus, result_beam_z_plus, result_beam_y_minus, result_beam_z_minus] - for result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CYLINDER": - integration_parameters[result_beam_radius] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1515,18 +1502,17 @@ def DefinableStiffness(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] definable_stiffness (int): Definable Stiffness Tag comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1616,17 +1602,16 @@ def CouplingRigidRigid(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1692,17 +1677,16 @@ def CouplingRigidHinge(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1768,17 +1752,16 @@ def CouplingHingeRigid(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') @@ -1844,17 +1827,16 @@ def CouplingHingeHinge(self, end_node_no (int): Tag of End Node rotation_specification_type (enum): Rotation Specification Type Enumeration rotation_parameters (list): Rotation Parameters + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + rotation_parameters = [rotation_angle] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + rotation_parameters = [rotation_help_node, rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + rotation_parameters = [rotation_plane_type] + for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + rotation_parameters = [rotation_surface, rotation_surface_plane_type] comment (str, optional): Comment params (dict, optional): Parameters - - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: - rotation_parameters[rotation_angle] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: - rotation_parameters[rotation_help_node, rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: - rotation_parameters[rotation_plane_type] - for rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: - rotation_parameters[rotation_surface, rotation_surface_plane_type] """ # Client model | Member clientObject = Model.clientModel.factory.create('ns0:member') diff --git a/RFEM/BasicObjects/node.py b/RFEM/BasicObjects/node.py index 6c3c7e22..3676be77 100644 --- a/RFEM/BasicObjects/node.py +++ b/RFEM/BasicObjects/node.py @@ -57,15 +57,15 @@ def Standard(self, Args: no (int): Node Tag coordinate_system (list): Coordinate System - For coordinate_system_type = NodeCoordinateSystemType.COORDINATE_SYSTEM_CARTESIAN; + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_CARTESIAN; coordinate_system = [X, Y, Z] - For coordinate_system_type = NodeCoordinateSystemType.COORDINATE_SYSTEM_X_CYLINDRICAL; + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_X_CYLINDRICAL; coordinate_system = [X, R, θ] - For coordinate_system_type = NodeCoordinateSystemType.COORDINATE_SYSTEM_Y_CYLINDRICAL; + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_Y_CYLINDRICAL; coordinate_system = [R, Ύ, θ] - For coordinate_system_type = NodeCoordinateSystemType.COORDINATE_SYSTEM_Z_CYLINDRICAL; + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_Z_CYLINDRICAL; coordinate_system = [R, θ, Z] - For coordinate_system_type = NodeCoordinateSystemType.COORDINATE_SYSTEM_POLAR: + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_POLAR: coordinate_system = [R, θ, φ] coordinate_system_type (enum): Coordinate System Type Enumeration comment (str, optional): Comments diff --git a/RFEM/BasicObjects/surface.py b/RFEM/BasicObjects/surface.py index c8658fe2..49bbabe9 100644 --- a/RFEM/BasicObjects/surface.py +++ b/RFEM/BasicObjects/surface.py @@ -57,17 +57,16 @@ def Standard(self, no (int): Surface Tag geometry_type (enum): Surface Geometry Type Enumeration geometry_type_parameters (list): Geometry Type Parameters + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: + geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: + geometry_type_parameters = None + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: + geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] boundary_lines_no (str): Tags of Lines defining Standard Surface thickness (int): Tag of Thickness assigned to Standard Surface comment (str, optional): Comments params (dict, optional): Parameters - - for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: - geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: - geometry_type_parameters = None - for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: - geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' # Client model | Surface @@ -106,16 +105,15 @@ def WithoutThickness(self, no (int): Surface Tag geometry_type (enum): Surface Geometry Type Enumeration geometry_type_parameters (list): Geometry Type Parameters + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: + geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: + geometry_type_parameters = None + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: + geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] boundary_lines_no (str): Tags of Lines defining Without Thickness Surface comment (str, optional): Comments params (dict, optional): Parameters - - for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: - geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: - geometry_type_parameters = None - for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: - geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' # Client model | Surface @@ -153,16 +151,15 @@ def Rigid(self, no (int): Surface Tag geometry_type (enum): Surface Geometry Type Enumeration geometry_type_parameters (list): Geometry Type Parameters + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: + geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: + geometry_type_parameters = None + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: + geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] boundary_lines_no (str): Tags of Lines defining Rigid Surface comment (str, optional): Comments params (dict, optional): Parameters - - for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: - geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: - geometry_type_parameters = None - for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: - geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' # Client model | Surface @@ -201,17 +198,16 @@ def Membrane(self, no (int): Surface Tag geometry_type (enum): Surface Geometry Type Enumeration geometry_type_parameters (list): Geometry Type Parameters + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: + geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: + geometry_type_parameters = None + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: + geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] boundary_lines_no (str): Tags of Lines defining Membrane Surface thickness (int): Tag of Thickness assigned to Membrane Surface comment (str, optional): Comments params (dict, optional): Parameters - - for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: - geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: - geometry_type_parameters = None - for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: - geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' # Client model | Surface @@ -251,17 +247,16 @@ def WithoutMemberaneTension(self, no (int): Surface Tag geometry_type (enum): Surface Geometry Type Enumeration geometry_type_parameters (list): Geometry Type Parameters + for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: + geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] + for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: + geometry_type_parameters = None + for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: + geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] boundary_lines_no (str): Tags of Lines defining Without Membrane Tension Surface thickness (int): Tag of Thickness assigned to Without Membrane Tension Surface comment (str, optional): Comments params (dict, optional): Parameters - - for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: - geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: - geometry_type_parameters = None - for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: - geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' # Client model | Surface @@ -317,13 +312,6 @@ def LoadDistribution(self, loaded_lines (str): Tag of Loaded Lines comment (str, optional): Comments params (dict, optional): Parameters - - for geometry_type == SurfaceGeometry.GEOMETRY_NURBS: - geometry_type_parameters = [nurbs_control_point_count_in_direction_u, nurbs_control_point_count_in_direction_v, nurbs_order_in_direction_u, nurbs_order_in_direction_v] - for geometry_type == SurfaceGeometry.GEOMETRY_PLANE: - geometry_type_parameters = None - for geometry_type == SurfaceGeometry.GEOMETRY_QUADRANGLE: - geometry_type_parameters = [quadrangle_corner_node_1, quadrangle_corner_node_2, quadrangle_corner_node_3, quadrangle_corner_node_4] ''' # Client model | Surface diff --git a/RFEM/BasicObjects/thickness.py b/RFEM/BasicObjects/thickness.py index 54c564b4..32d69506 100644 --- a/RFEM/BasicObjects/thickness.py +++ b/RFEM/BasicObjects/thickness.py @@ -123,11 +123,10 @@ def Variable_3Nodes(self, no (int): Thickness Tag name (str): Thickness Name material_no (int): Tag of Material assigned to Thickness - properties (list): Properties for 3 Nodes Variable Thickness Definition (See Below) + properties (list): Properties for 3 Nodes Variable Thickness Definition + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3] comment (str, optional): Comments params (dict, optional): Parameters - - properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3] ''' # Client model | Thickness @@ -185,11 +184,11 @@ def Variable_2NodesAndDirection(self, no (int): Thickness Tag name (str): Thickness Name material_no (int): Tag of Material assigned to Thickness - properties (list): Properties for 2 Nodes and Direction Variable Thickness Definition (See Below) + properties (list): Properties for 2 Nodes and Direction Variable Thickness Definition + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, direction] comment (str, optional): Comments params (dict, optional): Parameters - properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, direction] ''' # Client model | Thickness @@ -244,11 +243,11 @@ def Variable_4SurfaceCorners(self, no (int): Thickness Tag name (str): Thickness Name material_no (int): Tag of Material assigned to Thickness - properties (list): Properties for 4 Surface Corners Variable Definition (See Below) + properties (list): Properties for 4 Surface Corners Variable Definition + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3, thickness_d4, node_no_4] comment (str, optional): Comments params (dict, optional): Parameters - properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3, thickness_d4, node_no_4] ''' # Client model | Thickness @@ -308,11 +307,10 @@ def Variable_Circle(self, no (int): Thickness Tag name (str): Thickness Name material_no (int): Tag of Material assigned to Thickness - properties (list): Properties for Circular Thickness Definition (See Below) + properties (list): Properties for Circular Thickness Definition + properties = [thickness_circle_center_dC, thickness_circle_line_dR] comment (str, optional): Comments params (dict, optional): Parameters - - properties = [thickness_circle_center_dC, thickness_circle_line_dR] ''' # Client model | Thickness @@ -367,11 +365,10 @@ def Layers(self, no (int): Thickness Tag name (str): Thickness Name material_no (int): Tag of Material assigned to Thickness - properties (list): Nested List of Layer Properties (See Below) + properties (list): Nested List of Layer Properties + properties: [[thickness_type, material, thickness, rotation, comment], ...] comment (str, optional): Comments params (dict, optional): Parameters - - properties: [[thickness_type, material, thickness, rotation, comment], ...] ''' # Check if Multilayer Surfaces Add-on is ON. @@ -443,31 +440,29 @@ def ShapeOrthotropy(self, orthotropy_type (enum): Thickness Orthotropy Type rotation_beta (float): Rotation consideration_of_self_weight (list): Consideration of Self-Weight Parameters + for consideration_of_self_weight == 'parameter defined' + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, fictitious_thickness] + for consideration_of_self_weight == 'user-defined fictitious thickness' + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, fictitious_thickness] + for consideration_of_self_weight == 'user-defined' + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_WEIGHT, self_weight] parameters (list): Parameters List of chosen Orthotropy Type + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_EFFECTIVE_THICKNESS: + parameters = [effective_thickness_x, effective_thickness_y] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_COUPLING: + parameters = [coupling_thickness, coupling_spacing, coupling_width] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_UNIDIRECTIONAL_RIBBED_PLATE: + parameters = [slab_thickness, rib_height, rib_spacing, rib_width] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_BIDIRECTIONAL_RIBBED_PLATE: + parameters = [slab_thickness, rib_height_x, rib_height_y, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_TRAPEZOIDAL_SHEET: + parameters = [sheet_thickness, total_profile_height, rib_spacing, top_flange_width, bottom_flange_width] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_HOLLOW_CORE_SLAB: + parameters = [slab_thickness, void_spacing, void_diameter] + for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_GRILLAGE: + parameters = [slab_thickness, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] comment (str, optional): Comments params (dict, optional): Parameters - - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_EFFECTIVE_THICKNESS: - parameters = [effective_thickness_x, effective_thickness_y] - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_COUPLING: - parameters = [coupling_thickness, coupling_spacing, coupling_width] - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_UNIDIRECTIONAL_RIBBED_PLATE: - parameters = [slab_thickness, rib_height, rib_spacing, rib_width] - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_BIDIRECTIONAL_RIBBED_PLATE: - parameters = [slab_thickness, rib_height_x, rib_height_y, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_TRAPEZOIDAL_SHEET: - parameters = [sheet_thickness, total_profile_height, rib_spacing, top_flange_width, bottom_flange_width] - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_HOLLOW_CORE_SLAB: - parameters = [slab_thickness, void_spacing, void_diameter] - for orthotropy_type == ThicknessOrthotropyType.ORTHOTROPIC_THICKNESS_TYPE_GRILLAGE: - parameters = [slab_thickness, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] - - for consideration_of_self_weight == 'parameter defined' - consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, fictitious_thickness] - for consideration_of_self_weight == 'user-defined fictitious thickness' - consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, fictitious_thickness] - for consideration_of_self_weight == 'user-defined' - consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_DEFINED_VIA_WEIGHT, self_weight] ''' # Client model | Thickness @@ -585,19 +580,14 @@ def StiffnessMatrix(self, material_no (int): Tag of Material assigned to Thickness rotation_beta (float): Rotation consideration_of_self_weight (list): Self-Weight Consideration Parameters + for consideration_of_self_weight == 'fictitious thickness and bulk density' + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY, fictitious_thickness, stiffness_matrix_bulk_density] + for consideration_of_self_weight == 'fictitious thickness and area density' + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY, stiffness_matrix_bulk_density, stiffness_matrix_area_density] + for consideration_of_self_weight == 'bulk density and area density' + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_BULK_DENSITY_AND_AREA_DENSITY, fictitious_thickness, stiffness_matrix_area_density] coefficient_of_thermal_expansion (float): Coefficient of Thermal Expansion stiffness_matrix (list): Nested List of Stiffness Matrix Entries (See Below) - comment (str, optional): Comments - params (dict, optional): Parameters - - for consideration_of_self_weight == 'fictitious thickness and bulk density' - consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY, fictitious_thickness, stiffness_matrix_bulk_density] - for consideration_of_self_weight == 'fictitious thickness and area density' - consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY, stiffness_matrix_bulk_density, stiffness_matrix_area_density] - for consideration_of_self_weight == 'bulk density and area density' - consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_BULK_DENSITY_AND_AREA_DENSITY, fictitious_thickness, stiffness_matrix_area_density] - - stiffness_matrix: Element entry overview : [[Bending/Torsional Stiffness Elements (Nm)], [Shear Stiffness Elements (N/m)], [Membrane Stiffness Elements (N/m)], @@ -606,6 +596,8 @@ def StiffnessMatrix(self, [D44, D45, D55], [D66, D67, D68, D77, D78, D88], [D16, D17, D18, D27, D28, D38]] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Thickness From b5d2ea500bf682f71cda9f46c50456b210422d27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Fri, 14 Jan 2022 17:42:57 +0100 Subject: [PATCH 5/7] DocStrings Update: Imperfections --- RFEM/Imperfections/imperfectionCase.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/RFEM/Imperfections/imperfectionCase.py b/RFEM/Imperfections/imperfectionCase.py index a330d54a..663a3df4 100644 --- a/RFEM/Imperfections/imperfectionCase.py +++ b/RFEM/Imperfections/imperfectionCase.py @@ -6,6 +6,13 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Imperfection Case Tag + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Imperfection Case clientObject = Model.clientModel.factory.create('ns0:imperfection_case') From d7449767ee53fb305dbd1b22eab197d75ea4dffa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Fri, 14 Jan 2022 18:18:46 +0100 Subject: [PATCH 6/7] DocStrings Update: LoadCasesAndCombinations --- .../designSituation.py | 3 - RFEM/LoadCasesAndCombinations/loadCase.py | 17 ++- .../resultCombination.py | 7 + .../spectralAnalysisSettings.py | 18 ++- .../stabilityAnalysisSettings.py | 133 +++++++++--------- .../staticAnalysisSettings.py | 70 ++++----- 6 files changed, 139 insertions(+), 109 deletions(-) diff --git a/RFEM/LoadCasesAndCombinations/designSituation.py b/RFEM/LoadCasesAndCombinations/designSituation.py index c535c736..6397f2cd 100644 --- a/RFEM/LoadCasesAndCombinations/designSituation.py +++ b/RFEM/LoadCasesAndCombinations/designSituation.py @@ -17,7 +17,6 @@ def __init__(self, name (str, optional): User-Defined Name (Applicable when user_defined_name = TRUE) active (bool): Enable/Disable Design Situation Activity design_situation_type (int): Design Situation Numeric Code (Variable key inputs, dependant on Standards defined in the model) - Applicable to Standard Group EN 1990 with National Annex CEN | 2010-04 (See Model Base Data > Standards I) 6122 = ULS (EQU) - Permanent and transient, 6993 = ULS (EQU) - Accidental - psi-1,1, @@ -31,7 +30,6 @@ def __init__(self, 6193 = SLS - Characteristic, 6194 = SLS - Frequent, 6195 = SLS - Quasi-permanent. - Applicable to Standard Group EN 1990 with National Annex DIN | 2012-08 (See Model Base Data > Standards I) 6122 = ULS (EQU) - Permanent and transient, 6993 = ULS (EQU) - Accidental - psi-1,1, @@ -48,7 +46,6 @@ def __init__(self, 6193 = SLS - Characteristic, 6194 = SLS - Frequent, 6195 = SLS - Quasi-permanent. - comment (str, optional): Comments params (dict, optional): Parameters """ diff --git a/RFEM/LoadCasesAndCombinations/loadCase.py b/RFEM/LoadCasesAndCombinations/loadCase.py index b8954526..1ec51020 100644 --- a/RFEM/LoadCasesAndCombinations/loadCase.py +++ b/RFEM/LoadCasesAndCombinations/loadCase.py @@ -14,14 +14,17 @@ class LoadCase(): def __init__(self, no: int = 1, name: str = 'Self-weight', - self_weight = [True, 0.0, 0.0, 1.0], + self_weight: list = [True, 0.0, 0.0, 1.0], comment: str = 'Comment', params: dict = {}): ''' - Creates a default load case with no further options. - Analysis type is static by default. - Static analysis settings defaults to 1. - Action category is Permanent | G by default. + Args: + no (int): Load Case Tag + name (str): Load Case Name + self_weight (list): Self-Weight Parameters + self_weight = [self_weight_active, self_weight_factor_x, self_weight_factor_y, self_weight_factor_z] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Load Case @@ -109,9 +112,9 @@ def StaticAnalysis(self, 10 = Seismic actions | AE None = None | None self_weight (list): Self-weight Considerations - For self-weight considerations; + for self-weight considerations; self_weight = [True, self_weight_factor_x, self_weight_factor_y, self_weight_factor_z] - For no self-weight considerations; + for no self-weight considerations; self_weight = [False] comment (str, optional): Comments params (dict, optional): Parameters diff --git a/RFEM/LoadCasesAndCombinations/resultCombination.py b/RFEM/LoadCasesAndCombinations/resultCombination.py index e4aec621..acfb1273 100644 --- a/RFEM/LoadCasesAndCombinations/resultCombination.py +++ b/RFEM/LoadCasesAndCombinations/resultCombination.py @@ -6,6 +6,13 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Result Combination Tag + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Result Combination clientObject = Model.clientModel.factory.create('ns0:result_combination') diff --git a/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py b/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py index 6cb471dd..691a29f4 100644 --- a/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py +++ b/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py @@ -16,6 +16,22 @@ def __init__(self, comment: str = '', params: dict = {}): + ''' + Args: + no (int): Sprectral Analysis Settings Tag + name (str): Sprectral Analysis Settings Name + periodic_combination (enum): Periodic Combination Rule Enumeration + directional_combination (enum): Directional Component Combination Rule Enumeration + equivalent_linear_combination (bool): Equivalent Linear Combination Boolean + save_mode_results (bool): Save Mode Results Boolean + signed_dominant_mode_results (bool): Signed Dominant Mode Results Boolean + directional_component_scale_value (float): Directional Component Scale Value + damping_for_cqc_rule (enum): Cqs Damping Rule Enumeration + constant_d_for_each_mode (float): Constant d for Each Mode + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Surface clientObject = Model.clientModel.factory.create('ns0:spectral_analysis_settings') @@ -48,7 +64,7 @@ def __init__(self, if directional_combination == DirectionalComponentCombinationRule.SCALED_SUM: pass else: - raise "WARNING: Signed results using dominant mode is only available with Scaled Sum Directional Combination!" + raise "WARNING: Signed results using dominant mode is only available with Scaled Sum Directional Combination." # Further Options if directional_combination == DirectionalComponentCombinationRule.SCALED_SUM: diff --git a/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py b/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py index 47f704f0..3df60f89 100644 --- a/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py +++ b/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py @@ -10,10 +10,11 @@ def __init__(self, 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. + Args: + no (int): Stability Analysis Setting Tag + name (str): Stability Analysis Setting Name + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Stability Analysis Settings @@ -66,24 +67,24 @@ def EigenvalueMethod(self, params: dict = {}): ''' Args: - no (int): - name (str, optional): Stability Analysis Name + no (int): Stability Analysis Setting Tag + name (str, optional): Stability Analysis Setting 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: + for find_eigenvectors_beyond_critical_load_factor == False: critical_load_factor = None - For find_eigenvectors_beyond_critical_load_factor == True: + for find_eigenvectors_beyond_critical_load_factor == True: critical_load_factor = int minimum_initial_strain (optional): - For minimum initial strain application: + for minimum initial strain application: minimum_initial_strain != 0 or minimum_initial_strain is not None - For no minimum initial strain application: + for no minimum initial strain application: minimum_initial_strain == 0 or minimum_initial_strain is None local_torsional_rotations (optional): - For no local torsional rotations display: + for no local torsional rotations display: local_torsional_rotations = None - For local torsional rotations display: + for local torsional rotations display: local_torsional_rotations = double eigenvalue_method (enum): Eigenvalue Method Enumeration matrix_type (enum): Matrix Type Enumeration @@ -162,50 +163,50 @@ def IncrementalyMethodWithEigenvalue(self, params: dict = {}): ''' Args: - no (int): - name (str, optional): Stability Analysis Name + no (int): Stability Analysis Setting Tag + name (str, optional): Stability Analysis Setting 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: + for find_eigenvectors_beyond_critical_load_factor == False: critical_load_factor = None - For find_eigenvectors_beyond_critical_load_factor == True: + for find_eigenvectors_beyond_critical_load_factor == True: critical_load_factor = int minimum_initial_strain (optional): - For minimum initial strain application: + for minimum initial strain application: minimum_initial_strain != 0 or minimum_initial_strain is not None - For no minimum initial strain application: + for no minimum initial strain application: minimum_initial_strain is None local_torsional_rotations (optional): - For no local torsional rotations display: + for no local torsional rotations display: local_torsional_rotations = None - For local torsional rotations display: + 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] + 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): + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Stability Analysis Settings clientObject = Model.clientModel.factory.create('ns0:stability_analysis_settings') @@ -297,41 +298,41 @@ def IncrementalyMethodWithoutEigenvalue(self, params: dict = {}): ''' Args: - no (int): - name (str, optional): Stability Analysis Name + no (int): Stability Analysis Setting Tag + name (str, optional): Stability Analysis Setting Name minimum_initial_strain (optional): - For minimum initial strain application: + for minimum initial strain application: minimum_initial_strain != 0 or minimum_initial_strain is not None - For no minimum initial strain application: + for no minimum initial strain application: minimum_initial_strain == 0 or minimum_initial_strain is None local_torsional_rotations (optional): - For no local torsional rotations display: + for no local torsional rotations display: local_torsional_rotations = None - For local torsional rotations display: + 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] + 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): + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Stability Analysis Settings clientObject = Model.clientModel.factory.create('ns0:stability_analysis_settings') diff --git a/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py b/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py index 6bb82e5f..38b8e3df 100644 --- a/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py +++ b/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py @@ -13,8 +13,8 @@ def __init__(self, params: dict = {}): """ Args: - no (int): Setting Tag - name (str): Setting Name + no (int): Static Analysis Setting Tag + name (str): Static Analysis Setting Name analysis_type (enum): Analysis Type Enumeration comment (str): Comments params (dict): Parameters @@ -59,14 +59,16 @@ def GeometricallyLinear(self, """ Args: - no (int): - name (str, optional): Static Analysis Name - load_modification (list, optional): [loading_by_multiplier_factor, multiplier_factor, dividing_results] - bourdon_effect (bool, optional): - nonsymmetric_direct_solver (bool, optional): + no (int): Static Analysis Setting Tag + name (str, optional): Static Analysis Setting Name + load_modification (list, optional): Load Modification Parameters + load_modification = [loading_by_multiplier_factor, multiplier_factor, dividing_results] + bourdon_effect (bool, optional): Bourdon Effect Boolean + nonsymmetric_direct_solver (bool, optional): Nonsymmetric Direct Solver Boolean method_of_equation_system (enum): Static Analysis Settings Method of Equation System Enumeration plate_bending_theory (enum): Static Analysis Settings Plate Bending Theory Enumeration - mass_conversion (list, optional): [mass_conversion_enabled, mass_conversion_factor_in_direction_x, mass_conversion_factor_in_direction_y, mass_conversion_factor_in_direction_z] + mass_conversion (list, optional): Mass Conversion Parameters + mass_conversion = [mass_conversion_enabled, mass_conversion_factor_in_direction_x, mass_conversion_factor_in_direction_y, mass_conversion_factor_in_direction_z] comment (str, optional): params (dict, optional): """ @@ -169,26 +171,26 @@ def LargeDeformation(self, """ Args: - no (int): - name (str, optional): Static Analysis Name + no (int): Static Analysis Setting Tag + name (str, optional): Static Analysis Setting Name iterative_method (enum): Static Analysis Settings Iterative Method for Non-linear Analysis Enumeration - For iterative_method == "NEWTON_RAPHSON" or iterative_method.name == "NEWTON_RAPHSON_COMBINED_WITH_PICARD" or iterative_method.name == "PICARD" or iterative_method.name == "NEWTON_RAPHSON_WITH_POSTCRITICAL_ANALYSIS" - max_number_of_iterations = int - number_of_load_increments = int - For iterative_method == "DYNAMIC_RELAXATION": - max_number_of_iterations = None - number_of_load_increments = None standard_precision_and_tolerance_settings (list, optional): [standard_precision_and_tolerance_settings_enabled, precision_of_convergence_criteria_for_nonlinear_calculation, tolerance_for_detection_of_instability, robustness_of_iterative_calculation] control_nonlinear_analysis (list): [max_number_of_iterations, number_of_load_increments] - load_modification (list, optional): [loading_by_multiplier_factor, multiplier_factor, dividing_results] - instabil_structure_calculation (bool, optional): - bourdon_effect (bool, optional): - nonsymmetric_direct_solver (bool, optional): + for iterative_method == "NEWTON_RAPHSON" or iterative_method.name == "NEWTON_RAPHSON_COMBINED_WITH_PICARD" or iterative_method.name == "PICARD" or iterative_method.name == "NEWTON_RAPHSON_WITH_POSTCRITICAL_ANALYSIS": + control_nonlinear_analysis = [max_number_of_iterations = int, number_of_load_increments = int] + for iterative_method == "DYNAMIC_RELAXATION": + control_nonlinear_analysis = [max_number_of_iterations = None, number_of_load_increments = None] + load_modification (list, optional): Load Modification Parameters + load_modification = [loading_by_multiplier_factor, multiplier_factor, dividing_results] + instabil_structure_calculation (bool, optional): Instabil Structure Calculation Boolean + bourdon_effect (bool, optional): Bourdon Effect Boolean + nonsymmetric_direct_solver (bool, optional): Nonsymmetric Direct Solver Boolean method_of_equation_system (enum): Static Analysis Settings Method of Equation System Enumeration plate_bending_theory (enum): Static Analysis Settings Plate Bending Theory Enumeration - mass_conversion (list, optional): [mass_conversion_enabled, mass_conversion_factor_in_direction_x, mass_conversion_factor_in_direction_y, mass_conversion_factor_in_direction_z] - comment (str, optional): - params (dict, optional): + mass_conversion (list, optional): Mass Conversion Parameters + mass_conversion = [mass_conversion_enabled, mass_conversion_factor_in_direction_x, mass_conversion_factor_in_direction_y, mass_conversion_factor_in_direction_z] + comment (str, optional): Comments + params (dict, optional): Parameters """ # Client model @@ -337,18 +339,22 @@ def SecondOrderPDelta(self, params: dict = {}): """ Args: - no (int): - name (str, optional): Static Analysis Name + no (int): Static Analysis Setting Tag + name (str, optional): Static Analysis Setting Name iterative_method (enum): Static Analysis Settings Iterative Method for Non-linear Analysis Enumeration - standard_precision_and_tolerance_settings (list, optional): [standard_precision_and_tolerance_settings_enabled, precision_of_convergence_criteria_for_nonlinear_calculation, tolerance_for_detection_of_instability, robustness_of_iterative_calculation] - control_nonlinear_analysis (list): [max_number_of_iterations, number_of_load_increments] - favorable_effect_due_to_tension_in_members (bool, optional): - bourdon_effect (bool, optional): - nonsymmetric_direct_solver (bool, optional): - internal_forces_to_deformed_structure (list, optional): [refer_internal_forces_to_deformed_structure, internal_forces_to_deformed_structure_for_moments, internal_forces_to_deformed_structure_for_normal_forces, internal_forces_to_deformed_structure_for_shear_forces] + standard_precision_and_tolerance_settings (list, optional): [Standard Precision and Tolerance Settings List + standard_precision_and_tolerance_settings = [standard_precision_and_tolerance_settings_enabled, precision_of_convergence_criteria_for_nonlinear_calculation, tolerance_for_detection_of_instability, robustness_of_iterative_calculation] + control_nonlinear_analysis (list): Nonlinear Analysis Control Parameters + control_nonlinear_analysis = [max_number_of_iterations, number_of_load_increments] + favorable_effect_due_to_tension_in_members (bool, optional): Favorable Effect due to Tension In Members Boolean + bourdon_effect (bool, optional): Bourdon Effect Boolean + nonsymmetric_direct_solver (bool, optional): Nonsymmetric Direct Solver Boolean + internal_forces_to_deformed_structure (list, optional): Internal Forces to Deformed Structure List + internal_forces_to_deformed_structure = [refer_internal_forces_to_deformed_structure, internal_forces_to_deformed_structure_for_moments, internal_forces_to_deformed_structure_for_normal_forces, internal_forces_to_deformed_structure_for_shear_forces] method_of_equation_system (enum): Static Analysis Settings Method of Equation System Enumeration plate_bending_theory (enum): Static Analysis Settings Plate Bending Theory Enumeration - mass_conversion (list, optional): [mass_conversion_enabled, mass_conversion_factor_in_direction_x, mass_conversion_factor_in_direction_y, mass_conversion_factor_in_direction_z] + mass_conversion (list, optional): Mass Conversion Parameters + mass_conversion = [mass_conversion_enabled, mass_conversion_factor_in_direction_x, mass_conversion_factor_in_direction_y, mass_conversion_factor_in_direction_z] comment (str, optional): params (dict, optional): """ From d41634dfc1e199c09372cc525b289d5a9c03d425 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Steinhagen?= Date: Mon, 17 Jan 2022 15:37:51 +0100 Subject: [PATCH 7/7] DocStrings Update: Loads (free, line and member) --- RFEM/BasicObjects/line.py | 12 +- RFEM/BasicObjects/solidSet.py | 8 +- RFEM/Loads/freeLoad.py | 167 +++++++++++-------- RFEM/Loads/lineLoad.py | 117 +++++++++---- RFEM/Loads/memberLoad.py | 305 +++++++++++++++++----------------- 5 files changed, 345 insertions(+), 264 deletions(-) diff --git a/RFEM/BasicObjects/line.py b/RFEM/BasicObjects/line.py index 56897495..fc68a495 100644 --- a/RFEM/BasicObjects/line.py +++ b/RFEM/BasicObjects/line.py @@ -79,7 +79,7 @@ def Polyline(self, def Arc(self, no: int = 1, - nodes_no: str = '1 2', + nodes_no: str = [1,2], control_point: list = [10,0,0], # X,Y,Z alpha_adjustment_target = LineArcAlphaAdjustmentTarget.ALPHA_ADJUSTMENT_TARGET_BEGINNING_OF_ARC, comment: str = '', @@ -88,7 +88,7 @@ def Arc(self, ''' Args: no (int): Line Tag - nodes_no (str): Nodes Defining Arc + nodes_no (list): Node Tags Defining Arc control_point (list): Control Point for Arc in [X, Y, Z] alpha_adjustment_target (enum): Line Arc Alpha Adjustment Target Enumeration comment (str, optional): Comments @@ -245,7 +245,7 @@ def EllipticalArc(self, def Ellipse(self, no: int = 1, - nodes_no: str = '1 2', + nodes_no: list = [5,10], ellipse_control_point: list = [18,-4.8,0], comment: str = '', params: dict = {}): @@ -253,7 +253,7 @@ def Ellipse(self, ''' Args: no (int): Line Tag - nodes_no (str): Node Tags on Line of Ellipse + nodes_no (list): Node Tags on Line of Ellipse ellipse_control_point (list): Ellipse Control Point [X, Y, Z] comment (str, optional): Comments params (dict, optional): Parameters @@ -293,7 +293,7 @@ def Ellipse(self, def Parabola(self, no: int = 1, - nodes_no: str = '1 2', + nodes_no: str = [3,8], parabola_control_point: list = [10,-3,0], parabola_alpha: float = 0, comment: str = '', @@ -302,7 +302,7 @@ def Parabola(self, ''' Args: no (int): Line Tag - nodes_no (str): Node Tags on Line of Parabola + nodes_no (list): Node Tags on Line of Parabola parabola_control_point (list): Parabola Control Point [X, Y, Z] parabola_alpha (float): Alpha Angle (in Radians) comment (str, optional): Comments diff --git a/RFEM/BasicObjects/solidSet.py b/RFEM/BasicObjects/solidSet.py index 1be5960c..de88e5d1 100644 --- a/RFEM/BasicObjects/solidSet.py +++ b/RFEM/BasicObjects/solidSet.py @@ -46,7 +46,6 @@ def __init__(self, def ContinuousSolids(self, no: int = 1, solids_no: str = '1 2', - solid_set_type = SetType.SET_TYPE_CONTINUOUS, comment: str = '', params: dict = {}): @@ -54,7 +53,6 @@ def ContinuousSolids(self, Args: no (int): Solid Set Tag solids_no (str): Tags of Solids Contained Within Continuous Solid Set - solid_set_type (enum): Solid Set Type Enumeration comment (str, optional): Comments params (dict, optional): Parameters ''' @@ -72,7 +70,7 @@ def ContinuousSolids(self, clientObject.solids = ConvertToDlString(solids_no) # Solid Set Type - clientObject.set_type = solid_set_type.name + clientObject.set_type = SetType.SET_TYPE_CONTINUOUS.name # Comment clientObject.comment = comment @@ -87,7 +85,6 @@ def ContinuousSolids(self, def GroupOfSolids(self, no: int = 1, solids_no: str = '1 2', - solid_set_type = SetType.SET_TYPE_GROUP, comment: str = '', params: dict = {}): @@ -95,7 +92,6 @@ def GroupOfSolids(self, Args: no (int): Solid Set Tag solids_no (str): Tags of Solids Contained Within Group of Solids Solid Set - solid_set_type (enum): Solid Set Type Enumeration comment (str, optional): Comments params (dict, optional): Parameters ''' @@ -113,7 +109,7 @@ def GroupOfSolids(self, clientObject.solids = ConvertToDlString(solids_no) # Solid Set Type - clientObject.set_type = solid_set_type.name + clientObject.set_type = SetType.SET_TYPE_GROUP.name # Comment clientObject.comment = comment diff --git a/RFEM/Loads/freeLoad.py b/RFEM/Loads/freeLoad.py index 5dd258ab..c61c7709 100644 --- a/RFEM/Loads/freeLoad.py +++ b/RFEM/Loads/freeLoad.py @@ -16,14 +16,22 @@ def ConcentratedLoad(self, params: dict = {}): ''' - for load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV: - load_parameter = [magnitude, X, Y] - - for load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_YZ_OR_VW: - load_parameter = [magnitude, Y, Z] - - for load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XZ_OR_UW: - load_parameter = [magnitude, X, Z] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surfaces_no (int): Assigned Surface(s) + load_type (enum): Load Type Enumeration + load_projection (enum): Load Projection Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameter List + for load_projection == FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV: + load_parameter = [magnitude, X, Y] + for load_projection == FreeLoadLoadProjection.LOAD_PROJECTION_YZ_OR_VW: + load_parameter = [magnitude, Y, Z] + for load_projection == FreeLoadLoadProjection.LOAD_PROJECTION_XZ_OR_UW: + load_parameter = [magnitude, X, Z] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Free Concentrated Load @@ -79,11 +87,20 @@ def LineLoad(self, params: dict = {}): ''' - for load_distribution = FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: - load_parameter = [magnitude_uniform, load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y] - - for load_distribution = FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR: - load_parameter = [magnitude_first, magnitude_second, load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surfaces_no (int): Assigned Surface(s) + load_distribution (enum): Load Distribution Enumeration + load_projection (enum): Load Projection Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameter List + for load_distribution == FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude_uniform, load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y] + for load_distribution == FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [magnitude_first, magnitude_second, load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Free Concentrated Load @@ -153,39 +170,40 @@ def RectangularLoad(self, params: dict = {}): ''' - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: - load_magnitude_parameter = [magnitude_uniform] - - for load_distribution = FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST or FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: - load_magnitude_parameter = [magnitude_linear_first, magnitude_linear_second] - - for load_location = FreeRectangularLoadLoadLocationRectangle.LOAD_LOCATION_RECTANGLE_CORNER_POINTS: - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: - load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, axis_start_angle] - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: - load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, [[distance, factor], ...] - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER: - load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER: - load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, [[distance, factor], ...], [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] - - for load_location = FreeRectangularLoadLoadLocationRectangle.LOAD_LOCATION_RECTANGLE_CENTER_AND_SIDES: - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: - load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, axis_start_angle] - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: - load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, [[distance, factor], ...] - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER: - load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] - - for load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER: - load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, [[distance, factor], ...], [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surfaces_no (int): Assigned Surface(s) + load_distribution (enum): Load Distribution Enumeration + load_projection (enum): Load Projection Enumeration + load_direction (enum): Load Direction Enumeration + load_magnitude_parameter (list): Load Magnitude Parameter + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_magnitude_parameter = [magnitude_uniform] + for load_distribution == FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST or FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: + load_magnitude_parameter = [magnitude_linear_first, magnitude_linear_second] + load_location (enum): Load Location Enumeration + load_location_parameter (list): Load Location Parameters + for load_location == FreeRectangularLoadLoadLocationRectangle.LOAD_LOCATION_RECTANGLE_CORNER_POINTS: + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: + load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, axis_start_angle] + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: + load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, [[distance, factor], ...] + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER: + load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER: + load_location_parameter = [load_location_first_x, load_location_first_y, load_location_second_x, load_location_second_y, [[distance, factor], ...], [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] + for load_location == FreeRectangularLoadLoadLocationRectangle.LOAD_LOCATION_RECTANGLE_CENTER_AND_SIDES: + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST or FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: + load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, axis_start_angle] + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: + load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, [[distance, factor], ...] + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER: + load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] + for load_distribution == FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER: + load_location_parameter = [load_location_center_x, load_location_center_y, load_location_center_side_a, load_location_center_side_b, [[distance, factor], ...], [axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z], [axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z], axis_start_angle,[[alpha, factor], ...] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Free Concentrated Load @@ -421,11 +439,20 @@ def CircularLoad(self, params: dict = {}): ''' - for load_distribution = FreeCircularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: - load_parameter = [magnitude_uniform, load_location_x, load_location_y, load_location_radius] - - for load_distribution = FreeCircularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR: - load_parameter = [magnitude_center, magnitude_radius, load_location_x, load_location_y, load_location_radius] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surfaces_no (int): Assigned Surface(s) + load_distribution (enum): Load Distribution Enumeration + load_projection (enum): Load Projection Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameter + for load_distribution == FreeCircularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude_uniform, load_location_x, load_location_y, load_location_radius] + for load_distribution == FreeCircularLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [magnitude_center, magnitude_radius, load_location_x, load_location_y, load_location_radius] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Free Concentrated Load @@ -493,21 +520,29 @@ def PolygonLoad(self, params: dict = {}): ''' - for load_distribution = FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: - load_location = [[first_coordinate, second_coordinate], ...] - load_parameter = [magnitude_uniform] - - for load_distribution = FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR: - load_location = [[first_coordinate, second_coordinate], ...] - load_parameter = [magnitude_linear_1, magnitude_linear_2, magnitude_linear_3, magnitude_linear_location_1, magnitude_linear_location_2, magnitude_linear_location_3] - - for load_distribution = FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST: - load_location = [[first_coordinate, second_coordinate], ...] - load_parameter = [magnitude_linear_1, magnitude_linear_2, magnitude_linear_location_1, magnitude_linear_location_2] - - for load_distribution = FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: - load_location = [[first_coordinate, second_coordinate], ...] - load_parameter = [magnitude_linear_1, magnitude_linear_2, magnitude_linear_location_1, magnitude_linear_location_2] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surfaces_no (int): Assigned Surface(s) + load_distribution (enum): Load Distribution Enumeration + load_projection (enum): Load Projection Enumeration + load_direction (enum): Load Direction Enumeration + load_location (list): Load Location Parameter + load_parameter (list): Load Parameter + for load_distribution == FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_location = [[first_coordinate, second_coordinate], ...] + load_parameter = [magnitude_uniform] + for load_distribution == FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_location = [[first_coordinate, second_coordinate], ...] + load_parameter = [magnitude_linear_1, magnitude_linear_2, magnitude_linear_3, magnitude_linear_location_1, magnitude_linear_location_2, magnitude_linear_location_3] + for load_distribution == FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_FIRST: + load_location = [[first_coordinate, second_coordinate], ...] + load_parameter = [magnitude_linear_1, magnitude_linear_2, magnitude_linear_location_1, magnitude_linear_location_2] + for load_distribution == FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_LINEAR_SECOND: + load_location = [[first_coordinate, second_coordinate], ...] + load_parameter = [magnitude_linear_1, magnitude_linear_2, magnitude_linear_location_1, magnitude_linear_location_2] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Free Concentrated Load diff --git a/RFEM/Loads/lineLoad.py b/RFEM/Loads/lineLoad.py index 1006c639..71e6e56c 100644 --- a/RFEM/Loads/lineLoad.py +++ b/RFEM/Loads/lineLoad.py @@ -11,10 +11,16 @@ def __init__(self, magnitude: float = 0, comment: str = '', params: dict = {}): + ''' - Assigns line load without any further options. - Load type is Force by default. - Load distribution is Uniform by default. + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + lines_no (str): Assigned Line(s) + load_direction (enum): Load Direction Enumeration + magnitude (float): Magnitude of Line Load + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Line Load @@ -68,20 +74,38 @@ def Force(self, params: dict = {}): ''' - load_parameter: - LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude - LOAD_DISTRIBUTION_UNIFORM_TOTAL: load_parameter = magnitude - LOAD_DISTRIBUTION_CONCENTRATED_1: load_parameter = [relative_distance = False, magnitude, distance_a] - LOAD_DISTRIBUTION_CONCENTRATED_N: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude, count_n, distance_a, distance_b] - LOAD_DISTRIBUTION_CONCENTRATED_2x2: load_parameter = [relative_distance_a = False, relative_distance_b = False, relative_distance_c = False, magnitude, distance_a, distance_b, distance_c] - LOAD_DISTRIBUTION_CONCENTRATED_2: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] - LOAD_DISTRIBUTION_CONCENTRATED_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - LOAD_DISTRIBUTION_TRAPEZOIDAL: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - LOAD_DISTRIBUTION_TAPERED: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - params: - {''} + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + lines_no (str): Assigned Line(s) + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter: Load Parameter + for load_distribution == LOAD_DISTRIBUTION_UNIFORM: + load_parameter = magnitude + for load_distribution == LOAD_DISTRIBUTION_UNIFORM_TOTAL: + load_parameter = magnitude + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_1: + load_parameter = [relative_distance = False, magnitude, distance_a] + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_N: + load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude, count_n, distance_a, distance_b] + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_2x2: + load_parameter = [relative_distance_a = False, relative_distance_b = False, relative_distance_c = False, magnitude, distance_a, distance_b, distance_c] + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_2: + load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + for load_distribution == LOAD_DISTRIBUTION_TRAPEZOIDAL: + load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] + for load_distribution == LOAD_DISTRIBUTION_TAPERED: + load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] + for load_distribution == LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + for load_distribution == LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + list_reference (bool): List Reference Bool + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Line Load @@ -300,18 +324,38 @@ def Moment(self, list_reference: bool = False, comment: str = '', params: dict = {}): + ''' - load_parameter: - LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude - LOAD_DISTRIBUTION_CONCENTRATED_1: load_parameter = [relative_distance = False, magnitude, distance_a] - LOAD_DISTRIBUTION_CONCENTRATED_N: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude, count_n, distance_a, distance_b] - LOAD_DISTRIBUTION_CONCENTRATED_2x2: load_parameter = [relative_distance_a = False, relative_distance_b = False, relative_distance_c = False, magnitude, distance_a, distance_b, distance_c] - LOAD_DISTRIBUTION_CONCENTRATED_2: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] - LOAD_DISTRIBUTION_CONCENTRATED_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - LOAD_DISTRIBUTION_TRAPEZOIDAL: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - LOAD_DISTRIBUTION_TAPERED: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + lines_no (str): Assigned Line(s) + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter: Load Parameter + load_parameter == LOAD_DISTRIBUTION_UNIFORM: + load_parameter = magnitude + load_parameter == LOAD_DISTRIBUTION_CONCENTRATED_1: + load_parameter = [relative_distance = False, magnitude, distance_a] + load_parameter == LOAD_DISTRIBUTION_CONCENTRATED_N: + load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude, count_n, distance_a, distance_b] + load_parameter == LOAD_DISTRIBUTION_CONCENTRATED_2x2: + load_parameter = [relative_distance_a = False, relative_distance_b = False, relative_distance_c = False, magnitude, distance_a, distance_b, distance_c] + load_parameter == LOAD_DISTRIBUTION_CONCENTRATED_2: + load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] + load_parameter == LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + load_parameter == LOAD_DISTRIBUTION_TRAPEZOIDAL: + load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] + load_parameter == LOAD_DISTRIBUTION_TAPERED: + load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] + load_parameter == LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + load_parameter == LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + list_reference (bool): List Reference Bool + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Line Load @@ -529,11 +573,18 @@ def Mass(self, comment: str = '', params: dict = {}): ''' - if individual_mass_components == False: - mass_components = [mass_global] - - if individual_mass_components == True: - mass_components = [mass_x, mass_y, mass_z] + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + lines_no (str): Assigned Line(s) + individual_mass_components (bool): Individual Mass Components Boolean + mass_components (list): Mass Components + for individual_mass_components == False: + mass_components = [mass_global] + for individual_mass_components == True: + mass_components = [mass_x, mass_y, mass_z] + comment (str, optional): Comments + params (dict, optional): Parameters ''' # Client model | Line Load diff --git a/RFEM/Loads/memberLoad.py b/RFEM/Loads/memberLoad.py index f816a1a6..85cf55d8 100644 --- a/RFEM/Loads/memberLoad.py +++ b/RFEM/Loads/memberLoad.py @@ -74,42 +74,39 @@ def Force(self, Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum): Load Distribution Enumeration load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == LOAD_DISTRIBUTION_UNIFORM: load_parameter = [magnitude] - for LOAD_DISTRIBUTION_UNIFORM_TOTAL: + for load_distribution == LOAD_DISTRIBUTION_UNIFORM_TOTAL: load_parameter = [magnitude] - for LOAD_DISTRIBUTION_CONCENTRATED_1: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_1: load_parameter = [relative_distance = False, magnitude, distance_a] - for LOAD_DISTRIBUTION_CONCENTRATED_N: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_N: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude, count_n, distance_a, distance_b] - for LOAD_DISTRIBUTION_CONCENTRATED_2x2: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_2x2: load_parameter = [relative_distance_a = False, relative_distance_b = False, relative_distance_c = False, magnitude, distance_a, distance_b, distance_c] - for LOAD_DISTRIBUTION_CONCENTRATED_2: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_2: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] - for LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - for LOAD_DISTRIBUTION_TRAPEZOIDAL: + for load_distribution == LOAD_DISTRIBUTION_TRAPEZOIDAL: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - for LOAD_DISTRIBUTION_TAPERED: + for load_distribution == LOAD_DISTRIBUTION_TAPERED: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - for LOAD_DISTRIBUTION_PARABOLIC: + for load_distribution == LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - for LOAD_DISTRIBUTION_VARYING: + for load_distribution == LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - for LOAD_DISTRIBUTION_VARYING_IN_Z: + for load_distribution == LOAD_DISTRIBUTION_VARYING_IN_Z: load_parameter = [[distance, delta_distance, magnitude], ...] - force_eccentricity (bool): Enable/Disable Force Eccentricity Option list_reference (bool): Enable/Disable List Reference Option - comment (str): - params (dict): - - For force_eccentricity == True: + comment (str, optional): Comments + params (dict, optional): Parameters + for force_eccentricity == True: {'eccentricity_horizontal_alignment': MemberLoadEccentricityHorizontalAlignment.ALIGN_NONE, 'eccentricity_vertical_alignment': MemberLoadEccentricityVerticalAlignment.ALIGN_NONE, 'eccentricity_section_middle': MemberLoadEccentricitySectionMiddle.LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, @@ -377,32 +374,30 @@ def Moment(self, Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum): Load Distribution Enumeration load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude - for LOAD_DISTRIBUTION_CONCENTRATED_1: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_1: load_parameter = [relative_distance = False, magnitude, distance_a] - for LOAD_DISTRIBUTION_CONCENTRATED_N: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_N: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude, count_n, distance_a, distance_b] - for LOAD_DISTRIBUTION_CONCENTRATED_2x2: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_2x2: load_parameter = [relative_distance_a = False, relative_distance_b = False, relative_distance_c = False, magnitude, distance_a, distance_b, distance_c] - for LOAD_DISTRIBUTION_CONCENTRATED_2: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_2: load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] - for LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + for load_distribution == LOAD_DISTRIBUTION_CONCENTRATED_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - for LOAD_DISTRIBUTION_TRAPEZOIDAL: + for load_distribution == LOAD_DISTRIBUTION_TRAPEZOIDAL: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - for LOAD_DISTRIBUTION_TAPERED: + for load_distribution == LOAD_DISTRIBUTION_TAPERED: load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] - for LOAD_DISTRIBUTION_PARABOLIC: + for load_distribution == LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - for LOAD_DISTRIBUTION_VARYING: + for load_distribution == LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - list_reference (bool): Enable/Disable List Reference Option comment (str, optional): Comments params (dict, optional): Parameters @@ -603,15 +598,13 @@ def Mass(self, Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str):Assigned Members + members_no (str):Assigned Member(s) individual_mass_components (bool): Enable/Disable Individual Mass Components Option - mass_components (list): - + mass_components (list): Mass Components List if individual_mass_components == False: mass_components = [M] else: mass_components = [Mx, My, Mz, Ix, Iy, Iz] - comment (str, optional): Comments params (dict, optional): Parameters """ @@ -668,38 +661,34 @@ def Temperature(self, load_over_total_length: bool= False, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag - load_case_no (int): - members_no (str): - load_distribution (enum): - load_direction (enum): - load_parameter (list): - list_reference (bool): - load_over_total_length (bool): - comment (str, optional): - params (dict, optional): - """ + load_case_no (int): Assigned Load Case + members_no (str): Assigned Member(s) + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameter List + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [tt, tb] + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_over_total_length == False: + load_parameter = [tt1, tt2, tb1, tb2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_over_total_length == True: + load_parameter = [tt1, tt2, tb1, tb2] + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [tt1, tt2, tb1, tb2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [tb1, tb2, tb3, tt1, tt2, tt3] + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + list_reference (bool): List Reference Boolean + load_over_total_length (bool): Enable/Disable Load Over Total Length Option + comment (str, optional): Comments + params (dict, optional): Parameters ''' - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: - load_parameter = [tt, tb] - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: - for load_over_total_length: bool= False: - load_parameter = [tt1, tt2, tb1, tb2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_over_total_length: bool= True: - load_parameter = [tt1, tt2, tb1, tb2] - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: - load_parameter = [tt1, tt2, tb1, tb2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: - load_parameter = [tb1, tb2, tb3, tt1, tt2, tt3] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: - load_parameter = [[distance, delta_distance, magnitude], ...] - ''' # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -829,34 +818,34 @@ def TemperatureChange(self, load_over_total_length: bool= False, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum): Load Distribution load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: load_parameter = [tc, delta_t] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: - for load_over_total_length: bool= False: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_over_total_length == False: load_parameter = [delta_t_1, delta_t_2, t_c_1, t_c_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_over_total_length: bool= True: + for load_over_total_length == True: load_parameter = [delta_t_1, delta_t_2, t_c_1, t_c_2] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: load_parameter = [delta_t_1, delta_t_2, t_c_1, t_c_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [delta_t_1, delta_t_2, delta_t_3, t_c_1, t_c_2, t_c_3] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - list_reference (bool): Enable/Disable List Reference Option load_over_total_length (bool): Enable/Disable Load Over Total Length Option comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -986,31 +975,31 @@ def AxialStrain(self, load_over_total_length: bool= False, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum): Load Distribution Enumeration load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: load_parameter = [epsilon] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: load_parameter = [epsilon1, epsilon2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: load_parameter = [epsilon1, epsilon2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: load_parameter = [epsilon1, epsilon2, epsilon3] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - list_reference (bool): Enable/Disable List Reference Option load_over_total_length (bool): Enable/Disable Load Over Total Length Option comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1129,17 +1118,17 @@ def AxialDisplacement(self, magnitude : float = 0.0, comment: str = '', params: dict = {}): - """ + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_direction (enum): Load Direction Enumeration magnitude (float): Load Magnitude comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1190,31 +1179,31 @@ def Precamber(self, load_over_total_length: bool= False, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum):Load Distribution Enumeration load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: load_parameter = [magnitude] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - list_reference (bool): Enable/Disable List Reference Option load_over_total_length (bool): Enable/Disable Load Over Total Length Option comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1333,16 +1322,18 @@ def InitialPrestress(self, magnitude : float = 0.0, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_direction (enum): Load Direction Enumeration magnitude (float): Load Magnitude comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1392,41 +1383,41 @@ def Displacement(self, load_over_total_length: bool= False, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum): Load Distribution Enumeration load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: load_parameter = [magnitude] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_a] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_b_is_defined_as_relative = False, distance_a, distance_b] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_b_is_defined_as_relative = False, distance_c_is_defined_as_relative = False, distance_a, distance_b, distance_c] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: load_parameter = [magnitude_1, magnitude_2, distance_a_is_defined_as_relative = False, distance_b_is_defined_as_relative = False, distance_a, distance_b] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - list_reference (bool): Enable/Disable List Reference Option load_over_total_length (bool): Enable/Disable Load Over Total Length Option comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1627,41 +1618,41 @@ def Rotation(self, load_over_total_length: bool= False, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_distribution (enum): Load Distribution Enumeration load_direction (enum): Load Direction Enumeration - load_parameter (list): - - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter (list): Load Parameter List + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: load_parameter = [magnitude] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_a] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_b_is_defined_as_relative = False, distance_a, distance_b] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_b_is_defined_as_relative = False, distance_c_is_defined_as_relative = False, distance_a, distance_b, distance_c] - for load_distrubition = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: + for load_distrubition == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: load_parameter = [magnitude_1, magnitude_2, distance_a_is_defined_as_relative = False, distance_b_is_defined_as_relative = False, distance_a, distance_b] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: load_parameter = [magnitude_1, magnitude_2, magnitude_3] - for load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: load_parameter = [[distance, delta_distance, magnitude], ...] - list_reference (bool): Enable/Disable List Reference Option load_over_total_length (bool): Enable/Disable Load Over Total Length Option comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1859,16 +1850,18 @@ def PipeContentFull(self, specific_weight : float = 0.0, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_direction_orientation (enum): Load Direction Enumeration specific_weight (float): Specific Weight comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1919,17 +1912,19 @@ def PipeContentPartial(self, filling_height : float = 0.0, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) load_direction_orientation (enum): Load Direction Enumeration specific_weight (float): Specific Weight filling_height (float): Filling Height comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -1981,15 +1976,17 @@ def PipeInternalPressure(self, pressure : float = 0.0, comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members + members_no (str): Assigned Member(s) pressure (float): Pressure comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load') @@ -2041,21 +2038,23 @@ def RotaryMotion(self, axis_definition_p2 = [], comment: str = '', params: dict = {}): - """ + + ''' Args: no (int): Load Tag load_case_no (int): Assigned Load Case - members_no (str): Assigned Members No + members_no (str): Assigned Member(s) angular_acceleration (float): Angular Acceleration angular_velocity (float): Angular Velocity axis_definition_type (enum): Axis Definition Type Enumeration axis_orientation (enum): Axis Orientation Enumeration axis_definition (enum): Axis Definition Enumeration - axis_definition_p1 (list): P1 List - axis_definition_p2 (list): P2 List + axis_definition_p1 (list): P1 List [X, Y, Z] + axis_definition_p2 (list): P2 List [X, Y, Z] comment (str, optional): Comments params (dict, optional): Parameters - """ + ''' + # Client model | Member Load clientObject = Model.clientModel.factory.create('ns0:member_load')