diff --git a/package/README.md b/package/README.md new file mode 100644 index 00000000..b97926a8 --- /dev/null +++ b/package/README.md @@ -0,0 +1,27 @@ +# RFEM Python High Level Function Library + +## Project Description +**Webservice and API** is a programmable interface for RFEM 6 . Based on this technology, the program RFEM 6 provide a server service that can be used locally or via the network. The client-server communication allows you to send requests to and receive feedback from RFEM 6 . + +High-level libraries are available for the Python and C# programming languages, which allow easy and intuitive use of web services. The high-level libraries are available on [**GitHub under an open source license**](https://github.com/Dlubal-Software/RFEM_Python_Client). They can be used free of charge and adapted to your specific needs. Contributions to our repositories are always welcome. + +## Example +``` +from RFEM.initModel import Model, Calculate_all +from RFEM.BasicObjects.material import Material +from RFEM.BasicObjects.section import Section +from RFEM.BasicObjects.node import Node +from RFEM.BasicObjects.member import Member +from RFEM.TypesForNodes.nodalSupport import NodalSupport +from RFEM.enums import NodalSupportType, LoadDirectionType +from RFEM.LoadCasesAndCombinations.staticAnalysisSettings import StaticAnalysisSettings +from RFEM.LoadCasesAndCombinations.loadCase import LoadCase +from RFEM.Loads.nodalLoad import NodalLoad +``` +## API Documentation + +Visit our [GitHub page](https://dlubal-software.github.io/RFEM_Python_Client/) + +## License + +[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) diff --git a/package/RFEM/BasicObjects/__init__.py b/package/RFEM/BasicObjects/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/BasicObjects/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/BasicObjects/bracing.py b/package/RFEM/BasicObjects/bracing.py new file mode 100644 index 00000000..737bf1df --- /dev/null +++ b/package/RFEM/BasicObjects/bracing.py @@ -0,0 +1,213 @@ +# from RFEM.initModel import Model, clearAtributes, ConvertToDlString +# from RFEM.enums import BracingType + +# class Bracing(): +# def __init__(self, +# no: int = 1, +# member_type = BracingType.TYPE_HORIZONTAL, +# start_node_no: int = 1, +# end_node_no: int = 2, +# rotation_angle: float = 0.0, +# start_section_no: int = 1, +# end_section_no: int = 1, +# 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') + +# # Clears object atributes | Sets all atributes to None +# clearAtributes(clientObject) + +# # Bracing No. +# clientObject.no = no + +# # Bracing Type +# clientObject.type = bracing_type.name + +# # Start Node No. +# clientObject.node_start = start_node_no + +# # End Node No. +# clientObject.node_end = end_node_no + +# # Bracing Rotation Angle beta +# clientObject.rotation_angle = rotation_angle + +# # Start Section No. +# clientObject.section_start = start_section_no + +# # End Section No. +# clientObject.section_end = end_section_no + +# # Start Bracing Hinge No. +# clientObject.bracing_hinge_start = start_bracing_hinge_no + +# # End Bracing Hinge No. +# clientObject.bracing_hinge_end = end_bracing_hinge_no + +# # Comment +# clientObject.comment = comment + +# # Adding optional parameters via dictionary +# for key in params: +# clientObject[key] = params[key] + +# # Add Member to client model +# Model.clientModel.service.set_bracing(clientObject) + +# def Horizontal(self, +# no: int = 1, +# bracing_type = BracingType.TYPE_HORIZONTAL, +# start_node_no: int = 1, +# end_node_no: int = 2, +# rotation_angle: float = 0.0, +# start_section_no: int = 1, +# end_section_no: int = 1, +# start_bracing_hinge_no: int = 0, +# end_bracing_hinge_no: int = 0, +# 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') + +# # Clears object atributes | Sets all atributes to None +# clearAtributes(clientObject) + +# # Bracing No. +# clientObject.no = no + +# # Bracing Type +# clientObject.type = bracing_type.name + +# # Start Node No. +# clientObject.node_start = start_node_no + +# # End Node No. +# clientObject.node_end = end_node_no + +# # Bracing Rotation Angle beta +# clientObject.rotation_angle = rotation_angle + +# # Start Section No. +# clientObject.section_start = start_section_no + +# # End Section No. +# clientObject.section_end = end_section_no + +# # Start Bracing Hinge No. +# clientObject.bracing_hinge_start = start_bracing_hinge_no + +# # End Bracing Hinge No. +# clientObject.bracing_hinge_end = end_bracing_hinge_no + +# # Comment +# clientObject.comment = comment + +# # Adding optional parameters via dictionary +# for key in params: +# clientObject[key] = params[key] + +# # Add Bracing to client model +# Model.clientModel.service.set_bracing(clientObject) + +# def Vertical(self, +# no: int = 1, +# bracing_type = BracingType.TYPE_VERTICAL, +# start_node_no: int = 1, +# end_node_no: int = 2, +# rotation_angle: float = 0.0, +# start_section_no: int = 1, +# end_section_no: int = 1, +# start_bracing_hinge_no: int = 0, +# end_bracing_hinge_no: int = 0, +# 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') + +# # Clears object atributes | Sets all atributes to None +# clearAtributes(clientObject) + +# # Bracing No. +# clientObject.no = no + +# # Bracing Type +# clientObject.type = bracing_type.name + +# # Start Node No. +# clientObject.node_start = start_node_no + +# # End Node No. +# clientObject.node_end = end_node_no + +# # Bracing Rotation Angle beta +# clientObject.rotation_angle = rotation_angle + +# # Start Section No. +# clientObject.section_start = start_section_no + +# # End Section No. +# clientObject.section_end = end_section_no + +# # Start Bracing Hinge No. +# clientObject.bracing_hinge_start = start_bracing_hinge_no + +# # End Bracing Hinge No. +# clientObject.bracing_hinge_end = end_bracing_hinge_no + +# # Comment +# clientObject.comment = comment + +# # Adding optional parameters via dictionary +# for key in params: +# clientObject[key] = params[key] + +# # Add Bracing to client model +# Model.clientModel.service.set_bracing(clientObject) + diff --git a/package/RFEM/BasicObjects/frame.py b/package/RFEM/BasicObjects/frame.py new file mode 100644 index 00000000..b5b13079 --- /dev/null +++ b/package/RFEM/BasicObjects/frame.py @@ -0,0 +1,123 @@ +# from RFEM.initModel import Model, clearAtributes, ConvertToDlString + +# class Frame(): +# def __init__(self, +# number_of_frames: int = 1, +# span_l: int = 2, +# height_h: int = 1, +# column_cross_section: 1, +# column_member_type = MemberType.TYPE_BEAM, +# girder_cross_section: 2, +# girder_member_type = MemberType.TYPE_BEAM, +# support_type = NodalSupportType.HINGED, +# insertion_point_x: int = 3, +# insertion_point_y: int = 4, +# insertion_point_z: int = 3, +# 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') + +# # Clears object atributes | Sets all atributes to None +# clearAtributes(clientObject) + +# ------------------------------------------------------------------------- +# # Number of frames: da soll man eine Funktion zu clientModel. herstellen... oder? + +# i = 1 +# while i <= n: +# j = (i-1) * 5 +# Node(j+1, 0.0, -(i-1)*d, 0.0) +# Node(j+2, 0.0, -(i-1)*d, -h) +# Node(j+3, l/2, -(i-1)*d, -h) +# Node(j+4, l, -(i-1)*d, -h) +# Node(j+5, l, -(i-1)*d, 0.0) +# i += 1 + +# # Nodal Supports +# i = 1 +# nodes_no = "" +# while i <= n: +# j = (i-1) * 5 +# nodes_no += str(j+1) + " " +# nodes_no += str(j+5) + " " +# i += 1 +# nodes_no = nodes_no.rstrip(nodes_no[-1]) +# NodalSupport(1, nodes_no, NodalSupportType.HINGED, "Hinged support") + +# #members: what's about the sections? maybe an input field where the user gives the materials +# Material (1 , 'S235') +# Material (2, 'C25/30') + +# Section (1, 'HEM 700',1) +# Section (2, 'IPE 500',1) + +# #members x direction +# i = 1 +# while i <= n: +# j = (i-1) * 5 +# k = (i-1) * 4 +# Member(k+1, MemberType.TYPE_BEAM, j+1, j+2, 0.0, 1, 1) +# Member(k+2, MemberType.TYPE_BEAM, j+2, j+3, 0.0, 2, 2) +# Member(k+3, MemberType.TYPE_BEAM, j+3, j+4, 0.0, 2, 2) +# Member(k+4, MemberType.TYPE_BEAM, j+4, j+5, 0.0, 1, 1) +# i += 1 +# print(k+1,k+2,k+3,k+4) + +# #members y direction +# i = 1 +# while i <= n-1: +# j = (i-1) * 5 +# print(k+4+2*(i-1)+1, k+4+2*(i-1)+2) +# Member(int(k+4+2*(i-1)+1), MemberType.TYPE_BEAM, j+2, j+7, 0.0, 2, 2) +# Member(int(k+4+2*(i-1)+2), MemberType.TYPE_BEAM, j+4, j+9, 0.0, 2, 2) +# i += 1 + +# ------------------------------------------------------------------------- + +# clientObject. = NodeType.TYPE_BETWEEN_TWO_NODES.name +# = column_cross_section + +# #column cross section +# clientobject. = columnn_cross_section.name + +# #column member type +# clientObject.type = column_member_type.name + +# #girder cross section +# clientobject. = girder_cross_section.name + +# #girder member type +# clientObject.type = girder_member_type.name + +# # Nodal Support + +# clientObject. = support_type.name + +# # Comment +# clientObject.comment = comment + +# # Adding optional parameters via dictionary +# for key in params: +# clientObject[key] = params[key] + +# # Add Member to client model +# clientModel.service.set_frame(clientObject) diff --git a/package/RFEM/BasicObjects/line.py b/package/RFEM/BasicObjects/line.py new file mode 100644 index 00000000..7d05edc6 --- /dev/null +++ b/package/RFEM/BasicObjects/line.py @@ -0,0 +1,438 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import LineType, LineArcAlphaAdjustmentTarget + +class Line(): + def __init__(self, + no: int = 1, + nodes_no: str = '1 2', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def Polyline(self, + no: int = 1, + nodes_no: str = '1 2', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Type + clientObject.type = LineType.TYPE_POLYLINE.name + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def Arc(self, + no: int = 1, + 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 (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 + params (dict, optional): Parameters + ''' + + # Client model | Line + clientObject = Model.clientModel.factory.create('ns0:line') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Type + clientObject.type = LineType.TYPE_ARC.name + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + clientObject.arc_first_node = nodes_no[0] + clientObject.arc_second_node = nodes_no[1] + clientObject.arc_alpha_adjustment_target = alpha_adjustment_target.name + clientObject.arc_control_point_x = control_point[0] + clientObject.arc_control_point_y = control_point[1] + clientObject.arc_control_point_z = control_point[2] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def Circle(self, + no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Type + clientObject.type = LineType.TYPE_CIRCLE.name + + # Center of circle + clientObject.circle_center_coordinate_1 = center_of_cirle[0] + clientObject.circle_center_coordinate_2 = center_of_cirle[1] + clientObject.circle_center_coordinate_3 = center_of_cirle[2] + + clientObject.circle_radius = circle_radius + + # Point of normal to circle plane + clientObject.circle_normal_coordinate_1 = point_of_normal_to_circle_plane[0] + clientObject.circle_normal_coordinate_2 = point_of_normal_to_circle_plane[1] + clientObject.circle_normal_coordinate_3 = point_of_normal_to_circle_plane[2] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def EllipticalArc(self, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Type + clientObject.type = LineType.TYPE_ELLIPTICAL_ARC.name + + # Control points + clientObject.elliptical_arc_first_control_point_x = p1_control_point[0] + clientObject.elliptical_arc_first_control_point_y = p1_control_point[1] + clientObject.elliptical_arc_first_control_point_z = p1_control_point[2] + + clientObject.elliptical_arc_second_control_point_x = p2_control_point[0] + clientObject.elliptical_arc_second_control_point_y = p2_control_point[1] + clientObject.elliptical_arc_second_control_point_z = p2_control_point[2] + + clientObject.elliptical_arc_perimeter_control_point_x = p3_control_point[0] + clientObject.elliptical_arc_perimeter_control_point_y = p3_control_point[1] + clientObject.elliptical_arc_perimeter_control_point_z = p3_control_point[2] + + clientObject.elliptical_arc_alpha = arc_angle_alpha + clientObject.elliptical_arc_beta = arc_angle_beta + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def Ellipse(self, + no: int = 1, + nodes_no: list = [5,10], + ellipse_control_point: list = [18,-4.8,0], + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Line Tag + 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 + ''' + + # Client model | Line + clientObject = Model.clientModel.factory.create('ns0:line') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + clientObject.ellipse_first_node = nodes_no[0] + clientObject.ellipse_second_node = nodes_no[1] + + # Type + clientObject.type = LineType.TYPE_ELLIPSE.name + + # Control point + 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 + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def Parabola(self, + no: int = 1, + nodes_no: str = [3,8], + parabola_control_point: list = [10,-3,0], + parabola_alpha: float = 0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Line Tag + 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 + params (dict, optional): Parameters + ''' + + # Client model | Line + clientObject = Model.clientModel.factory.create('ns0:line') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + clientObject.parabola_first_node = nodes_no[0] + clientObject.parabola_second_node = nodes_no[1] + + clientObject.parabola_alpha = parabola_alpha + + # Type + clientObject.type = LineType.TYPE_PARABOLA.name + + # Control point + 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 + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def Spline(self, + no: int = 1, + nodes_no: str = '1 3 5', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + + # Type + clientObject.type = LineType.TYPE_SPLINE.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) + + def NURBS(self, + no: int = 1, + nodes_no: str = '1 2', + control_points: list = [[0,0,0],[2.33,0,-3,4],[10,0,-11],[17.66,0,-3.4],[20,0,0]], + weights = [1,1,1,1,1], + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line No. + clientObject.no = no + + # Nodes No. + clientObject.definition_nodes = ConvertToDlString(nodes_no) + + # Type + clientObject.type = LineType.TYPE_NURBS.name + + if len(control_points) != len(weights): + print("WARNING: The number of weigths prescribed must equal the number of control points defined.") + + ''' + TODO: bug 24721 + nurbs_control_points = [] + for i,j in enumerate(control_points): + point = Model.clientModel.factory.create('ns0:line_nurbs_control_points_by_components') + point.no = i+1 + point.global_coordinate_x = control_points[i][0] + point.global_coordinate_y = control_points[i][1] + point.global_coordinate_z = control_points[i][2] + point.weight = weights[i] + nurbs_control_points.append(point) + #clientObject.nurbs_control_points_by_components = Model.clientModel.factory.create('ns0:line_nurbs_control_points_by_components') + ''' + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_line(clientObject) diff --git a/package/RFEM/BasicObjects/lineSet.py b/package/RFEM/BasicObjects/lineSet.py new file mode 100644 index 00000000..01e57fa7 --- /dev/null +++ b/package/RFEM/BasicObjects/lineSet.py @@ -0,0 +1,122 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SetType + +class LineSet(): + def __init__(self, + no: int = 1, + lines_no: str = '33 36 39 42 45', + line_set_type = SetType.SET_TYPE_CONTINUOUS, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Set No. + clientObject.no = no + + # Lines number + clientObject.lines = ConvertToDlString(lines_no) + + # Line Set Type + clientObject.set_type = line_set_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Set to client model + Model.clientModel.service.set_line_set(clientObject) + + def ContinuousLines(self, + no: int = 1, + lines_no: str = '33 36 39 42 45', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Set No. + clientObject.no = no + + # Lines number + clientObject.lines = ConvertToDlString(lines_no) + + # Line Set Type + clientObject.set_type = SetType.SET_TYPE_CONTINUOUS.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Set to client model + Model.clientModel.service.set_line_set(clientObject) + + def GroupOfLines(self, + no: int = 1, + lines_no: str = '33 36 39 42 45', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Set No. + clientObject.no = no + + # Lines number + clientObject.lines = ConvertToDlString(lines_no) + + # Line Set Type + clientObject.set_type = SetType.SET_TYPE_GROUP.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Set to client model + Model.clientModel.service.set_line_set(clientObject) diff --git a/package/RFEM/BasicObjects/material.py b/package/RFEM/BasicObjects/material.py new file mode 100644 index 00000000..25ba52fc --- /dev/null +++ b/package/RFEM/BasicObjects/material.py @@ -0,0 +1,38 @@ +from RFEM.initModel import clearAtributes, Model + +class Material(): + def __init__(self, + no: int = 1, + name: str = 'S235', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Material No. + clientObject.no = no + + # Material Name + clientObject.name = name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add material to client model + Model.clientModel.service.set_material(clientObject) diff --git a/package/RFEM/BasicObjects/member.py b/package/RFEM/BasicObjects/member.py new file mode 100644 index 00000000..472790fb --- /dev/null +++ b/package/RFEM/BasicObjects/member.py @@ -0,0 +1,1888 @@ +from RFEM.enums import MemberType, MemberRotationSpecificationType, MemberSectionDistributionType, MemberTypeRibAlignment, MemberReferenceLengthWidthType, MemberResultBeamIntegration +from RFEM.initModel import Model, clearAtributes + +class Member(): + def __init__(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_angle: float = 0.0, + start_section_no: int = 1, + end_section_no: int = 1, + start_member_hinge_no: int = 0, + end_member_hinge_no: int = 0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + end_node_no (int,): Tag of End Node + rotation_angle (float): Member Rotation Angle + start_section_no (int): Tag of Start Section + end_section_no (int): Tag of End Section + start_member_hinge_no (int): Tag of Start Member Hinge + end_member_hinge_no (int): Tag of End Member Hinge + comment (str, optional): Comment + params (dict, optional): Parameters + """ + + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_BEAM.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation Angle beta + clientObject.rotation_angle = rotation_angle + + # Start Section No. + clientObject.section_start = start_section_no + + # End Section No. + clientObject.section_end = end_section_no + + # Start Member Hinge No. + clientObject.member_hinge_start = start_member_hinge_no + + # End Member Hinge No. + clientObject.member_hinge_end = end_member_hinge_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Beam(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + section_distribution_type = MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_UNIFORM, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + start_section_no: int = 1, + end_section_no: int = 1, + distribution_parameters = [], + comment: str = '', + params: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'support':0, 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_BEAM.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Section Distribution + clientObject.section_distribution_type = section_distribution_type.name + + if section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: + clientObject.section_alignment = distribution_parameters[0].name + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES: + try: + isinstance(distribution_parameters[0], bool) + isinstance(distribution_parameters[1], bool) + except: + raise TypeError("WARNING: First two parameters should be type bool for SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[1] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[2] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[2] + if distribution_parameters[1]: + clientObject.section_distance_from_end_relative = distribution_parameters[3] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[3] + clientObject.section_alignment = distribution_parameters[4].name + clientObject.section_internal = distribution_parameters[5] + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_end_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_SADDLE: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_SADDLE. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_end_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + clientObject.section_internal = distribution_parameters[3] + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES: + try: + isinstance(distribution_parameters[0], bool) + isinstance(distribution_parameters[1], bool) + except: + raise TypeError("WARNING: First two parameters should be type bool for SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[1] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[2] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[2] + if distribution_parameters[1]: + clientObject.section_distance_from_end_relative = distribution_parameters[3] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[3] + clientObject.section_alignment = distribution_parameters[4].name + clientObject.section_internal = distribution_parameters[5] + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_end_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + + # Start Section No. + clientObject.section_start = start_section_no + + # End Section No. + clientObject.section_end = end_section_no + + # Update parameters + params_up: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'support':0, 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Hinges + clientObject.member_hinge_start = params_up['member_hinge_start'] + clientObject.member_hinge_end = params_up['member_hinge_end'] + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Support + clientObject.support = params_up['support'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Result Intermediate Points + clientObject.member_result_intermediate_point = params_up['member_result_intermediate_point'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Rigid(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + comment: str = '', + params: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'support':0, 'member_nonlinearity': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_RIGID.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Update parameters + params_up: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'support':0, 'member_nonlinearity': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Hinges + clientObject.member_hinge_start = params_up['member_hinge_start'] + clientObject.member_hinge_end = params_up['member_hinge_end'] + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Support + clientObject.support = params_up['support'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # Result Intermediate Points + clientObject.member_result_intermediate_point = params_up['member_result_intermediate_point'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + +## Rib Member should be corrected. + def Rib(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + section_distribution_type = MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_UNIFORM, + start_section_no: int = 1, + end_section_no: int = 1, + rib_surfaces_no = [], + rib_alignment = MemberTypeRibAlignment.ALIGNMENT_ON_Z_SIDE_POSITIVE, + reference_width_type = MemberReferenceLengthWidthType.REFERENCE_LENGTH_WIDTH_SIXTH, + comment: str = '', + params: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'support':0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + end_node_no (int): Tag of End Node + section_distribution_type (enum): Section Distribution Type Enuemration + start_section_no (int): Tag of Start Section + end_section_no (int): Tag of End Section + rib_surfaces_no (list): Surfaces Tags Assigned to Rib + rib_alignment (enum): Rib Alignment Enumeration + reference_width_type (enum): Reference Width Type Enumeration + comment (str, optional): Comment + params (dict, optional): Parameters + + for section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: + distribution_parameters[section_alignment] BJÖRN: Where is this parameter used? + """ + + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_RIB.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Section Distribution + clientObject.section_distribution_type = section_distribution_type.name + try: + section_distribution_type.name == "MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_UNIFORM" or section_distribution_type.name == "MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR" + except: + raise TypeError("WARNING: Only Uniform and Linear section distributions are available for Rib member. Kindly check inputs and correctness.") + + # Start Section No. + clientObject.section_start = start_section_no + + # End Section No. + clientObject.section_end = end_section_no + + # Rib Surfaces + clientObject.member_rib_first_surface = rib_surfaces_no[0] + clientObject.member_rib_second_surface = rib_surfaces_no[1] + + # Rib Alignment + clientObject.member_type_rib_alignment = rib_alignment.name + + # Reference Length Width Type + clientObject.reference_length_width_type = reference_width_type.name + + # Update parameters + params_up: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'support':0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Hinges + clientObject.member_hinge_start = params_up['member_hinge_start'] + clientObject.member_hinge_end = params_up['member_hinge_end'] + + # Member Support + clientObject.support = params_up['support'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Result Intermediate Points + clientObject.member_result_intermediate_point = params_up['member_result_intermediate_point'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Truss(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + section_no: int = 1, + comment: str = '', + params: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_TRUSS.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = section_no + + # End Section No. + clientObject.section_end = section_no + + # Update parameters + params_up: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def TrussOnlyN(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + section_no: int = 1, + comment: str = '', + params: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_TRUSS_ONLY_N.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = section_no + + # End Section No. + clientObject.section_end = section_no + + # Update parameters + params_up: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Tension(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + section_no: int = 1, + comment: str = '', + params: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_TENSION.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = section_no + + # End Section No. + clientObject.section_end = section_no + + # Update parameters + params_up: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Compression(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + section_no: int = 1, + comment: str = '', + params: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_COMPRESSION.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = section_no + + # End Section No. + clientObject.section_end = section_no + + # Update parameters + params_up: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Buckling(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + section_no: int = 1, + comment: str = '', + params: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_BUCKLING.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = section_no + + # End Section No. + clientObject.section_end = section_no + + # Update parameters + params_up: dict = {'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def Cable(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + section_no: int = 1, + comment: str = '', + params: dict = {'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_CABLE.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = section_no + + # End Section No. + clientObject.section_end = section_no + + # Update parameters + params_up: dict = {'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'is_deactivated_for_calculation' : False } + + params_up.update(params) + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def ResultBeam(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + section_distribution_type = MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_UNIFORM, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + result_beam_integrate_stresses_and_forces = MemberResultBeamIntegration.INTEGRATE_WITHIN_CUBOID_QUADRATIC, + rotation_parameters = [0], + start_section_no: int = 1, + end_section_no: int = 1, + distribution_parameters = [], + integration_parameters = [], + comment: str = '', + params: dict = { 'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'member_result_intermediate_point' : 0}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + end_node_no (int,): Tag of End Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_RESULT_BEAM.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Section Distribution + clientObject.section_distribution_type = section_distribution_type.name + + # Result Beam Integration + clientObject.result_beam_integrate_stresses_and_forces = result_beam_integrate_stresses_and_forces.name + if result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CUBOID_QUADRATIC": + clientObject.result_beam_y_z = integration_parameters[0] + elif result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CUBOID_GENERAL": + clientObject.result_beam_y_plus = integration_parameters[0] + clientObject.result_beam_z_plus = integration_parameters[1] + clientObject.result_beam_y_minus = integration_parameters[2] + clientObject.result_beam_z_minus = integration_parameters[3] + elif result_beam_integrate_stresses_and_forces.name == "INTEGRATE_WITHIN_CYLINDER": + clientObject.result_beam_radius = integration_parameters[0] + + if section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_LINEAR: + clientObject.section_alignment = distribution_parameters[0].name + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES: + try: + isinstance(distribution_parameters[0], bool) + isinstance(distribution_parameters[1], bool) + except: + raise TypeError("WARNING: First two parameters should be type bool for SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[1] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[2] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[2] + if distribution_parameters[1]: + clientObject.section_distance_from_end_relative = distribution_parameters[3] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[3] + clientObject.section_alignment = distribution_parameters[4].name + clientObject.section_internal = distribution_parameters[5] + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_end_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_SADDLE: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_SADDLE. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_end_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + clientObject.section_internal = distribution_parameters[3] + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES: + try: + isinstance(distribution_parameters[0], bool) + isinstance(distribution_parameters[1], bool) + except: + raise TypeError("WARNING: First two parameters should be type bool for SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[1] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[2] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[2] + if distribution_parameters[1]: + clientObject.section_distance_from_end_relative = distribution_parameters[3] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[3] + clientObject.section_alignment = distribution_parameters[4].name + clientObject.section_internal = distribution_parameters[5] + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_start_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_start_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_start_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + elif section_distribution_type == MemberSectionDistributionType.SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER: + try: + isinstance(distribution_parameters[0], bool) + except: + raise TypeError("WARNING: First parameter should be type bool for SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER. Kindly check list inputs completeness and correctness.") + clientObject.section_distance_from_end_is_defined_as_relative = distribution_parameters[0] + if distribution_parameters[0]: + clientObject.section_distance_from_end_relative = distribution_parameters[1] + else: + clientObject.section_distance_from_end_absolute = distribution_parameters[1] + clientObject.section_alignment = distribution_parameters[2].name + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Start Section No. + clientObject.section_start = start_section_no + + # End Section No. + clientObject.section_end = end_section_no + + # Update parameters + params_up: dict = {'end_modifications_member_start_extension': 0, + 'end_modifications_member_start_slope_y': 0, + 'end_modifications_member_start_slope_z': 0, + 'end_modifications_member_end_extension': 0, + 'end_modifications_member_end_slope_y': 0, + 'end_modifications_member_end_slope_z': 0, + 'member_result_intermediate_point' : 0} + + params_up.update(params) + + # End Modifications + clientObject.end_modifications_member_start_extension = params_up['end_modifications_member_start_extension'] + clientObject.end_modifications_member_start_slope_y = params_up['end_modifications_member_start_slope_y'] + clientObject.end_modifications_member_start_slope_z = params_up['end_modifications_member_start_slope_z'] + clientObject.end_modifications_member_end_extension = params_up['end_modifications_member_end_extension'] + clientObject.end_modifications_member_end_slope_y = params_up['end_modifications_member_end_slope_y'] + clientObject.end_modifications_member_end_slope_z = params_up['end_modifications_member_end_slope_z'] + + # Result Intermediate Points + clientObject.member_result_intermediate_point = params_up['member_result_intermediate_point'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def DefinableStiffness(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + definable_stiffness : int = 1, + comment: str = '', + params: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_DEFINABLE_STIFFNESS.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Section Distribution + clientObject.section_distribution_type = "SECTION_DISTRIBUTION_TYPE_UNIFORM" + + # Member Type Definable Stiffness + clientObject.member_type_definable_stiffness = definable_stiffness + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Update parameters + params_up: dict = {'member_hinge_start':0, 'member_hinge_end': 0, + 'member_eccentricity_start': 0, 'member_eccentricity_end': 0, + 'member_nonlinearity': 0, + 'member_result_intermediate_point' : 0, + 'is_deactivated_for_calculation' : False} + + params_up.update(params) + + # Member Hinges + clientObject.member_hinge_start = params_up['member_hinge_start'] + clientObject.member_hinge_end = params_up['member_hinge_end'] + + # Member Eccentricity + clientObject.member_eccentricity_start = params_up['member_eccentricity_start'] + clientObject.member_eccentricity_end = params_up['member_eccentricity_end'] + + # Member Nonlinearity + clientObject.member_nonlinearity = params_up['member_nonlinearity'] + + # Result Intermediate Points + clientObject.member_result_intermediate_point = params_up['member_result_intermediate_point'] + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def CouplingRigidRigid(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + comment: str = '', + params: dict = {'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_COUPLING_RIGID_RIGID.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Update parameters + params_up: dict = {'is_deactivated_for_calculation' : False} + + params_up.update(params) + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def CouplingRigidHinge(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + comment: str = '', + params: dict = {'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_COUPLING_RIGID_HINGE.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Update parameters + params_up: dict = {'is_deactivated_for_calculation' : False} + + params_up.update(params) + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def CouplingHingeRigid(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + comment: str = '', + params: dict = {'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_COUPLING_HINGE_RIGID.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Update parameters + params_up: dict = {'is_deactivated_for_calculation' : False} + + params_up.update(params) + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) + + def CouplingHingeHinge(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + rotation_specification_type = MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, + rotation_parameters = [0], + comment: str = '', + params: dict = {'is_deactivated_for_calculation' : False}): + """ + Args: + no (int): Member Tag + start_node_no (int): Tag of Start Node + 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 + """ + # Client model | Member + clientObject = Model.clientModel.factory.create('ns0:member') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member No. + clientObject.no = no + + # Member Type + clientObject.type = MemberType.TYPE_COUPLING_HINGE_HINGE.name + + # Start Node No. + clientObject.node_start = start_node_no + + # End Node No. + clientObject.node_end = end_node_no + + # Member Rotation + clientObject.rotation_specification_type = rotation_specification_type.name + if rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_ANGLE: + clientObject.rotation_angle = rotation_parameters[0] + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE: + clientObject.rotation_help_node = rotation_parameters[0] + clientObject.rotation_plane_type = rotation_parameters[1].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE: + clientObject.rotation_plane_type = rotation_parameters[0].name + elif rotation_specification_type == MemberRotationSpecificationType.COORDINATE_SYSTEM_ROTATION_VIA_SURFACE: + clientObject.rotation_surface = rotation_parameters[0] + clientObject.rotation_surface_plane_type = rotation_parameters[1].name + + # Update parameters + params_up: dict = {'is_deactivated_for_calculation' : False} + + params_up.update(params) + + # Deactivation for Calculation + clientObject.is_deactivated_for_calculation = params_up['is_deactivated_for_calculation'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member to client model + Model.clientModel.service.set_member(clientObject) diff --git a/package/RFEM/BasicObjects/memberSet.py b/package/RFEM/BasicObjects/memberSet.py new file mode 100644 index 00000000..4ec76ae7 --- /dev/null +++ b/package/RFEM/BasicObjects/memberSet.py @@ -0,0 +1,122 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SetType + +class MemberSet(): + def __init__(self, + no: int = 1, + members_no: str = '1 4 5 8 9 12 13 16 17 20 21 24', + member_set_type = SetType.SET_TYPE_GROUP, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Set No. + clientObject.no = no + + # Members number + clientObject.members = ConvertToDlString(members_no) + + # Member Set Type + clientObject.set_type = member_set_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Set to client model + Model.clientModel.service.set_member_set(clientObject) + + def ContinuousMembers(self, + no: int = 1, + members_no: str = '1 4 5 8 9 12 13 16 17 20 21 24', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Set No. + clientObject.no = no + + # Members number + clientObject.members = ConvertToDlString(members_no) + + # Member Set Type + clientObject.set_type = SetType.SET_TYPE_CONTINUOUS.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Set to client model + Model.clientModel.service.set_member_set(clientObject) + + def GroupOfmembers(self, + no: int = 1, + members_no: str = '1 4 5 8 9 12 13 16 17 20 21 24', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Set No. + clientObject.no = no + + # Members number + clientObject.members = ConvertToDlString(members_no) + + # Member Set Type + clientObject.set_type = SetType.SET_TYPE_GROUP.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Set to client model + Model.clientModel.service.set_member_set(clientObject) diff --git a/package/RFEM/BasicObjects/node.py b/package/RFEM/BasicObjects/node.py new file mode 100644 index 00000000..2cfa28ad --- /dev/null +++ b/package/RFEM/BasicObjects/node.py @@ -0,0 +1,416 @@ +from RFEM.enums import NodeType +from RFEM.enums import NodeCoordinateSystemType +from RFEM.enums import NodeReferenceType +from RFEM.initModel import Model, clearAtributes +from math import pi + +class Node(): + def __init__(self, + no: int = 1, + coordinate_X: float = 0.0, + coordinate_Y: float = 0.0, + coordinate_Z: float = 0.0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Node Tag + coordinate_X (float): X-Coordinate + coordinate_Y (float): Y-Coordinate + coordinate_Z (float): Z-Coordinate + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Node + clientObject = Model.clientModel.factory.create('ns0:node') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Node No. + clientObject.no = no + + # Coordinates + clientObject.coordinate_1 = coordinate_X + clientObject.coordinate_2 = coordinate_Y + clientObject.coordinate_3 = coordinate_Z + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Node to client model + Model.clientModel.service.set_node(clientObject) + + def Standard(self, + no: int = 1, + coordinate_system = [], + coordinate_system_type = NodeCoordinateSystemType.COORDINATE_SYSTEM_CARTESIAN, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Node Tag + coordinate_system (list): Coordinate System + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_CARTESIAN; + coordinate_system = [X, Y, Z] + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_X_CYLINDRICAL; + coordinate_system = [X, R, θ] + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_Y_CYLINDRICAL; + coordinate_system = [R, Ύ, θ] + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_Z_CYLINDRICAL; + coordinate_system = [R, θ, Z] + for coordinate_system_type == NodeCoordinateSystemType.COORDINATE_SYSTEM_POLAR: + coordinate_system = [R, θ, φ] + coordinate_system_type (enum): Coordinate System Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Node + clientObject = Model.clientModel.factory.create('ns0:node') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Node No. + clientObject.no = no + + # Node Type + clientObject.type = NodeType.TYPE_STANDARD.name + + # Coordinates + + clientObject.coordinate_system_type = coordinate_system_type.name + + if len(coordinate_system) != 3: + raise Exception('WARNING: The coordinate system needs to be of length 3. Kindly check list inputs for completeness and correctness.') + + if not isinstance(coordinate_system[0], (int, float)): + raise Exception ('WARNING: Coordinate system at index 0 to be of type "int" or ''float''') + + if not isinstance(coordinate_system[1], (int, float)): + raise Exception ('WARNING: Coordinate system at index 1 to be of type "int" or ''float''') + + if not isinstance(coordinate_system[2], (int, float)): + raise Exception ('WARNING: Coordinate system at index 2 to be of type "int" or ''float''') + + if clientObject.coordinate_system_type == "COORDINATE_SYSTEM_CARTESIAN": + clientObject.coordinate_1 = coordinate_system[0] + clientObject.coordinate_2 = coordinate_system[1] + clientObject.coordinate_3 = coordinate_system[2] + + elif clientObject.coordinate_system_type == "COORDINATE_SYSTEM_X_CYLINDRICAL": + clientObject.coordinate_1 = coordinate_system[0] + clientObject.coordinate_2 = coordinate_system[1] + clientObject.coordinate_3 = coordinate_system[2] * (pi/180) + + elif clientObject.coordinate_system_type == "COORDINATE_SYSTEM_Y_CYLINDRICAL": + clientObject.coordinate_1 = coordinate_system[0] + clientObject.coordinate_2 = coordinate_system[1] + clientObject.coordinate_3 = coordinate_system[2] * (pi/180) + + elif clientObject.coordinate_system_type == "COORDINATE_SYSTEM_Z_CYLINDRICAL": + clientObject.coordinate_1 = coordinate_system[0] + clientObject.coordinate_2 = coordinate_system[1] * (pi/180) + clientObject.coordinate_3 = coordinate_system[2] + + elif clientObject.coordinate_system_type == "COORDINATE_SYSTEM_POLAR": + clientObject.coordinate_1 = coordinate_system[0] + clientObject.coordinate_2 = coordinate_system[1] * (pi/180) + clientObject.coordinate_3 = coordinate_system[2] * (pi/180) + + # Comment + clientObject.comment = comment + + for key in params: + clientObject[key] = params[key] + + # Add Node to client model + Model.clientModel.service.set_node(clientObject) + + + def BetweenTwoNodes(self, + no: int = 1, + start_node_no: int = 1, + end_node_no: int = 2, + node_reference = NodeReferenceType.REFERENCE_TYPE_L, + length_between_i_and_j: int = 1, + parameters = [True, 50], + offset_y: int = 0, + offset_z: int = 0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Node Tag + start_node_no (int): Start Node + end_node_no (int): End Node + node_reference (enum): Node Reference Enumeration + length_between_i_and_j (int): Length between 2 Nodes + parameters (list): + if distance_from_start_relative: + parameters = [True, %] + if distance_from_start_absolute: + parameters = [False, magnitude] + offset_y (int): Offset in Y-Direction + offset_z (int): Offset in Z-Direction + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Node + clientObject = Model.clientModel.factory.create('ns0:node') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Node No. + clientObject.no = no + + # Node Type + clientObject.type = NodeType.TYPE_BETWEEN_TWO_NODES.name + + # Start Node No. + clientObject.between_two_nodes_start_node = start_node_no + + # End Node No. + clientObject.between_two_nodes_end_node = end_node_no + + # Length between i and j + + clientObject.reference_type = node_reference.name + + clientObject.reference_object_projected_length = length_between_i_and_j + + # Distance between node k and start point + + if parameters[0]: #if parameters[0]==True + clientObject.distance_from_start_relative = parameters[1] + else: + clientObject.distance_from_start_absolute = parameters[1] + + # Offset_local_y + clientObject.offset_in_local_direction_y = offset_y + + # Offset_local_z + clientObject.offset_in_local_direction_z = offset_z + + # Comment + clientObject.comment = comment + + for key in params: + clientObject[key] = params[key] + + # Add Node to client model + Model.clientModel.service.set_node(clientObject) + + def BetweenTwoPoints(self, + no: int = 1, + start_point_x: float = 0.0, + start_point_y: float = 0.0, + start_point_z: float = 0.0, + end_point_x: float = 1.0, + end_point_y:float = 1.0, + end_point_z: float = 1.0, + node_reference = NodeReferenceType.REFERENCE_TYPE_L, + parameters = [True, 0.5], + offset_y: float = 0.0, + offset_z: float = 0.0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Node Tag + start_point_x (float): Start Point in X-Coordinate + start_point_y (float): Start Point in Y-Coordinate + start_point_z (float): Start Point in Z-Coordinate + end_point_x (float): End Point in X-Coordinate + end_point_y (float): End Point in Y-Coordinate + end_point_z (float): End Point in Z-Coordinate + node_reference (enum): Node Reference Enumeration + parameters (list): + if distance_from_start_relative: + parameters = [True, %] + if distance_from_start_absolute: + parameters = [False, magnitude] + offset_y (int): Offset in Y-Direction + offset_z (int): Offset in Z-Direction + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Node + clientObject = Model.clientModel.factory.create('ns0:node') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Node No. + clientObject.no = no + + # Node Type + clientObject.type = NodeType.TYPE_BETWEEN_TWO_POINTS.name + + # Coordinates start point + clientObject.between_two_points_start_point_coordinate_1= start_point_x + clientObject.between_two_points_start_point_coordinate_2= start_point_y + clientObject.between_two_points_start_point_coordinate_3= start_point_z + + # Coordinates end point + + clientObject.between_two_points_end_point_coordinate_1= end_point_x + clientObject.between_two_points_end_point_coordinate_2= end_point_y + clientObject.between_two_points_end_point_coordinate_3= end_point_z + + # Length between i and j + + clientObject.reference_type = node_reference.name + + # Distance between node k and start point + + if parameters[0]: + clientObject.distance_from_start_relative = parameters[1] + else: + clientObject.distance_from_start_absolute = parameters[1] + + # offset local coordinates + clientObject.offset_in_local_direction_y= offset_y + clientObject.offset_in_local_direction_z= offset_z + + # Comment + clientObject.comment = comment + + for key in params: + clientObject[key] = params[key] + + # Add Node to client model + Model.clientModel.service.set_node(clientObject) + + def OnLine(self, + no: int = 1, + line_number: int = 1, + node_reference = NodeReferenceType.REFERENCE_TYPE_L, + length_between_i_and_j: int = 1, + parameters = [True, 0.5], + comment: str = '', + params: dict = {}): + + ''' + Args: + line_number (int): Line Tag + node_reference (enum): Node Reference Enumeration + length_between_i_and_j (int): Length between 2 Nodes + parameters (list): + if distance_from_start_relative: + parameters = [True, %] + if distance_from_start_absolute: + parameters = [False, magnitude] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Node + clientObject = Model.clientModel.factory.create('ns0:node') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Node No. + clientObject.no = no + + # Reference Line + clientObject.on_line_reference_line = line_number + + # Node Type + clientObject.type = NodeType.TYPE_ON_LINE.name + + # Length between i and j + + clientObject.reference_type = node_reference.name + + clientObject.reference_object_projected_length = length_between_i_and_j + + # Distance between node k and start point + + if parameters[0]: + clientObject.distance_from_start_relative = parameters[1] + else: + clientObject.distance_from_start_absolute = parameters[1] + + # Comment + clientObject.comment = comment + + for key in params: + clientObject[key] = params[key] + + # Add Node to client model + Model.clientModel.service.set_node(clientObject) + + def OnMember(self, + no: int = 1, + member_number: int = 1, + node_reference = NodeReferenceType.REFERENCE_TYPE_L, + length_between_i_and_j: int = 1, + parameters = [True, 0.5], + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Node Tag + member_number (int): Member Tag + node_reference (enum): Node Reference Enumeration + length_between_i_and_j (int): Length between 2 Nodes + parameters (list): + if distance_from_start_relative: + parameters = [True, %] + if distance_from_start_absolute: + parameters = [False, magnitude] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Node + clientObject = Model.clientModel.factory.create('ns0:node') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Node No. + clientObject.no = no + + # Member Reference No. + clientObject.on_member_reference_member = member_number + + # Node Type + clientObject.type = NodeType.TYPE_ON_MEMBER.name + + # Length between i and j + + clientObject.reference_type = node_reference.name + + clientObject.reference_object_projected_length = length_between_i_and_j + + # Distance between node k and start point + + if parameters[0]: + clientObject.distance_from_start_relative = parameters[1] + else: + clientObject.distance_from_start_absolute = parameters[1] + + # Comment + clientObject.comment = comment + + for key in params: + clientObject[key] = params[key] + + # Add Node to client model + Model.clientModel.service.set_node(clientObject) diff --git a/package/RFEM/BasicObjects/opening.py b/package/RFEM/BasicObjects/opening.py new file mode 100644 index 00000000..b69ed130 --- /dev/null +++ b/package/RFEM/BasicObjects/opening.py @@ -0,0 +1,38 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString + +class Opening(): + def __init__(self, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Opening No. + clientObject.no = no + + # Boundary Lines No. + clientObject.boundary_lines = ConvertToDlString(lines_no) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Opening to client model + Model.clientModel.service.set_opening(clientObject) diff --git a/package/RFEM/BasicObjects/section.py b/package/RFEM/BasicObjects/section.py new file mode 100644 index 00000000..72ffbb7d --- /dev/null +++ b/package/RFEM/BasicObjects/section.py @@ -0,0 +1,43 @@ +from RFEM.initModel import Model, clearAtributes + +class Section(): + def __init__(self, + no: int = 1, + name: str = 'IPE 300', + material_no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Section No. + clientObject.no = no + + # Section nNme + clientObject.name = name + + # Material No. + clientObject.material = material_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Section to client model + Model.clientModel.service.set_section(clientObject) diff --git a/package/RFEM/BasicObjects/solid.py b/package/RFEM/BasicObjects/solid.py new file mode 100644 index 00000000..accd8bd2 --- /dev/null +++ b/package/RFEM/BasicObjects/solid.py @@ -0,0 +1,220 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SolidType + +class Solid(): + def __init__(self, + no: int = 1, + boundary_surfaces_no: str = '1 2', + material_no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid No. + clientObject.no = no + + # Surfaces No. (e.g. "5 7 8 12 5") + clientObject.boundary_surfaces = ConvertToDlString(boundary_surfaces_no) + + # Material + clientObject.material = material_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_solid(clientObject) + + def Standard(self, + no: int = 1, + boundary_surfaces_no: str = '1 2', + material_no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid No. + clientObject.no = no + + # Solid Type + clientObject.type = SolidType.TYPE_STANDARD.name + + # Surfaces No. (e.g. "5 7 8 12 5") + clientObject.boundary_surfaces = ConvertToDlString(boundary_surfaces_no) + + # Material + clientObject.material = material_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_solid(clientObject) + + def Gas(self, + no: int = 1, + boundary_surfaces_no: str = '1 2', + material_no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid No. + clientObject.no = no + + # Solid Type + clientObject.type = SolidType.TYPE_GAS.name + + # Surfaces No. (e.g. "5 7 8 12 5") + clientObject.boundary_surfaces = ConvertToDlString(boundary_surfaces_no) + + # Material + clientObject.material = material_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_solid(clientObject) + + def Contact(self, + no: int = 1, + boundary_surfaces_no: str = '1 2', + material_no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid No. + clientObject.no = no + + # Solid Type + clientObject.type = SolidType.TYPE_CONTACT.name + + # Surfaces No. (e.g. "5 7 8 12 5") + clientObject.boundary_surfaces = ConvertToDlString(boundary_surfaces_no) + + # Material + clientObject.material = material_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_solid(clientObject) + + def Soil(self, + no: int = 1, + boundary_surfaces_no: str = '1 2', + material_no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid No. + clientObject.no = no + + # Solid Type + clientObject.type = SolidType.TYPE_SOIL.name + + # Surfaces No. (e.g. "5 7 8 12 5") + clientObject.boundary_surfaces = ConvertToDlString(boundary_surfaces_no) + + # Material + clientObject.material = material_no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_solid(clientObject) \ No newline at end of file diff --git a/package/RFEM/BasicObjects/solidSet.py b/package/RFEM/BasicObjects/solidSet.py new file mode 100644 index 00000000..988c495c --- /dev/null +++ b/package/RFEM/BasicObjects/solidSet.py @@ -0,0 +1,122 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SetType + +class SolidSet(): + def __init__(self, + no: int = 1, + solids_no: str = '1 2', + solid_set_type = SetType.SET_TYPE_GROUP, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid Set No. + clientObject.no = no + + # Solids number + clientObject.solids = ConvertToDlString(solids_no) + + # Solid Set Type + clientObject.set_type = solid_set_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Set to client model + Model.clientModel.service.set_solid_set(clientObject) + + def ContinuousSolids(self, + no: int = 1, + solids_no: str = '1 2', + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Solid Set Tag + solids_no (str): Tags of Solids Contained Within Continuous Solid Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Solid Set + clientObject = Model.clientModel.factory.create('ns0:solid_set') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid Set No. + clientObject.no = no + + # Solids number + clientObject.solids = ConvertToDlString(solids_no) + + # Solid Set Type + clientObject.set_type = SetType.SET_TYPE_CONTINUOUS.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Set to client model + Model.clientModel.service.set_solid_set(clientObject) + + def GroupOfSolids(self, + no: int = 1, + solids_no: str = '1 2', + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Solid Set Tag + solids_no (str): Tags of Solids Contained Within Group of Solids Solid Set + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Solid Set + clientObject = Model.clientModel.factory.create('ns0:solid_set') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid Set No. + clientObject.no = no + + # Solids number + clientObject.solids = ConvertToDlString(solids_no) + + # Solid Set Type + clientObject.set_type = SetType.SET_TYPE_GROUP.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Set to client model + Model.clientModel.service.set_solid_set(clientObject) diff --git a/package/RFEM/BasicObjects/surface.py b/package/RFEM/BasicObjects/surface.py new file mode 100644 index 00000000..77dc43ef --- /dev/null +++ b/package/RFEM/BasicObjects/surface.py @@ -0,0 +1,412 @@ +from RFEM.enums import SurfaceGeometry, SurfaceLoadDistributionDirection, SurfaceType +from RFEM.initModel import * + +class Surface(): + def __init__(self, + no: int = 1, + boundary_lines_no: str = '1 2 3 4', + thickness: int = 1, + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Lines No. (e.g. "5 7 8 12") + clientObject.boundary_lines = ConvertToDlString(boundary_lines_no) + + # Thickness + clientObject.thickness = thickness + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_surface(clientObject) + + def Standard(self, + no: int = 1, + geometry_type = SurfaceGeometry.GEOMETRY_PLANE, + geometry_type_parameters = None, + boundary_lines_no: str = '1 2 3 4', + thickness: int = 1, + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + ''' + + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Surface Type + clientObject.type = SurfaceType.TYPE_STANDARD.name + + # Reptitive code between various functions migrated to a private method + self.type = SurfaceType.TYPE_STANDARD.name + self.boundary_lines_no = boundary_lines_no + self.geometry_type = geometry_type + self.geometry_type_parameters = geometry_type_parameters + self.thickness = thickness + self.comment = comment + self.params = params + self.clientObject = clientObject + self.__CreateGeometryAndSetToModel(self) + + def WithoutThickness(self, + no: int = 1, + geometry_type = SurfaceGeometry.GEOMETRY_PLANE, + geometry_type_parameters = None, + boundary_lines_no: str = '1 2 3 4', + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + ''' + + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Surface Type + clientObject.type = SurfaceType.TYPE_WITHOUT_THICKNESS.name + + # Reptitive code between various functions migrated to a private method + self.type = SurfaceType.TYPE_WITHOUT_THICKNESS.name + self.boundary_lines_no = boundary_lines_no + self.geometry_type = geometry_type + self.geometry_type_parameters = geometry_type_parameters + self.comment = comment + self.params = params + self.clientObject = clientObject + self.__CreateGeometryAndSetToModel(self) + + def Rigid(self, + no: int = 1, + geometry_type = SurfaceGeometry.GEOMETRY_PLANE, + geometry_type_parameters = None, + boundary_lines_no: str = '1 2 3 4', + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + ''' + + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Surface Type + clientObject.type = SurfaceType.TYPE_RIGID.name + + # Reptitive code between various functions migrated to a private method + self.type = SurfaceType.TYPE_RIGID.name + self.boundary_lines_no = boundary_lines_no + self.geometry_type = geometry_type + self.geometry_type_parameters = geometry_type_parameters + self.comment = comment + self.params = params + self.clientObject = clientObject + self.__CreateGeometryAndSetToModel(self) + + def Membrane(self, + no: int = 1, + geometry_type = SurfaceGeometry.GEOMETRY_PLANE, + geometry_type_parameters = None, + boundary_lines_no: str = '1 2 3 4', + thickness: int = 1, + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + ''' + + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Surface Type + clientObject.type = SurfaceType.TYPE_MEMBRANE.name + + # Reptitive code between various functions migrated to a private method + self.type = SurfaceType.TYPE_MEMBRANE.name + self.boundary_lines_no = boundary_lines_no + self.geometry_type = geometry_type + self.geometry_type_parameters = geometry_type_parameters + self.thickness = thickness + self.comment = comment + self.params = params + self.clientObject = clientObject + self.__CreateGeometryAndSetToModel(self) + + def WithoutMemberaneTension(self, + no: int = 1, + geometry_type = SurfaceGeometry.GEOMETRY_PLANE, + geometry_type_parameters = None, + boundary_lines_no: str = '1 2 3 4', + thickness: int = 1, + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + ''' + + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Surface Type + clientObject.type = SurfaceType.TYPE_WITHOUT_MEMBRANE_TENSION.name + + # Reptitive code between various functions migrated to a private method + self.type = SurfaceType.TYPE_WITHOUT_MEMBRANE_TENSION.name + self.boundary_lines_no = boundary_lines_no + self.geometry_type = geometry_type + self.geometry_type_parameters = geometry_type_parameters + self.thickness = thickness + self.comment = comment + self.params = params + self.clientObject = clientObject + self.__CreateGeometryAndSetToModel(self) + + def LoadDistribution(self, + no: int = 1, + boundary_lines_no: str = '1 2 3 4', + load_transfer_direction = SurfaceLoadDistributionDirection.LOAD_TRANSFER_DIRECTION_IN_X, + surface_weight_enabled: bool = False, + surface_weight: float = None, + excluded_members = None, + excluded_parallel_to_members = None, + excluded_lines = None, + excluded_parallel_to_lines = None, + loaded_members = None, + loaded_lines = None, + comment: str = '', + params: dict = {}): + + ''' + 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 + ''' + + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:surface') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface No. + clientObject.no = no + + # Surface Type + clientObject.type = SurfaceType.TYPE_LOAD_TRANSFER.name + + # Geometry Type + clientObject.geometry = SurfaceGeometry.GEOMETRY_PLANE.name + + # Lines No. (e.g. "5 7 8 12") + clientObject.boundary_lines = ConvertToDlString(boundary_lines_no) + + # Surface Load Distribution Direction + clientObject.load_transfer_direction = load_transfer_direction.name + + # Surface Weight + clientObject.is_surface_weight_enabled = surface_weight_enabled + clientObject.surface_weight = surface_weight + + # Loading Parameters + if excluded_members is not None: + clientObject.excluded_members = ConvertToDlString(excluded_members) + if excluded_parallel_to_members is not None: + clientObject.excluded_parallel_to_members = ConvertToDlString(excluded_parallel_to_members) + if excluded_lines is not None: + clientObject.excluded_lines = ConvertToDlString(excluded_lines) + if excluded_parallel_to_lines is not None: + clientObject.excluded_parallel_to_lines = ConvertToDlString(excluded_parallel_to_lines) + if loaded_members is not None: + clientObject.loaded_members = ConvertToDlString(loaded_members) + if loaded_lines is not None: + clientObject.loaded_lines = ConvertToDlString(loaded_lines) + if loaded_lines is None and loaded_members is None: + raise Exception('WARNING: Loaded lines and/or members need to be specified.') + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface to client model + Model.clientModel.service.set_surface(clientObject) + + def __CreateGeometryAndSetToModel(self): + + # Geometry Type + boundary_lines_list = self.boundary_lines_no.split(sep= ' ') + + if self.geometry_type.name == 'GEOMETRY_NURBS': + if len(self.geometry_type_parameters) != 4: + raise Exception('WARNING: The geometry type parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + for line in boundary_lines_list: + if Model.clientModel.service.get_line(int(line))['type'] != 'TYPE_NURBS': + raise Exception('WARNING: For a NURBS Surface, the boundary lines need to be NURBS Curves') + self.clientObject.nurbs_control_point_count_in_direction_u = self.geometry_type_parameters[0] + self.clientObject.nurbs_control_point_count_in_direction_v = self.geometry_type_parameters[1] + self.clientObject.nurbs_order_in_direction_u = self.geometry_type_parameters[2] + self.clientObject.nurbs_order_in_direction_v = self.geometry_type_parameters[3] + + elif self.geometry_type.name == 'GEOMETRY_PLANE': + self.geometry_type_parameters = None + + elif self.geometry_type.name == 'GEOMETRY_QUADRANGLE': + if len(self.geometry_type_parameters) != 4: + raise Exception('WARNING: The geometry type parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + self.clientObject.quadrangle_corner_node_1 = self.geometry_type_parameters[0] + self.clientObject.quadrangle_corner_node_2 = self.geometry_type_parameters[1] + self.clientObject.quadrangle_corner_node_3 = self.geometry_type_parameters[2] + self.clientObject.quadrangle_corner_node_4 = self.geometry_type_parameters[3] + + self.clientObject.geometry = self.geometry_type.name + + # Lines No. (e.g. "5 7 8 12") + self.clientObject.boundary_lines = ConvertToDlString(self.boundary_lines_no) + + # Thickness + if self.type == 'TYPE_STANDARD'or self.type == 'TYPE_MEMBRANE' or self.type == 'TYPE_WITHOUT_MEMBRANE_TENSION': + self.clientObject.thickness = self.thickness + + # Comment + self.clientObject.comment = self.comment + + # Adding optional parameters via dictionary + for key in self.params: + self.clientObject[key] = self.params[key] + + # Add Surface to client model + Model.clientModel.service.set_surface(self.clientObject) diff --git a/package/RFEM/BasicObjects/surfaceSet.py b/package/RFEM/BasicObjects/surfaceSet.py new file mode 100644 index 00000000..e3e3299f --- /dev/null +++ b/package/RFEM/BasicObjects/surfaceSet.py @@ -0,0 +1,123 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SetType + +class SurfaceSet(): + def __init__(self, + no: int = 1, + surfaces_no: str = '2 4 7', + surface_set_type = SetType.SET_TYPE_GROUP, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Set No. + clientObject.no = no + + # Surfaces number + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Surface Set Type + clientObject.set_type = surface_set_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Set to client model + Model.clientModel.service.set_surface_set(clientObject) + + def ContinuousSurfaces(self, + no: int = 1, + surfaces_no: str = '2 4 7', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Set No. + clientObject.no = no + + # Surfaces number + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Surface Set Type + clientObject.set_type = SetType.SET_TYPE_CONTINUOUS.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Set to client model + Model.clientModel.service.set_surface_set(clientObject) + + def GroupOfSurfaces(self, + no: int = 1, + surfaces_no: str = '2 4 7', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Set No. + clientObject.no = no + + # Surfaces number + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Surface Set Type + clientObject.set_type = SetType.SET_TYPE_GROUP.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Set to client model + Model.clientModel.service.set_surface_set(clientObject) diff --git a/package/RFEM/BasicObjects/thickness.py b/package/RFEM/BasicObjects/thickness.py new file mode 100644 index 00000000..94bf4820 --- /dev/null +++ b/package/RFEM/BasicObjects/thickness.py @@ -0,0 +1,669 @@ +from RFEM.enums import ThicknessDirection, ThicknessType +from RFEM.enums import ThicknessOrthotropyType, AddOn +from RFEM.enums import ThicknessShapeOrthotropySelfWeightDefinitionType +from RFEM.enums import ThicknessStiffnessMatrixSelfWeightDefinitionType +from RFEM.initModel import Model, GetAddonStatus, clearAtributes, SetAddonStatus +from math import pi + +class Thickness(): + def __init__(self, + no: int = 1, + name: str = None, + material_no: int = 1, + uniform_thickness_d: float = 0.20, + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_UNIFORM.name + + # Material No. + clientObject.material = material_no + + # Uniform Thickness d + clientObject.uniform_thickness = uniform_thickness_d + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def Uniform(self, + no: int = 1, + name: str = None, + material_no: int = 1, + properties = [0.2], + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Thickness Tag + name (str): Thickness Name + material_no (int): Tag of Material assigned to Thickness + properties (list): Magnitude of Thickness [Thickness] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_UNIFORM.name + + # Material No. + clientObject.material = material_no + + # Thickness Parameters + if properties is None: + raise Exception('WARNING: The properties parameter cannot be empty.') + clientObject.uniform_thickness = properties[0] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def Variable_3Nodes(self, + no: int = 1, + name: str = None, + material_no: int = 1, + properties = None, + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, thickness_d3, node_no_3] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_VARIABLE_THREE_NODES.name + + # Material No. + clientObject.material = material_no + + # Thickness Properties + if properties is None: + raise Exception('WARNING: The properties parameter cannot be empty') + elif len(properties) != 6: + raise Exception('WARNING: The properties parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + clientObject.thickness_1 = properties[0] + clientObject.node_1 = properties[1] + clientObject.thickness_2 = properties[2] + clientObject.node_2 = properties[3] + clientObject.thickness_3 = properties[4] + clientObject.node_3 = properties[5] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def Variable_2NodesAndDirection(self, + no: int = 1, + name: str = None, + material_no: int = 1, + properties = [0.18, 1, 0.18, 2, ThicknessDirection.THICKNESS_DIRECTION_IN_X], + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + properties = [thickness_d1, node_no_1, thickness_d2, node_no_2, direction] + comment (str, optional): Comments + params (dict, optional): Parameters + + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_VARIABLE_TWO_NODES_AND_DIRECTION.name + + # Material No. + clientObject.material = material_no + + # Thickness Properties + if len(properties) != 5: + raise Exception('WARNING: The properties parameter needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.thickness_1 = properties[0] + clientObject.node_1 = properties[1] + clientObject.thickness_2 = properties[2] + clientObject.node_2 = properties[3] + clientObject.direction = properties[4].name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def Variable_4SurfaceCorners(self, + no: int = 1, + name: str = None, + material_no: int = 1, + properties = None, + comment: str = '', + params: dict = {}): + + ''' + Args: + 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 + 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 + + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_VARIABLE_FOUR_SURFACE_CORNERS.name + + # Material No. + clientObject.material = material_no + + # Thickness Properties + if properties is None: + raise Exception('WARNING: The properties parameter cannot be empty') + elif len(properties) != 8: + raise Exception('WARNING: The properties parameter needs to be of length 8. Kindly check list inputs for completeness and correctness.') + clientObject.thickness_1 = properties[0] + clientObject.node_1 = properties[1] + clientObject.thickness_2 = properties[2] + clientObject.node_2 = properties[3] + clientObject.thickness_3 = properties[4] + clientObject.node_3 = properties[5] + clientObject.thickness_4 = properties[6] + clientObject.node_4 = properties[7] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def Variable_Circle(self, + no: int = 1, + name: str = None, + material_no: int = 1, + properties = None, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Thickness Tag + name (str): Thickness Name + material_no (int): Tag of Material assigned to Thickness + properties (list): Properties for Circular Thickness Definition + properties = [thickness_circle_center_dC, thickness_circle_line_dR] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_VARIABLE_CIRCLE.name + + # Material No. + clientObject.material = material_no + + # Thickness Properties + if properties is None: + raise Exception('WARNING: The properties parameter cannot be empty') + elif len(properties) != 2: + raise Exception('WARNING: The properties parameter needs to be of length 2. Kindly check list inputs for completeness and correctness.') + clientObject.thickness_circle_center = properties[0] + clientObject.thickness_circle_line = properties[1] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def Layers(self, + no: int = 1, + name: str = None, + layers = [[0, 1, 200, 0.0, '']], + comment: str = '', + params: dict = {}): + + ''' + NOTE: Available only for Special Solution Add-on Multilayer Surfaces. + + Args: + no (int): Thickness Tag + name (str): Thickness Name + material_no (int): Tag of Material assigned to Thickness + properties (list): Nested List of Layer Properties + properties: [[thickness_type, material, thickness, rotation, comment], ...] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Check if Multilayer Surfaces Add-on is ON. + if not GetAddonStatus(Model.clientModel, AddOn.multilayer_surfaces_design_active): + SetAddonStatus(Model.clientModel, AddOn.multilayer_surfaces_design_active, True) + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_LAYERS.name + + # Layers + clientObject.layers_reference_table = Model.clientModel.factory.create('ns0:thickness.layers_reference_table') + + for i,j in enumerate(layers): + tlrt = Model.clientModel.factory.create('ns0:thickness_layers_reference_table') + tlrt.no = no + tlrt.layer_no = i+1 + tlrt.layer_type = None + tlrt.thickness_type = layers[i][0] + tlrt.material = layers[i][1] + tlrt.thickness = layers[i][2] + tlrt.angle = layers[i][3] * (pi/180) + tlrt.connection_with_other_topological_elements = False + tlrt.comment = layers[i][4] + tlrt.specific_weight = 0 + tlrt.weight = 0 + + clientObject.layers_reference_table.thickness_layers_reference_table.append(tlrt) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def ShapeOrthotropy(self, + no: int = 1, + name: str = None, + material_no: int = 1, + orthotropy_type = ThicknessOrthotropyType.EFFECTIVE_THICKNESS, + rotation_beta: float = 0, + consideration_of_self_weight = [ThicknessShapeOrthotropySelfWeightDefinitionType.SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, 0.18], + parameters = [0.18, 0.18], + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Thickness Tag + name (str): Thickness Name + material_no (int): Tag of Material assigned to Thickness + 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.EFFECTIVE_THICKNESS: + parameters = [effective_thickness_x, effective_thickness_y] + for orthotropy_type == ThicknessOrthotropyType.COUPLING: + parameters = [coupling_thickness, coupling_spacing, coupling_width] + for orthotropy_type == ThicknessOrthotropyType.UNIDIRECTIONAL_RIBBED_PLATE: + parameters = [slab_thickness, rib_height, rib_spacing, rib_width] + for orthotropy_type == ThicknessOrthotropyType.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.TRAPEZOIDAL_SHEET: + parameters = [sheet_thickness, total_profile_height, rib_spacing, top_flange_width, bottom_flange_width] + for orthotropy_type == ThicknessOrthotropyType.HOLLOW_CORE_SLAB: + parameters = [slab_thickness, void_spacing, void_diameter] + for orthotropy_type == ThicknessOrthotropyType.GRILLAGE: + parameters = [slab_thickness, rib_spacing_x, rib_spacing_y, rib_width_x, rib_width_y] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_SHAPE_ORTHOTROPY.name + + # Material No. + clientObject.material = material_no + + # Orthotropy Type + clientObject.orthotropy_type = 'ORTHOTROPIC_THICKNESS_TYPE_' + orthotropy_type.name + + # Rotation Beta + clientObject.orthotropy_rotation_beta = rotation_beta * (pi/180) + + # Consideration of Self-Weight + if len(consideration_of_self_weight) != 2: + raise Exception('WARNING: The consideration of self-weight parameter needs to be of length 2. Kindly check list inputs for completeness and correctness.') + clientObject.shape_orthotropy_self_weight_definition_type = consideration_of_self_weight[0].name + if consideration_of_self_weight[0].name == 'SELF_WEIGHT_COMPUTED_FROM_PARAMETERS' or consideration_of_self_weight[0].name == 'SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS': + clientObject.orthotropy_fictitious_thickness = consideration_of_self_weight[1] + elif consideration_of_self_weight[0].name == 'SELF_WEIGHT_DEFINED_VIA_WEIGHT': + clientObject.shape_orthotropy_self_weight = consideration_of_self_weight[1] + + # Shape Orthotropy Parameters + if orthotropy_type.name == 'EFFECTIVE_THICKNESS': + if len(parameters) != 2: + raise Exception('WARNING: The parameters needs to be of length 2. Kindly check list inputs for completeness and correctness.') + clientObject.shape_orthotropy_effective_thickness_x = parameters[0] + clientObject.shape_orthotropy_effective_thickness_y = parameters[1] + elif orthotropy_type.name == 'COUPLING': + if len(parameters) != 3: + raise Exception('WARNING: The parameters needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.coupling_thickness = parameters[0] + clientObject.coupling_spacing = parameters[1] + clientObject.coupling_width = parameters[2] + elif orthotropy_type.name == 'UNIDIRECTIONAL_RIBBED_PLATE': + if len(parameters) != 4: + raise Exception('WARNING: The parameters needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.slab_thickness = parameters[0] + clientObject.rib_height = parameters[1] + clientObject.rib_spacing = parameters[2] + clientObject.rib_width = parameters[3] + elif orthotropy_type.name == 'BIDIRECTIONAL_RIBBED_PLATE': + if len(parameters) != 7: + raise Exception('WARNING: The parameters needs to be of length 7. Kindly check list inputs for completeness and correctness.') + clientObject.slab_thickness = parameters[0] + clientObject.rib_height_x = parameters[1] + clientObject.rib_height_y = parameters[2] + clientObject.rib_spacing_x = parameters[3] + clientObject.rib_spacing_y = parameters[4] + clientObject.rib_width_x = parameters[5] + clientObject.rib_width_y = parameters[6] + elif orthotropy_type.name == 'TRAPEZOIDAL_SHEET': + if len(parameters) != 5: + raise Exception('WARNING: The parameters needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.sheet_thickness = parameters[0] + clientObject.total_profile_height = parameters[1] + clientObject.rib_spacing = parameters[2] + clientObject.top_flange_width = parameters[3] + clientObject.bottom_flange_width = parameters[4] + elif orthotropy_type.name == 'HOLLOW_CORE_SLAB': + if len(parameters) != 3: + raise Exception('WARNING: The parameters needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.slab_thickness = parameters[0] + clientObject.void_spacing = parameters[1] + clientObject.void_diameter = parameters[2] + elif orthotropy_type.name == 'GRILLAGE': + if len(parameters) != 5: + raise Exception('WARNING: The parameters needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.slab_thickness = parameters[0] + clientObject.rib_spacing_x = parameters[1] + clientObject.rib_spacing_y = parameters[2] + clientObject.rib_width_x = parameters[3] + clientObject.rib_width_y = parameters[4] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) + + def StiffnessMatrix(self, + no: int = 1, + name: str = None, + material_no: int = 1, + rotation_beta: float = 0, + consideration_of_self_weight = [ThicknessStiffnessMatrixSelfWeightDefinitionType.SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY, 0.2, 0.0], + coefficient_of_thermal_expansion: float = 0, + stiffness_matrix = [[0, 0, 0, 0, 0, 0],[0, 0, 0],[0, 0, 0, 0, 0, 0],[0, 0, 0, 0, 0, 0]], + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Thickness Tag + name (str): Thickness Name + 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) + Element entry overview : [[Bending/Torsional Stiffness Elements (Nm)], + [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 + ''' + + # Client model | Thickness + clientObject = Model.clientModel.factory.create('ns0:thickness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Thickness No. + clientObject.no = no + + # Thickness Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Thickness Type + clientObject.type = ThicknessType.TYPE_STIFFNESS_MATRIX.name + + # Material No. + clientObject.material = material_no + + # Rotation Beta + clientObject.orthotropy_rotation_beta = rotation_beta * (pi/180) + + # Consideration of Self-Weight + clientObject.stiffness_matrix_self_weight_definition_type = consideration_of_self_weight[0].name + if consideration_of_self_weight[0].name == 'SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY': + clientObject.orthotropy_fictitious_thickness = consideration_of_self_weight[1] + clientObject.stiffness_matrix_bulk_density = consideration_of_self_weight[2] + elif consideration_of_self_weight[0].name == 'SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY': + clientObject.orthotropy_fictitious_thickness = consideration_of_self_weight[1] + clientObject.stiffness_matrix_area_density = consideration_of_self_weight[2] + elif consideration_of_self_weight[0].name == 'SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_BULK_DENSITY_AND_AREA_DENSITY': + clientObject.stiffness_matrix_bulk_density = consideration_of_self_weight[1] + clientObject.stiffness_matrix_area_density = consideration_of_self_weight[2] + + # Coefficient of Thermal Expansion + clientObject.stiffness_matrix_coefficient_of_thermal_expansion = coefficient_of_thermal_expansion + + # Stiffness Matrix - Bending/Torsional Stiffness Elements + array_count = [] + for item_length in stiffness_matrix: + array_count.append(len(item_length)) + if array_count != [6, 3, 6, 6]: + raise Exception('WARNING: Kindly check Stiffness Matrix inputs for completeness and correctness.') + clientObject.D11, clientObject.D12, clientObject.D13 = stiffness_matrix[0][0], stiffness_matrix[0][1], stiffness_matrix[0][2] + clientObject.D22, clientObject.D23, clientObject.D33 = stiffness_matrix[0][3], stiffness_matrix[0][4], stiffness_matrix[0][5] + + # Stiffness Matrix - Shear Stiffness Elements + clientObject.D44, clientObject.D45, clientObject.D55 = stiffness_matrix[1][0], stiffness_matrix[1][1], stiffness_matrix[1][2] + + # Stiffness Matrix - Membrane Stiffness Elements + clientObject.D66, clientObject.D67, clientObject.D68 = stiffness_matrix[2][0], stiffness_matrix[2][1], stiffness_matrix[2][2] + clientObject.D77, clientObject.D78, clientObject.D88 = stiffness_matrix[2][3], stiffness_matrix[2][4], stiffness_matrix[2][5] + + # Stiffness Matrix - Eccentric Stiffness Elements + clientObject.D16, clientObject.D17, clientObject.D18 = stiffness_matrix[3][0], stiffness_matrix[3][1], stiffness_matrix[3][2] + clientObject.D27, clientObject.D28, clientObject.D38 = stiffness_matrix[3][3], stiffness_matrix[3][4], stiffness_matrix[3][5] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Thickness to client model + Model.clientModel.service.set_thickness(clientObject) diff --git a/package/RFEM/Calculate/meshSettings.py b/package/RFEM/Calculate/meshSettings.py new file mode 100644 index 00000000..5c717ab7 --- /dev/null +++ b/package/RFEM/Calculate/meshSettings.py @@ -0,0 +1,171 @@ +from RFEM.initModel import Model, GetAddonStatus +from RFEM.enums import AddOn + +class MeshSettings(): + ComonMeshConfig: dict = { + 'general_target_length_of_fe': None, + 'general_maximum_distance_between_node_and_line': None, + 'general_maximum_number_of_mesh_nodes': None, + 'members_number_of_divisions_for_special_types': None, + 'members_activate_division_for_large_deformation_and_post_critical_analysis': None, + 'members_number_of_divisions_for_result_diagram': None, + 'members_number_of_divisions_for_min_max_values': None, + 'members_use_division_for_concrete_members': None, + 'members_number_of_divisions_for_concrete_members': None, + 'members_use_division_for_straight_members': None, + 'members_division_for_straight_members_type': None, + 'members_length_of_fe': None, + 'members_minimum_number_of_divisions': None, + 'members_use_division_for_members_with_nodes': None, + 'surfaces_maximum_ratio_of_fe': None, + 'surfaces_maximum_out_of_plane_inclination': None, + 'surfaces_mesh_refinement': None, + 'surfaces_relationship': None, + 'surfaces_integrate_also_unutilized_objects': None, + 'surfaces_shape_of_finite_elements': None, + 'surfaces_same_squares': None, + 'surfaces_triangles_for_membranes': None, + 'surfaces_mapped_mesh_preferred': None, + 'solids_use_refinement_if_containing_close_nodes': None, + 'solids_maximum_number_of_elements': None} + SurfacesMeshQualityConfig: dict = { + 'mesh_quality_color_indicator_ok_color': None, + 'mesh_quality_color_indicator_warning_color': None, + 'mesh_quality_color_indicator_failure_color': None, + 'QualityCriteriaConfig': { + 'quality_criterion_check_aspect_ratio': None, + 'quality_criterion_check_aspect_ratio_warning': None, + 'quality_criterion_check_aspect_ratio_failure': None, + 'quality_criterion_parallel_deviations': None, + 'quality_criterion_parallel_deviations_warning': None, + 'quality_criterion_parallel_deviations_failure': None, + 'quality_criterion_corner_angles_of_triangle_elements': None, + 'quality_criterion_corner_angles_of_triangle_elements_warning': None, + 'quality_criterion_corner_angles_of_triangle_elements_failure': None, + 'quality_criterion_corner_angles_of_quadrangle_elements': None, + 'quality_criterion_corner_angles_of_quadrangle_elements_warning': None, + 'quality_criterion_corner_angles_of_quadrangle_elements_failure': None, + 'quality_criterion_warping_of_membrane_elements': None, + 'quality_criterion_warping_of_membrane_elements_warning': None, + 'quality_criterion_warping_of_membrane_elements_failure': None, + 'quality_criterion_warping_of_non_membrane_elements': None, + 'quality_criterion_warping_of_non_membrane_elements_warning': None, + 'quality_criterion_warping_of_non_membrane_elements_failure': None, + 'quality_criterion_jacobian_ratio': None, + 'quality_criterion_jacobian_ratio_warning': None, + 'quality_criterion_jacobian_ratio_failure': None}} + SolidsMeshQualityConfig: dict = { + 'mesh_quality_color_indicator_ok_color': None, + 'mesh_quality_color_indicator_warning_color': None, + 'mesh_quality_color_indicator_failure_color': None, + 'QualityCriteriaConfig': { + 'quality_criterion_check_aspect_ratio': None, + 'quality_criterion_check_aspect_ratio_warning': None, + 'quality_criterion_check_aspect_ratio_failure': None, + 'quality_criterion_parallel_deviations': None, + 'quality_criterion_parallel_deviations_warning': None, + 'quality_criterion_parallel_deviations_failure': None, + 'quality_criterion_corner_angles_of_triangle_elements': None, + 'quality_criterion_corner_angles_of_triangle_elements_warning': None, + 'quality_criterion_corner_angles_of_triangle_elements_failure': None, + 'quality_criterion_corner_angles_of_quadrangle_elements': None, + 'quality_criterion_corner_angles_of_quadrangle_elements_warning': None, + 'quality_criterion_corner_angles_of_quadrangle_elements_failure': None, + 'quality_criterion_warping': None, + 'quality_criterion_warping_warning': None, + 'quality_criterion_warping_failure': None, + 'quality_criterion_jacobian_ratio': None, + 'quality_criterion_jacobian_ratio_warning': None, + 'quality_criterion_jacobian_ratio_failure': None}} + WindSimulationMeshConfig: dict = { + 'windsimulation_mesh_config_value_simplify_model': None, + 'windsimulation_mesh_config_value_determine_details_by': None, + 'windsimulation_mesh_config_value_level_of_details': None, + 'windsimulation_mesh_config_value_detail_size': None, + 'windsimulation_mesh_config_value_small_openings_closure_type': None, + 'windsimulation_mesh_config_value_small_openings_closure_value': None, + 'windsimulation_mesh_config_value_optimized_member_topology': None, + 'windsimulation_mesh_config_value_optimized_member_topo_value': None, + 'windsimulation_mesh_config_value_active_objects_only': None, + 'windsimulation_mesh_config_value_terrain': None, + 'windsimulation_mesh_config_value_terrain_from_model': None, + 'windsimulation_mesh_config_value_terrain_objects_id': None, + 'windsimulation_mesh_config_value_terrain_objects_all': None, + 'windsimulation_mesh_config_value_surrounding_model': None, + 'windsimulation_mesh_config_value_surrounding_model_ifc_objects_id': None, + 'windsimulation_mesh_config_value_surrounding_model_ifc_objects_all': None, + 'windsimulation_mesh_config_value_surrounding_model_visual_objects_id': None, + 'windsimulation_mesh_config_value_surrounding_model_visual_objects_all': None, + 'windsimulation_mesh_config_value_keep_results_if_mesh_deleted': None, + 'windsimulation_mesh_config_value_consider_surface_thickness': None, + 'windsimulation_mesh_config_value_run_rwind_silent': None} + + def __init__(self, + commonConfig: dict = ComonMeshConfig, + surfaceConfig: dict = SurfacesMeshQualityConfig, + solidConfig: dict = SolidsMeshQualityConfig, + windConfig: dict = WindSimulationMeshConfig): + """ + The object is automaticaly created therefore we can assume that it will not be created but only updated. + Only posititve values are recognized. + + Args: + commonConfig: common parameters settings + surfaceConfig: surface specific parameters + solidConfig: solid specific parameters + windConfig: wind specific parameters; use only when Wind Simulation Add-on is active + """ + # Get current mesh settings + config = Model.clientModel.service.get_mesh_settings() + + clientObject = {} + for i in config: + if i[0] == 'windSimulationMeshConfig': + if GetAddonStatus(Model.clientModel, AddOn.wind_simulation_active): + clientObject[i[0]] = config[i[0]] + else: + clientObject[i[0]] = config[i[0]] + + # No parameter can be set to None + for key in commonConfig: + if commonConfig[key]: + clientObject[key] = commonConfig[key] + for key in surfaceConfig: + if key == 'QualityCriteriaConfig': + for key_ in surfaceConfig['QualityCriteriaConfig']: + if surfaceConfig['QualityCriteriaConfig'][key_]: + clientObject['SurfacesMeshQualityConfig']['QualityCriteriaConfig'][key_] = surfaceConfig['QualityCriteriaConfig'][key_] + elif surfaceConfig[key]: + clientObject['SurfacesMeshQualityConfig'][key] = surfaceConfig[key] + for key in solidConfig: + if key == 'QualityCriteriaConfig': + for key_ in solidConfig['QualityCriteriaConfig']: + if solidConfig['QualityCriteriaConfig'][key_]: + clientObject['SolidsMeshQualityConfig']['QualityCriteriaConfig'][key_] = solidConfig['QualityCriteriaConfig'][key_] + elif solidConfig[key]: + clientObject['SolidsMeshQualityConfig'][key] = solidConfig[key] + if GetAddonStatus(Model.clientModel, AddOn.wind_simulation_active): + for key in windConfig: + if windConfig[key]: + clientObject['windSimulationMeshConfig'][key] = windConfig[key] + + # Add Mesh Settings to client model + Model.clientModel.service.set_mesh_settings(clientObject) + + def get_mesh_settings(self): + return Model.clientModel.service.get_mesh_settings() + + def set_mesh_settings(self, all_settings): + new_sett = {} + + for i in all_settings: + if i[0] == 'windSimulationMeshConfig': + if GetAddonStatus(Model.clientModel, AddOn.wind_simulation_active): + new_sett['wind_simulation_active'] = all_settings['wind_simulation_active'] + else: + new_sett[i[0]] = all_settings[i[0]] + + Model.clientModel.service.set_mesh_settings(new_sett) + + def get_model_info(self): + return Model.clientModel.service.get_model_info() diff --git a/package/RFEM/Calculate/optimizationSettings.py b/package/RFEM/Calculate/optimizationSettings.py new file mode 100644 index 00000000..a3a028d9 --- /dev/null +++ b/package/RFEM/Calculate/optimizationSettings.py @@ -0,0 +1,37 @@ +from RFEM.initModel import Model +from RFEM.enums import * + +class OptimizationSettings(): + def __init__(self, + general_optimization_active = True, + general_keep_best_number_model_mutations = 10, + general_optimize_on = OptimizeOnType.E_OPTIMIZE_ON_TYPE_MIN_WHOLE_WEIGHT, + general_optimizer = Optimizer.E_OPTIMIZER_TYPE_ALL_MUTATIONS, + general_number_random_mutations = 0.2): + """ + The object is automaticaly created therefore we can assume, + that it will not be created but only updated/changed. + + Args: + general_optimization_active (bool): Set Optimization Active + general_keep_best_number_model_mutations (int): Keep best number of model mutations + general_optimize_on (enum): Optimize on + general_optimizer (enum): Optimizer + general_number_random_mutations (float): Number of random mutations + """ + + opt_settings = Model.clientModel.service.get_optimization_settings() + opt_settings.general_optimization_active = general_optimization_active + opt_settings.general_keep_best_number_model_mutations = general_keep_best_number_model_mutations + opt_settings.general_optimize_on = general_optimize_on.name + opt_settings.general_optimizer = general_optimizer.name + opt_settings.general_number_random_mutations = general_number_random_mutations + + # Set Optimization settings to client model + Model.clientModel.service.set_optimization_settings(opt_settings) + + def get_optimization_settings(self): + return Model.clientModel.service.get_optimization_settings() + + def set_optimization_settings(self, opt_settings): + Model.clientModel.service.set_optimization_settings(opt_settings) \ No newline at end of file diff --git a/package/RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py b/package/RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py new file mode 100644 index 00000000..1c822113 --- /dev/null +++ b/package/RFEM/ConcreteDesign/ConcreteServiceabilityConfigurations.py @@ -0,0 +1,65 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import * + +class ConcreteServiceabilityConfiguration(): + + def __init__(self, + no: int = 1, + name: str = 'SLS', + members = '1', + member_sets = '', + surfaces = '', + surface_sets = '', + nodes = '', + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Configuration Tag + name (str): User Defined Name + members (str): Assigned Members + member_sets (str): Assigned Member Sets + surfaces (str): Assigned Surfaces + surface_sets (str): Assigned Surface Sets + nodes (str): Assigned Nodes + comment (str, optional): Comment + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = Model.clientModel.factory.create('ns0:sls_configuration') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.assigned_to_members = ConvertToDlString(members) + + # Assigned Member Sets + clientObject.assigned_to_member_sets = ConvertToDlString(member_sets) + + # Assigned Surfaces + clientObject.assigned_to_surfaces = ConvertToDlString(surfaces) + + # Assigned Surface Sets + clientObject.assigned_to_surface_sets = ConvertToDlString(surface_sets) + + #Assinged Nodes + clientObject.assigned_to_nodes = ConvertToDlString(nodes) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_sls_configuration(clientObject) \ No newline at end of file diff --git a/package/RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py b/package/RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py new file mode 100644 index 00000000..7896e7c9 --- /dev/null +++ b/package/RFEM/ConcreteDesign/ConcreteUltimateConfigurations.py @@ -0,0 +1,65 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import * + +class ConcreteUltimateConfiguration(): + + def __init__(self, + no: int = 1, + name: str = 'ULS', + members = '1', + member_sets = '', + surfaces = '', + surface_sets = '', + nodes = '', + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Configuration Tag + name (str): User Defined Name + members (str): Assigned Members + member_sets (str): Assigned Member Sets + surfaces (str): Assigned Surfaces + surface_sets (str): Assigned Surface Sets + nodes (str): Assigned Nodes + comment (str, optional): Comment + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = Model.clientModel.factory.create('ns0:uls_configuration') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.assigned_to_members = ConvertToDlString(members) + + # Assigned Member Sets + clientObject.assigned_to_member_sets = ConvertToDlString(member_sets) + + # Assigned Surfaces + clientObject.assigned_to_surfaces = ConvertToDlString(surfaces) + + # Assigned Surface Sets + clientObject.assigned_to_surface_sets = ConvertToDlString(surface_sets) + + #Assinged Nodes + clientObject.assigned_to_nodes = ConvertToDlString(nodes) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_uls_configuration(clientObject) \ No newline at end of file diff --git a/package/RFEM/ConcreteDesign/__init__.py b/package/RFEM/ConcreteDesign/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/ConcreteDesign/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/Imperfections/__init__.py b/package/RFEM/Imperfections/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/Imperfections/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/Imperfections/imperfectionCase.py b/package/RFEM/Imperfections/imperfectionCase.py new file mode 100644 index 00000000..1366d131 --- /dev/null +++ b/package/RFEM/Imperfections/imperfectionCase.py @@ -0,0 +1,37 @@ +from RFEM.initModel import Model, clearAtributes + +class ImperfectionCase(): + def __init__(self, + no: int = 1, + assigned_to_load_cases: str = '1', + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Imperfection Case No. + clientObject.no = no + + # Assign to Load Cases + clientObject.assigned_to_load_cases = assigned_to_load_cases + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Imperfection Case to client model + Model.clientModel.service.set_imperfection_case(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/__init__.py b/package/RFEM/LoadCasesAndCombinations/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/LoadCasesAndCombinations/designSituation.py b/package/RFEM/LoadCasesAndCombinations/designSituation.py new file mode 100644 index 00000000..626e0362 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/designSituation.py @@ -0,0 +1,83 @@ +from RFEM.initModel import Model,clearAtributes + +class DesignSituation(): + def __init__(self, + no: int = 1, + user_defined_name: bool = False, + name = None, + active: bool = True, + design_situation_type: int = 6122, + comment: str = '', + params: dict = {}): + + """ + Args: + no (int): Design Situation Tag + user_defined_name (bool): Enable/Disable User-Defined Name + 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, + 6994 = ULS (EQU) - Accidental - psi-2,1, + 6997 = ULS (EQU) - Seismic, + 7007 = ULS (STR/GEO) - Permanent and transient - Eq. 6.10, + 7008 = ULS (STR/GEO) - Permanent and transient - Eq. 6.10a and 6.10b, + 7010 = ULS (STR/GEO) - Accidental - psi-1,1, + 7011 = ULS (STR/GEO) - Accidental - psi-2,1, + 7014 = ULS (STR/GEO) - Seismic, + 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, + 6994 = ULS (EQU) - Accidental - psi-2,1, + 6995 = ULS (EQU) - Accidental - Snow - psi-1,1, + 6996 = ULS (EQU) - Accidental - Snow - psi-2,1, + 6997 = ULS (EQU) - Seismic, + 7007 = ULS (STR/GEO) - Permanent and transient - Eq. 6.10, + 7010 = ULS (STR/GEO) - Accidental - psi-1,1, + 7011 = ULS (STR/GEO) - Accidental - psi-2,1, + 7012 = ULS (STR/GEO) - Accidental - Snow - psi-1,1, + 7013 = ULS (STR/GEO) - Accidental - Snow - psi-2,1, + 7014 = ULS (STR/GEO) - Seismic, + 6193 = SLS - Characteristic, + 6194 = SLS - Frequent, + 6195 = SLS - Quasi-permanent. + comment (str, optional): Comments + params (dict, optional): Parameters + """ + + # Client model | Design Situation + clientObject = Model.clientModel.factory.create('ns0:design_situation') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Design Situation No. + clientObject.no = no + + # Design Situation Name + clientObject.user_defined_name_enabled = user_defined_name + if user_defined_name: + if name is None: + raise Exception('WARNING: A user defined design situation name was requested. As such, the name parameter cannot be empty.') + clientObject.name = name + + # Design Situation Active + clientObject.active = active + + # Design Situation Type + clientObject.design_situation_type = design_situation_type + + # Design Situation Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Design Situation to client model + Model.clientModel.service.set_design_situation(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/loadCase.py b/package/RFEM/LoadCasesAndCombinations/loadCase.py new file mode 100644 index 00000000..a11d02a3 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/loadCase.py @@ -0,0 +1,167 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import AnalysisType + +DIN_Action_Category = {'1A': 'Permanent | G', '1B': 'Permanent - small fluctuations | G*', '1C': 'Permanent/Imposed | Gq', '2': 'Prestress | P', + '3A': 'Imposed loads - category A: domestic, residential areas | QI A', '3B': 'Imposed loads - category B: office areas | QI B', + '3C': 'Imposed loads - category C: congregation areas | QI C', '3D': 'Imposed loads - category D: shopping areas | QI D', + '3E': 'Imposed loads - category E: storage areas | QI E', '3F': 'Imposed loads - category F: traffic area - vehicle weight <= 30 kN | QI F', + '3G': 'Imposed loads - category G: traffic area - vehicle weight <= 160 kN | QI G', '3H': 'Imposed loads - category H: roofs | QI H', + '4A': 'Snow / Ice loads - H <= 1000 m | Qs', '4B': 'Snow / Ice loads - H > 1000 m | Qs', '5': 'Wind | Qw', '6': 'Temperature (non-fire) | QT', + '7': 'Foundation subsidence | Qf', '8': 'Other actions | Qo', '9': 'Accidental actions | A', '10': 'Seismic actions | AE', 'None': 'None | None'} + +class LoadCase(): + + def __init__(self, + no: int = 1, + name: str = 'Self-weight', + self_weight: list = [True, 0.0, 0.0, 1.0], + comment: str = 'Comment', + params: dict = {}): + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:load_case') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Load Case No. + clientObject.no = no + + # Load Case Name + clientObject.name = name + + # To Solve + clientObject.to_solve = True + + # Analysis Type + clientObject.analysis_type = AnalysisType.ANALYSIS_TYPE_STATIC.name + clientObject.static_analysis_settings = 1 + + # Action Category + clientObject.action_category = 'Permanent | G' + + # Self-weight Considerations + clientObject.self_weight_active = self_weight[0] + if not isinstance(self_weight[0], bool): + raise Exception('WARNING: Entry at index 0 of Self-Weight parameter to be of type bool') + if self_weight[0]: + if len(self_weight) != 4: + raise Exception('WARNING: Self-weight is activated and therefore requires a list definition of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.self_weight_factor_x = self_weight[1] + clientObject.self_weight_factor_y = self_weight[2] + clientObject.self_weight_factor_z = self_weight[3] + else: + if len(self_weight) != 1: + raise Exception('WARNING: Self-weight is deactivated and therefore requires a list definition of length 1. Kindly check list inputs for completeness and correctness.') + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Case to client model + Model.clientModel.service.set_load_case(clientObject) + + def StaticAnalysis(self, + no: int = 1, + name: str = 'Self-weight', + to_solve: bool = True, + analysis_settings_no: int = 1, + action_category= DIN_Action_Category['1A'], + self_weight = [True, 0.0, 0.0, 10.0], + comment: str = 'Comment', + params: dict = {}): + ''' + Args: + no (int): Load Case Tag + name (str): Load Case Name + to_solve (bool): Enable/Disbale Load Case Solver Status + analysis_type (enum): Analysis Type Enumeration + analysis_settings_no (int): Analysis Settings Number + action_category (dict): Action Category Key + 1A = Permanent | G + 1B = Permanent - small fluctuations | G* + 1C = Permanent/Imposed | Gq + 2 = Prestress | P + 3A = Imposed loads - category A: domestic, residential areas | QI A + 3B = Imposed loads - category B: office areas | QI B + 3C = Imposed loads - category C: congregation areas | QI C + 3D = Imposed loads - category D: shopping areas | QI D + 3E = Imposed loads - category E: storage areas | QI E + 3F = Imposed loads - category F: traffic area - vehicle weight <= 30 kN | QI F + 3G = Imposed loads - category G: traffic area - vehicle weight <= 160 kN | QI G + 3H = Imposed loads - category H: roofs | QI H + 4A = Snow / Ice loads - H <= 1000 m | Qs + 4B = Snow / Ice loads - H > 1000 m | Qs + 5 = Wind | Qw + 6 = Temperature (non-fire) | QT + 7 = Foundation subsidence | Qf + 8 = Other actions | Qo + 9 = Accidental actions | A + 10 = Seismic actions | AE + None = None | None + self_weight (list): 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; + self_weight = [False] + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + + # Client model | Load Case + clientObject = Model.clientModel.factory.create('ns0:load_case') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Load Case No. + clientObject.no = no + + # Load Case Name + clientObject.name = name + + # To Solve + clientObject.to_solve = to_solve + + # Analysis Type + clientObject.analysis_type = AnalysisType.ANALYSIS_TYPE_STATIC.name + clientObject.static_analysis_settings = analysis_settings_no + + # Action Category + clientObject.action_category = action_category + + # Self-weight Considerations + clientObject.self_weight_active = self_weight[0] + if not isinstance(self_weight[0], bool): + raise Exception('WARNING: Entry at index 0 of Self-Weight parameter to be of type bool') + if self_weight[0]: + if len(self_weight) != 4: + raise Exception('WARNING: Self-weight is activated and therefore requires a list definition of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.self_weight_factor_x = self_weight[1] + clientObject.self_weight_factor_y = self_weight[2] + clientObject.self_weight_factor_z = self_weight[3] + else: + if len(self_weight) != 1: + raise Exception('WARNING: Self-weight is deactivated and therefore requires a list definition of length 1. Kindly check list inputs for completeness and correctness.') + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Case to client model + Model.clientModel.service.set_load_case(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/loadCombination.py b/package/RFEM/LoadCasesAndCombinations/loadCombination.py new file mode 100644 index 00000000..ab89d363 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/loadCombination.py @@ -0,0 +1,96 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import AnalysisType + +class LoadCombination(): + def __init__(self, + no: int = 1, + analysis_type = AnalysisType.ANALYSIS_TYPE_STATIC, + design_situation: int = 1, + user_defined_name = [False], + static_analysis_settings: int = 1, + consider_imperfection: bool = False, + consider_initial_state: bool = False, + structure_modification: bool = False, + to_solve: bool = True, + combination_items = [[1.5, 1, 0, False]], + comment: str = '', + params: dict = {}): + + # Client model | Load Combination + clientObject = Model.clientModel.factory.create('ns0:load_combination') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Load Combination No. + clientObject.no = no + + # Analysis Type + clientObject.analysis_type = analysis_type.name + + # Design Situation Assignment + clientObject.design_situation = design_situation + + # Combination Name + clientObject.user_defined_name_enabled = user_defined_name[0] + if user_defined_name[0]: + clientObject.name = user_defined_name[1] + + # Analysis Settings Assignment + clientObject.static_analysis_settings = static_analysis_settings + + # Consider Imperfection Options + clientObject.consider_imperfection = consider_imperfection + + # Consider Initial State + clientObject.consider_initial_state = consider_initial_state + + # Structure Modification Enable + clientObject.structure_modification_enabled = structure_modification + + # Decide to Solve + clientObject.to_solve = to_solve + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Items + clientObject.items = Model.clientModel.factory.create('ns0:load_combination.items') + + for i,j in enumerate(combination_items): + mlvlp = Model.clientModel.factory.create('ns0:load_combination_items') + mlvlp.no = i+1 + mlvlp.factor = combination_items[i][0] + mlvlp.load_case = combination_items[i][1] + mlvlp.action = combination_items[i][2] + mlvlp.is_leading = combination_items[i][3] + mlvlp.gamma=0 + mlvlp.psi=0 + mlvlp.xi=0 + mlvlp.k_fi=0 + mlvlp.c_esl=0 + mlvlp.k_def=0 + mlvlp.psi_0=0 + mlvlp.psi_1=0 + mlvlp.psi_2=0 + mlvlp.fi=0 + mlvlp.gamma_0=0 + mlvlp.alfa=0 + mlvlp.k_f=0 + mlvlp.phi=0 + mlvlp.rho=0 + mlvlp.omega_0=0 + mlvlp.gamma_l_1=0 + mlvlp.k_creep=0 + mlvlp.shift=0 + mlvlp.amplitude_function_type = "CONSTANT" + + + clientObject.items.load_combination_items.append(mlvlp) + + # Add Load Combination to client model + Model.clientModel.service.set_load_combination(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/modalAnalysisSettings.py b/package/RFEM/LoadCasesAndCombinations/modalAnalysisSettings.py new file mode 100644 index 00000000..b3bbae34 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/modalAnalysisSettings.py @@ -0,0 +1,77 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import ModalSolutionMethod, ModalMassConversionType, ModalMassMatrixType, ModalNeglectMasses + +class ModalAnalysisSettings(): + def __init__(self, + no: int = 1, + name: str = 'Modal Analysis Settings', + solution_method = ModalSolutionMethod.METHOD_LANCZOS, + mass_conversion_type = ModalMassConversionType.MASS_CONVERSION_TYPE_Z_COMPONENTS_OF_LOADS, + mass_matrix_type = ModalMassMatrixType.MASS_MATRIX_TYPE_CONSISTENT, + number_of_modes : int = 4, + acting_masses = [], + neglect_masses = ModalNeglectMasses.E_NEGLECT_MASSES_NO_NEGLECTION, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Setting Tag + name (str): Setting Name + solution_method (enum): Solution Method Enumeration + mass_conversion_type (enum): Mass Conversion Type Enumeration + mass_matrix_type (enum): Mass Matrix Type Enumeration + number_of_modes (int): Number of Modes + acting_masses (list): Acting Masses Directions List + neglect_masses (enum): Neglect Masses Enumeration + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:modal_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Static Analysis Settings No. + clientObject.no = no + + # Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Analysis Type + clientObject.solution_method = solution_method.name + + # Mass Conversion Type + clientObject.mass_conversion_type = mass_conversion_type.name + + # Mass Matrix Type + clientObject.mass_matrix_type = mass_matrix_type.name + + # Number of Modes + clientObject.number_of_modes_method = "NUMBER_OF_MODES_METHOD_USER_DEFINED" + clientObject.number_of_modes = number_of_modes + + # Acting Masses + if len(acting_masses) == 6: + clientObject.acting_masses_about_axis_x_enabled = acting_masses[0] + clientObject.acting_masses_about_axis_y_enabled = acting_masses[1] + clientObject.acting_masses_about_axis_z_enabled = acting_masses[2] + clientObject.acting_masses_in_direction_x_enabled = acting_masses[3] + clientObject.acting_masses_in_direction_y_enabled = acting_masses[4] + clientObject.acting_masses_in_direction_z_enabled = acting_masses[5] + else: + raise Exception('WARNING: The acting masses array needs to be of length 6. Kindly check list inputs for completeness and correctness.') + + # Neglect Masses + clientObject.neglect_masses = neglect_masses.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Static Analysis Settings to client model + Model.clientModel.service.set_modal_analysis_settings(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/resultCombination.py b/package/RFEM/LoadCasesAndCombinations/resultCombination.py new file mode 100644 index 00000000..4428fab8 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/resultCombination.py @@ -0,0 +1,33 @@ +from RFEM.initModel import Model, clearAtributes + +class ResultCombination(): + def __init__(self, + no: int = 1, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Result Combination No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Result Combination to client model + Model.clientModel.service.set_result_combination(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py b/package/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py new file mode 100644 index 00000000..77102190 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/spectralAnalysisSettings.py @@ -0,0 +1,82 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import DirectionalComponentCombinationRule, PeriodicResponseCombinationRule, CqsDampingRule + +class SpectralAnalysisSettings(): + def __init__(self, + no: int = 1, + name: str = 'SRSS | SRSS', + periodic_combination = PeriodicResponseCombinationRule.SRSS, + directional_combination = DirectionalComponentCombinationRule.SRSS, + equivalent_linear_combination : bool = False, + save_mode_results : bool = False, + signed_dominant_mode_results : bool = False, + directional_component_scale_value : float = 0.3, + damping_for_cqc_rule = CqsDampingRule.CONSTANT_FOR_EACH_MODE, + constant_d_for_each_mode: float = 0.0, + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Static Analysis Settings No. + clientObject.no = no + + # Name + clientObject.name = name + clientObject.user_defined_name_enabled = True + + # Periodic Combination + clientObject.combination_rule_for_periodic_responses = periodic_combination.name + + # Directional Component + clientObject.combination_rule_for_directional_components = directional_combination.name + + # Equivalent Linear Combination + clientObject.use_equivalent_linear_combination = equivalent_linear_combination + + # Save Results of All Selected Modes + clientObject.save_results_of_all_selected_modes = save_mode_results + + # Signed Results Using Dominant Mode + clientObject.signed_results_using_dominant_mode = signed_dominant_mode_results + + if signed_dominant_mode_results: + if directional_combination != DirectionalComponentCombinationRule.SCALED_SUM: + raise Exception("WARNING: Signed results using dominant mode is only available with Scaled Sum Directional Combination.") + + # Further Options + if directional_combination == DirectionalComponentCombinationRule.SCALED_SUM: + clientObject.combination_rule_for_directional_components_value = directional_component_scale_value + + if periodic_combination == PeriodicResponseCombinationRule.CQC: + clientObject.damping_for_cqc_rule = damping_for_cqc_rule.name + clientObject.constant_d_for_each_mode = constant_d_for_each_mode + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + # Add Static Analysis Settings to client model + Model.clientModel.service.set_spectral_analysis_settings(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py b/package/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py new file mode 100644 index 00000000..529cedcb --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/stabilityAnalysisSettings.py @@ -0,0 +1,396 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import StabilityAnalysisSettingsAnalysisType +from RFEM.enums import StabilityAnalysisSettingsEigenvalueMethod +from RFEM.enums import StabilityAnalysisSettingsMatrixType + +class StabilityAnalysisSettings(): + def __init__(self, + no: int = 1, + name: str = None, + comment: str = '', + params: dict = {}): + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.EIGENVALUE_METHOD.name + + # Number of Lowest Eigenvalues + clientObject.number_of_lowest_eigenvalues = 4 + + # Eigenvalue Method + clientObject.eigenvalue_method = StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS.name + + # Matrix Type + clientObject.matrix_type = StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + Model.clientModel.service.set_stability_analysis_settings(clientObject) + + def EigenvalueMethod(self, + no: int = 1, + name: str = None, + number_of_lowest_eigenvalues: int = 4, + considered_favored_effect: bool = True, + critical_load_factor = None, + minimum_initial_strain = 1e-05, + local_torsional_rotations = None, + eigenvalue_method = StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS, + matrix_type = StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD, + comment: str = '', + params: dict = {}): + ''' + Args: + no (int): 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: + critical_load_factor = None + for find_eigenvectors_beyond_critical_load_factor == True: + critical_load_factor = int + minimum_initial_strain (optional): + for minimum initial strain application: + minimum_initial_strain != 0 or minimum_initial_strain is not None + 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: + local_torsional_rotations = None + for local torsional rotations display: + local_torsional_rotations = double + eigenvalue_method (enum): Eigenvalue Method Enumeration + matrix_type (enum): Matrix Type Enumeration + comment (str, optional): + params (dict, optional): + ''' + # Client model | Stability Analysis Settings + clientObject = Model.clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.EIGENVALUE_METHOD.name + + # Number of Lowest Eigenvalues + clientObject.number_of_lowest_eigenvalues = number_of_lowest_eigenvalues + + # Considered Favored Effect + clientObject.considered_favored_effect = considered_favored_effect + + # Finding Eigenvectors Beyond Critical Load Factor + if critical_load_factor is not None: + clientObject.find_eigenvectors_beyond_critical_load_factor = True + clientObject.critical_load_factor = critical_load_factor + + # Minimum Initial Strain + if minimum_initial_strain in (None, 0): + clientObject.activate_minimum_initial_prestress = False + else: + clientObject.activate_minimum_initial_prestress = True + clientObject.minimum_initial_strain = minimum_initial_strain + + # Local Torsional Relations + if local_torsional_rotations is not None: + clientObject.display_local_torsional_rotations = True + + # Eigenvalue Method + clientObject.eigenvalue_method = eigenvalue_method.name + + # Matrix Type + clientObject.matrix_type = matrix_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + Model.clientModel.service.set_stability_analysis_settings(clientObject) + + def IncrementalyMethodWithEigenvalue(self, + no: int = 1, + name: str = None, + number_of_lowest_eigenvalues: int = 4, + considered_favored_effect: bool = True, + critical_load_factor = None, + minimum_initial_strain = 1e-05, + local_torsional_rotations = None, + incrementally_increasing_loading = [1.0, 0.1, 10, 100], + stopping_of_load_increasing = None, + save_results_of_all_increments: bool = False, + eigenvalue_method = StabilityAnalysisSettingsEigenvalueMethod.EIGENVALUE_METHOD_LANCZOS, + matrix_type = StabilityAnalysisSettingsMatrixType.MATRIX_TYPE_STANDARD, + comment: str = '', + params: dict = {}): + ''' + Args: + no (int): 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: + critical_load_factor = None + for find_eigenvectors_beyond_critical_load_factor == True: + critical_load_factor = int + minimum_initial_strain (optional): + for minimum initial strain application: + minimum_initial_strain != 0 or minimum_initial_strain is not None + for no minimum initial strain application: + minimum_initial_strain is None + local_torsional_rotations (optional): + for no local torsional rotations display: + local_torsional_rotations = None + for local torsional rotations display: + local_torsional_rotations = double + incrementally_increasing_loading (list): [initial_load_factor, load_factor_increment, refinement_of_the_last_load_increment, maximum_number_of_load_increments] + stopping_of_load_increasing (list, optional): + for stopping of load increasing deactivated: + stopping_of_load_increasing = None + for result u: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U, limit_result_displacement, limit_node] + for result uX: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_X, limit_result_displacement, limit_node] + for result uY: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Y, limit_result_displacement, limit_node] + for result uZ: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Z, limit_result_displacement, limit_node] + for result phi: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI, limit_result_rotation, limit_node] + for result phiX: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_X, limit_result_rotation, limit_node] + for result phiY: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Y, limit_result_rotation, limit_node] + for result phiZ: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Z, limit_result_rotation, limit_node] + save_results_of_all_increments (bool, optional): Save Results of All Increments + eigenvalue_method (enum): Eigenvalue Method Enumeration + matrix_type (enum): Matrix Type Enumeration + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Stability Analysis Settings + clientObject = Model.clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.INCREMENTALY_METHOD_WITH_EIGENVALUE.name + + # Number of Lowest Eigenvalues + clientObject.number_of_lowest_eigenvalues = number_of_lowest_eigenvalues + + # Considered Favored Effect + clientObject.considered_favored_effect = considered_favored_effect + + # Finding Eigenvectors Beyond Critical Load Factor + if critical_load_factor is not None: + clientObject.find_eigenvectors_beyond_critical_load_factor = True + clientObject.critical_load_factor = critical_load_factor + + # Minimum Initial Strain + if minimum_initial_strain in (None, 0): + clientObject.activate_minimum_initial_prestress = False + else: + clientObject.activate_minimum_initial_prestress = True + clientObject.minimum_initial_strain = minimum_initial_strain + + # Local Torsional Relations + if local_torsional_rotations is not None: + clientObject.display_local_torsional_rotations = True + + # Increase Loading + if len(incrementally_increasing_loading) != 4: + raise Exception('WARNING: The incrementally increasing loading parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.initial_load_factor = incrementally_increasing_loading[0] + clientObject.load_factor_increment = incrementally_increasing_loading[1] + clientObject.refinement_of_the_last_load_increment = incrementally_increasing_loading[2] + clientObject.maximum_number_of_load_increments = incrementally_increasing_loading[3] + + # Stopping of Load-Increasing + if stopping_of_load_increasing is not None: + if len(stopping_of_load_increasing) != 3: + raise Exception('WARNING: For active stopping of load-increasing, the stopping of load increasing parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.activate_stopping_of_load_increasing = True + clientObject.stopping_of_load_increasing_result = stopping_of_load_increasing[0].name + if stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Z': + clientObject.stopping_of_load_increasing_limit_result_displacement = stopping_of_load_increasing[1] + elif stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Z': + clientObject.stopping_of_load_increasing_limit_result_rotation = stopping_of_load_increasing[1] + clientObject.stopping_of_load_increasing_limit_node = stopping_of_load_increasing[2] + + # Save Results of All Increments + clientObject.save_results_of_all_increments = save_results_of_all_increments + + # Eigenvalue Method + clientObject.eigenvalue_method = eigenvalue_method.name + + # Matrix Type + clientObject.matrix_type = matrix_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + Model.clientModel.service.set_stability_analysis_settings(clientObject) + + def IncrementalyMethodWithoutEigenvalue(self, + no: int = 1, + name: str = None, + minimum_initial_strain = 1e-05, + local_torsional_rotations = None, + incrementally_increasing_loading = [1.0, 0.1, 10, 100], + stopping_of_load_increasing = None, + save_results_of_all_increments: bool = False, + comment: str = '', + params: dict = {}): + ''' + Args: + no (int): Stability Analysis Setting Tag + name (str, optional): Stability Analysis Setting Name + minimum_initial_strain (optional): + for minimum initial strain application: + minimum_initial_strain != 0 or minimum_initial_strain is not None + 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: + local_torsional_rotations = None + for local torsional rotations display: + local_torsional_rotations = double + incrementally_increasing_loading (list): [initial_load_factor, load_factor_increment, refinement_of_the_last_load_increment, maximum_number_of_load_increments] + stopping_of_load_increasing (list, optional): + for stopping of load increasing deactivated: + stopping_of_load_increasing = None + for result u: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U, limit_result_displacement, limit_node] + for result uX: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_X, limit_result_displacement, limit_node] + for result uY: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Y, limit_result_displacement, limit_node] + for result uZ: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_DISPLACEMENT_U_Z, limit_result_displacement, limit_node] + for result phi: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI, limit_result_rotation, limit_node] + for result phiX: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_X, limit_result_rotation, limit_node] + for result phiY: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Y, limit_result_rotation, limit_node] + for result phiZ: + stopping_of_load_increasing = [StabilityAnalysisSettingsStoppingOfLoadIncreasingResult.RESULT_TYPE_ROTATION_PHI_Z, limit_result_rotation, limit_node] + save_results_of_all_increments (bool, optional): Save Results of All Increments + comment (str, optional): Comments + params (dict, optional): Parameters + ''' + # Client model | Stability Analysis Settings + clientObject = Model.clientModel.factory.create('ns0:stability_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Stability Analysis Settings No. + clientObject.no = no + + # Name + if name is not None: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Stability Analysis Type + clientObject.analysis_type = StabilityAnalysisSettingsAnalysisType.INCREMENTALY_METHOD_WITHOUT_EIGENVALUE.name + + # Minimum Initial Strain + if minimum_initial_strain in (None, 0): + clientObject.activate_minimum_initial_prestress = False + else: + clientObject.activate_minimum_initial_prestress = True + clientObject.minimum_initial_strain = minimum_initial_strain + + # Local Torsional Relations + if local_torsional_rotations is not None: + clientObject.display_local_torsional_rotations = True + + # Increase Loading + if len(incrementally_increasing_loading) != 4: + raise Exception('WARNING: The incrementally increasing loading parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.initial_load_factor = incrementally_increasing_loading[0] + clientObject.load_factor_increment = incrementally_increasing_loading[1] + clientObject.refinement_of_the_last_load_increment = incrementally_increasing_loading[2] + clientObject.maximum_number_of_load_increments = incrementally_increasing_loading[3] + + # Stopping of Load-Increasing + if stopping_of_load_increasing is not None: + if len(stopping_of_load_increasing) != 3: + raise Exception('WARNING: For active stopping of load-increasing, the stopping of load increasing parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.activate_stopping_of_load_increasing = True + clientObject.stopping_of_load_increasing_result = stopping_of_load_increasing[0].name + if stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_DISPLACEMENT_U_Z': + clientObject.stopping_of_load_increasing_limit_result_displacement = stopping_of_load_increasing[1] + elif stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_X' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Y' or stopping_of_load_increasing[0].name == 'RESULT_TYPE_ROTATION_PHI_Z': + clientObject.stopping_of_load_increasing_limit_result_rotation = stopping_of_load_increasing[1] + clientObject.stopping_of_load_increasing_limit_node = stopping_of_load_increasing[2] + + # Save Results of All Increments + clientObject.save_results_of_all_increments = save_results_of_all_increments + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Stability Analysis Settings to client model + Model.clientModel.service.set_stability_analysis_settings(clientObject) diff --git a/package/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py b/package/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py new file mode 100644 index 00000000..249035a7 --- /dev/null +++ b/package/RFEM/LoadCasesAndCombinations/staticAnalysisSettings.py @@ -0,0 +1,368 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import StaticAnalysisSettingsIterativeMethodForNonlinearAnalysis +from RFEM.enums import StaticAnalysisSettingsMethodOfEquationSystem +from RFEM.enums import StaticAnalysisSettingsPlateBendingTheory, StaticAnalysisType + +class StaticAnalysisSettings(): + def __init__(self, + no: int = 1, + name: str = None, + analysis_type=StaticAnalysisType.GEOMETRICALLY_LINEAR, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Static Analysis Setting Tag + name (str): Static Analysis Setting Name + analysis_type (enum): Analysis Type Enumeration + comment (str): Comments + params (dict): Parameters + """ + # Client model | Surface + clientObject = Model.clientModel.factory.create('ns0:static_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Static Analysis Settings No. + clientObject.no = no + + # Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Analysis Type + clientObject.analysis_type = analysis_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Static Analysis Settings to client model + Model.clientModel.service.set_static_analysis_settings(clientObject) + + def GeometricallyLinear(self, + no: int = 1, + name: str = None, + load_modification = [False, 1, False], + bourdon_effect: bool = False, + nonsymmetric_direct_solver: bool = False, + method_of_equation_system = StaticAnalysisSettingsMethodOfEquationSystem.METHOD_OF_EQUATION_SYSTEM_DIRECT, + plate_bending_theory = StaticAnalysisSettingsPlateBendingTheory.PLATE_BENDING_THEORY_MINDLIN, + mass_conversion = [False, 0, 0, 0], + comment: str = '', + params: dict = {}): + + """ + Args: + 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 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): + """ + + # Client model + clientObject = Model.clientModel.factory.create('ns0:static_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Static Analysis Settings No. + clientObject.no = no + + # Name + if name: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Static Analysis Type + clientObject.analysis_type = StaticAnalysisType.GEOMETRICALLY_LINEAR.name + + # Bourdon Effect Displacement + clientObject.displacements_due_to_bourdon_effect = bourdon_effect + + # Conversion of Mass into Load + clientObject.mass_conversion_enabled = mass_conversion[0] + if mass_conversion[0]: + clientObject.mass_conversion_factor_in_direction_x = mass_conversion[1] + clientObject.mass_conversion_factor_in_direction_y = mass_conversion[2] + clientObject.mass_conversion_factor_in_direction_z = mass_conversion[3] + + # Method for Equation System + clientObject.method_of_equation_system = method_of_equation_system.name + + if load_modification[0]: + clientObject.modify_loading_by_multiplier_factor = True + clientObject.loading_multiplier_factor = load_modification[1] + clientObject.divide_results_by_loading_factor = load_modification[2] + + # Nonsymetric Direct Solver if Demanded by Nonlinear Model + clientObject.nonsymmetric_direct_solver = nonsymmetric_direct_solver + + # Plate Bending Theory + clientObject.plate_bending_theory = plate_bending_theory.name + + # Calculations Diagrams + # If needed utilize 'params' dictionary + clientObject.calculation_diagrams_enabled = False + clientObject.calculation_diagrams_list = "" + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Static Analysis Settings to client model + Model.clientModel.service.set_static_analysis_settings(clientObject) + + def LargeDeformation(self, + no: int = 1, + name: str = None, + iterative_method = StaticAnalysisSettingsIterativeMethodForNonlinearAnalysis.NEWTON_RAPHSON, + standard_precision_and_tolerance_settings = [False, 1.0, 1.0, 1.0], + control_nonlinear_analysis = [100, 1], + load_modification = [False, 1, False], + instabil_structure_calculation : bool = True, + bourdon_effect: bool = True, + nonsymmetric_direct_solver: bool = True, + method_of_equation_system = StaticAnalysisSettingsMethodOfEquationSystem.METHOD_OF_EQUATION_SYSTEM_DIRECT, + plate_bending_theory = StaticAnalysisSettingsPlateBendingTheory.PLATE_BENDING_THEORY_MINDLIN, + mass_conversion = [False, 0, 0, 1], + comment: str = '', + params: dict = {'save_results_of_all_load_increments': False}): + + """ + Args: + 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] + 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 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 + clientObject = Model.clientModel.factory.create('ns0:static_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Static Analysis Settings No. + clientObject.no = no + + # Name + if name: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Static Analysis Type + clientObject.analysis_type = StaticAnalysisType.LARGE_DEFORMATIONS.name + + # Consider Favorable Effect due to Tension in Members + clientObject.consider_favorable_effect_due_to_tension_in_members = True + + # Bourdon Effect Displacement + clientObject.displacements_due_to_bourdon_effect = bourdon_effect + + # Iterative Method + clientObject.iterative_method_for_nonlinear_analysis = iterative_method.name + + # Controls for Nonlinear Analysis + if iterative_method == StaticAnalysisSettingsIterativeMethodForNonlinearAnalysis.DYNAMIC_RELAXATION: + clientObject.max_number_of_iterations = None + clientObject.number_of_load_increments = None + else: + clientObject.max_number_of_iterations = control_nonlinear_analysis[0] + clientObject.number_of_load_increments = control_nonlinear_analysis[1] + + # Conversion of Mass into Load + clientObject.mass_conversion_enabled = mass_conversion[0] + if mass_conversion[0]: + clientObject.mass_conversion_factor_in_direction_x = mass_conversion[1] + clientObject.mass_conversion_factor_in_direction_y = mass_conversion[2] + clientObject.mass_conversion_factor_in_direction_z = mass_conversion[3] + + # Method for Equation System + clientObject.method_of_equation_system = method_of_equation_system.name + + # Modify Loading by Multiplier Factor + if load_modification[0]: + clientObject.modify_loading_by_multiplier_factor = True + clientObject.loading_multiplier_factor = load_modification[1] + clientObject.divide_results_by_loading_factor = load_modification[2] + + # Nonsymetric Direct Solver if Demanded by Nonlinear Model + clientObject.nonsymmetric_direct_solver = nonsymmetric_direct_solver + + # Plate Bending Theory + clientObject.plate_bending_theory = plate_bending_theory.name + + # Modify Standard precision and Tolerance Settings... + if standard_precision_and_tolerance_settings[0]: + clientObject.standard_precision_and_tolerance_settings_enabled = True + clientObject.precision_of_convergence_criteria_for_nonlinear_calculation = standard_precision_and_tolerance_settings[1] + clientObject.instability_detection_tolerance = standard_precision_and_tolerance_settings[2] + clientObject.iterative_calculation_robustness = standard_precision_and_tolerance_settings[3] + + # Try to Calculate Unstable Structure + clientObject.try_to_calculate_instabil_structure = instabil_structure_calculation + + # Calculations Diagrams + # If needed utilize 'params' dictionary + clientObject.calculation_diagrams_enabled = False + clientObject.calculation_diagrams_list = "" + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Static Analysis Settings to client model + Model.clientModel.service.set_static_analysis_settings(clientObject) + + def SecondOrderPDelta(self, + no: int = 1, + name: str = None, + iterative_method = StaticAnalysisSettingsIterativeMethodForNonlinearAnalysis.NEWTON_RAPHSON, + standard_precision_and_tolerance_settings = [False, 1.0, 1.0, 1.0], + control_nonlinear_analysis = [100, 1], + load_modification = [False, 0, False], + favorable_effect_due_to_tension_in_members : bool = False, + bourdon_effect: bool = True, + nonsymmetric_direct_solver: bool = True, + internal_forces_to_deformed_structure = [True, True, True, True], + method_of_equation_system = StaticAnalysisSettingsMethodOfEquationSystem.METHOD_OF_EQUATION_SYSTEM_DIRECT, + plate_bending_theory = StaticAnalysisSettingsPlateBendingTheory.PLATE_BENDING_THEORY_MINDLIN, + mass_conversion = [False, 0, 0, 1], + comment: str = '', + params: dict = {}): + """ + Args: + 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 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 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): + """ + + # Client model + clientObject = Model.clientModel.factory.create('ns0:static_analysis_settings') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Static Analysis Settings No. + clientObject.no = no + + # Name + if name: + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Static Analysis Type + clientObject.analysis_type = StaticAnalysisType.SECOND_ORDER_P_DELTA.name + + # Consider Favorable Effect due to Tension in Members + clientObject.consider_favorable_effect_due_to_tension_in_members = favorable_effect_due_to_tension_in_members + + # Bourdon Effect Displacement + clientObject.displacements_due_to_bourdon_effect = bourdon_effect + + # Iterative Method + clientObject.iterative_method_for_nonlinear_analysis = iterative_method.name + + # Conversion of Mass Into Load + clientObject.mass_conversion_enabled = mass_conversion[0] + if mass_conversion[0]: + clientObject.mass_conversion_factor_in_direction_x = mass_conversion[1] + clientObject.mass_conversion_factor_in_direction_y = mass_conversion[2] + clientObject.mass_conversion_factor_in_direction_z = mass_conversion[3] + + clientObject.max_number_of_iterations = control_nonlinear_analysis[0] + clientObject.number_of_load_increments = control_nonlinear_analysis[1] + + # Method for Equation System + clientObject.method_of_equation_system = method_of_equation_system.name + + # Modify Loading by Multiplier Factor + if load_modification[0]: + clientObject.modify_loading_by_multiplier_factor = True + clientObject.loading_multiplier_factor = load_modification[1] + clientObject.divide_results_by_loading_factor = load_modification[2] + + # Non-symetric Direct Solver id Demanded by Nonlinear Model + clientObject.nonsymmetric_direct_solver = nonsymmetric_direct_solver + + # Plate Bending Theory + clientObject.plate_bending_theory = plate_bending_theory.name + + # Iterative Method Settings + if internal_forces_to_deformed_structure[0]: + clientObject.refer_internal_forces_to_deformed_structure = True + clientObject.refer_internal_forces_to_deformed_structure_for_moments = internal_forces_to_deformed_structure[1] + clientObject.refer_internal_forces_to_deformed_structure_for_normal_forces = internal_forces_to_deformed_structure[2] + clientObject.refer_internal_forces_to_deformed_structure_for_shear_forces = internal_forces_to_deformed_structure[3] + + # Modify Standard Precision and Tolerance Settings... + if standard_precision_and_tolerance_settings[0]: + clientObject.standard_precision_and_tolerance_settings_enabled = True + clientObject.precision_of_convergence_criteria_for_nonlinear_calculation = standard_precision_and_tolerance_settings[1] + clientObject.instability_detection_tolerance = standard_precision_and_tolerance_settings[2] + clientObject.iterative_calculation_robustness = standard_precision_and_tolerance_settings[3] + + # Calculations Diagrams + # If needed utilize 'params' dictionary + clientObject.calculation_diagrams_enabled = False + clientObject.calculation_diagrams_list = "" + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Static Analysis Settings to client model + Model.clientModel.service.set_static_analysis_settings(clientObject) diff --git a/package/RFEM/Loads/__init__.py b/package/RFEM/Loads/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/Loads/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/Loads/freeLoad.py b/package/RFEM/Loads/freeLoad.py new file mode 100644 index 00000000..3812f214 --- /dev/null +++ b/package/RFEM/Loads/freeLoad.py @@ -0,0 +1,616 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import FreeConcentratedLoadLoadType, FreeConcentratedLoadLoadDirection, FreeLoadLoadProjection +from RFEM.enums import FreeLineLoadLoadDistribution, FreeLineLoadLoadDirection, FreeRectangularLoadLoadDistribution +from RFEM.enums import FreeRectangularLoadLoadDirection, FreeRectangularLoadLoadLocationRectangle, FreeCircularLoadLoadDistribution +from RFEM.enums import FreeCircularLoadLoadDirection, FreePolygonLoadLoadDistribution, FreePolygonLoadLoadDirection +from math import pi + +class FreeLoad(): + + def ConcentratedLoad(self, + no: int = 1, + load_case_no: int = 1, + surfaces_no = '1', + load_type = FreeConcentratedLoadLoadType.LOAD_TYPE_FORCE, + load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV, + load_direction = FreeConcentratedLoadLoadDirection.LOAD_DIRECTION_GLOBAL_Z, + load_parameter = [1000, 0, 0], + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:free_concentrated_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Surfaces No. + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Load Projection + clientObject.load_projection = load_projection.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Parameter + if len(load_parameter) != 3: + raise Exception('WARNING: The load parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude = load_parameter[0] + clientObject.load_location_x = load_parameter[1] + clientObject.load_location_y = load_parameter[2] + + # Load Type + clientObject.load_type = load_type.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Free Concentrated Load to client model + Model.clientModel.service.set_free_concentrated_load(load_case_no, clientObject) + + def LineLoad(self, + no: int = 1, + load_case_no: int = 1, + surfaces_no = '1', + load_distribution = FreeLineLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV, + load_direction = FreeLineLoadLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:free_line_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Surfaces No. + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Projection + clientObject.load_projection = load_projection.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Parameter + if load_distribution.name == 'LOAD_DISTRIBUTION_UNIFORM': + if len(load_parameter) != 5: + raise Exception('WARNING: The load parameter needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_uniform = load_parameter[0] + clientObject.load_location_first_x = load_parameter[1] + clientObject.load_location_first_y = load_parameter[2] + clientObject.load_location_second_x = load_parameter[3] + clientObject.load_location_second_y = load_parameter[4] + elif load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR': + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_first = load_parameter[0] + clientObject.magnitude_second = load_parameter[1] + clientObject.load_location_first_x = load_parameter[2] + clientObject.load_location_first_y = load_parameter[3] + clientObject.load_location_second_x = load_parameter[4] + clientObject.load_location_second_y = load_parameter[5] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Free Concentrated Load to client model + Model.clientModel.service.set_free_line_load(load_case_no, clientObject) + + def RectangularLoad(self, + no: int = 1, + load_case_no: int = 1, + surfaces_no = '1', + load_distribution = FreeRectangularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV, + load_direction = FreeRectangularLoadLoadDirection.LOAD_DIRECTION_GLOBAL_Z_TRUE, + load_magnitude_parameter = [], + load_location = FreeRectangularLoadLoadLocationRectangle.LOAD_LOCATION_RECTANGLE_CORNER_POINTS, + load_location_parameter = [], + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:free_rectangular_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Surfaces No. + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Projection + clientObject.load_projection = load_projection.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Magnitude Parameter + if load_distribution.name == 'LOAD_DISTRIBUTION_UNIFORM' or load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_IN_Z' or load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER' or load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER': + if len(load_magnitude_parameter) != 1: + raise Exception('WARNING: The load parameter for the selected distribution needs to be of length 1. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_uniform = load_magnitude_parameter[0] + + elif load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_FIRST' or load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_SECOND': + if len(load_magnitude_parameter) != 2: + raise Exception('WARNING: The load parameter for the selected distribution needs to be of length 2. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_linear_first = load_magnitude_parameter[0] + clientObject.magnitude_linear_second = load_magnitude_parameter[1] + + # Load Location Parameter + clientObject.load_location_rectangle = load_location.name + + if load_location.name == 'LOAD_LOCATION_RECTANGLE_CORNER_POINTS': + + if load_distribution.name == 'LOAD_DISTRIBUTION_UNIFORM' or load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_FIRST' or load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_SECOND': + if len(load_location_parameter) != 5: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_first_x = load_location_parameter[0] + clientObject.load_location_first_y = load_location_parameter[1] + clientObject.load_location_second_x = load_location_parameter[2] + clientObject.load_location_second_y = load_location_parameter[3] + clientObject.axis_start_angle = load_location_parameter[4] * (pi/180) + + elif load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_IN_Z': + if len(load_location_parameter) != 5: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_first_x = load_location_parameter[0] + clientObject.load_location_first_y = load_location_parameter[1] + clientObject.load_location_second_x = load_location_parameter[2] + clientObject.load_location_second_y = load_location_parameter[3] + + clientObject.load_varying_in_z_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_in_z_parameters') + varying_in_z = load_location_parameter[4] + for i,j in enumerate(varying_in_z): + frllvp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_in_z_parameters') + frllvp.no = i+1 + frllvp.distance = varying_in_z[i][0] + frllvp.factor = varying_in_z[i][1] + clientObject.load_varying_in_z_parameters.free_rectangular_load_load_varying_in_z_parameters.append(frllvp) + + elif load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER': + if len(load_location_parameter) != 8: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 9. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_first_x = load_location_parameter[0] + clientObject.load_location_first_y = load_location_parameter[1] + clientObject.load_location_second_x = load_location_parameter[2] + clientObject.load_location_second_y = load_location_parameter[3] + clientObject.axis_definition_p1_x = load_location_parameter[4][0] + clientObject.axis_definition_p1_y = load_location_parameter[4][1] + clientObject.axis_definition_p1_z = load_location_parameter[4][2] + clientObject.axis_definition_p2_x = load_location_parameter[5][0] + clientObject.axis_definition_p2_y = load_location_parameter[5][1] + clientObject.axis_definition_p2_z = load_location_parameter[5][2] + clientObject.axis_start_angle = load_location_parameter[6] + + clientObject.load_varying_along_perimeter_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_along_perimeter_parameters') + varying_along_perimeter = load_location_parameter[7] + for i,j in enumerate(varying_along_perimeter): + frllvapp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_along_perimeter_parameters') + frllvapp.no = i+1 + frllvapp.alpha = varying_along_perimeter[i][0] * (pi/180) + frllvapp.factor = varying_along_perimeter[i][1] + clientObject.load_varying_along_perimeter_parameters.free_rectangular_load_load_varying_along_perimeter_parameters.append(frllvapp) + + elif load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER': + if len(load_location_parameter) != 9: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 9. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_first_x = load_location_parameter[0] + clientObject.load_location_first_y = load_location_parameter[1] + clientObject.load_location_second_x = load_location_parameter[2] + clientObject.load_location_second_y = load_location_parameter[3] + + clientObject.load_varying_in_z_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_in_z_parameters') + varying_in_z = load_location_parameter[4] + for i,j in enumerate(varying_in_z): + frllvp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_in_z_parameters') + frllvp.no = i+1 + frllvp.distance = varying_in_z[i][0] + frllvp.factor = varying_in_z[i][1] + clientObject.load_varying_in_z_parameters.free_rectangular_load_load_varying_in_z_parameters.append(frllvp) + + clientObject.axis_definition_p1_x = load_location_parameter[5][0] + clientObject.axis_definition_p1_y = load_location_parameter[5][1] + clientObject.axis_definition_p1_z = load_location_parameter[5][2] + clientObject.axis_definition_p2_x = load_location_parameter[6][0] + clientObject.axis_definition_p2_y = load_location_parameter[6][1] + clientObject.axis_definition_p2_z = load_location_parameter[6][2] + clientObject.axis_start_angle = load_location_parameter[7] + + clientObject.load_varying_along_perimeter_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_along_perimeter_parameters') + varying_along_perimeter = load_location_parameter[8] + for i,j in enumerate(varying_along_perimeter): + frllvapp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_along_perimeter_parameters') + frllvapp.no = i+1 + frllvapp.alpha = varying_along_perimeter[i][0] * (pi/180) + frllvapp.factor = varying_along_perimeter[i][1] + clientObject.load_varying_along_perimeter_parameters.free_rectangular_load_load_varying_along_perimeter_parameters.append(frllvapp) + + elif load_location.name == 'LOAD_LOCATION_RECTANGLE_CENTER_AND_SIDES': + + if load_distribution.name == 'LOAD_DISTRIBUTION_UNIFORM' or load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_FIRST' or load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_SECOND': + if len(load_location_parameter) != 5: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_center_x = load_location_parameter[0] + clientObject.load_location_center_y = load_location_parameter[1] + clientObject.load_location_center_side_a = load_location_parameter[2] + clientObject.load_location_center_side_b = load_location_parameter[3] + clientObject.axis_start_angle = load_location_parameter[4] * (pi/180) + + elif load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_IN_Z': + if len(load_location_parameter) != 5: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_center_x = load_location_parameter[0] + clientObject.load_location_center_y = load_location_parameter[1] + clientObject.load_location_center_side_a = load_location_parameter[2] + clientObject.load_location_center_side_b = load_location_parameter[3] + + clientObject.load_varying_in_z_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_in_z_parameters') + varying_in_z = load_location_parameter[4] + for i,j in enumerate(varying_in_z): + frllvp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_in_z_parameters') + frllvp.no = i+1 + frllvp.distance = varying_in_z[i][0] + frllvp.factor = varying_in_z[i][1] + clientObject.load_varying_in_z_parameters.free_rectangular_load_load_varying_in_z_parameters.append(frllvp) + + elif load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER': + if len(load_location_parameter) != 8: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 9. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_center_x = load_location_parameter[0] + clientObject.load_location_center_y = load_location_parameter[1] + clientObject.load_location_center_side_a = load_location_parameter[2] + clientObject.load_location_center_side_b = load_location_parameter[3] + clientObject.axis_definition_p1_x = load_location_parameter[4][0] + clientObject.axis_definition_p1_y = load_location_parameter[4][1] + clientObject.axis_definition_p1_z = load_location_parameter[4][2] + clientObject.axis_definition_p2_x = load_location_parameter[5][0] + clientObject.axis_definition_p2_y = load_location_parameter[5][1] + clientObject.axis_definition_p2_z = load_location_parameter[5][2] + clientObject.axis_start_angle = load_location_parameter[6] + + clientObject.load_varying_along_perimeter_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_along_perimeter_parameters') + varying_along_perimeter = load_location_parameter[7] + for i,j in enumerate(varying_along_perimeter): + frllvapp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_along_perimeter_parameters') + frllvapp.no = i+1 + frllvapp.alpha = varying_along_perimeter[i][0] * (pi/180) + frllvapp.factor = varying_along_perimeter[i][1] + clientObject.load_varying_along_perimeter_parameters.free_rectangular_load_load_varying_along_perimeter_parameters.append(frllvapp) + + elif load_distribution.name == 'LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER': + if len(load_location_parameter) != 9: + raise Exception('WARNING: The load location parameter for the designated location and distribution type needs to be of length 9. Kindly check list inputs for completeness and correctness.') + clientObject.load_location_center_x = load_location_parameter[0] + clientObject.load_location_center_y = load_location_parameter[1] + clientObject.load_location_center_side_a = load_location_parameter[2] + clientObject.load_location_center_side_b = load_location_parameter[3] + + clientObject.load_varying_in_z_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_in_z_parameters') + varying_in_z = load_location_parameter[4] + for i,j in enumerate(varying_in_z): + frllvp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_in_z_parameters') + frllvp.no = i+1 + frllvp.distance = varying_in_z[i][0] + frllvp.factor = varying_in_z[i][1] + clientObject.load_varying_in_z_parameters.free_rectangular_load_load_varying_in_z_parameters.append(frllvp) + + clientObject.axis_definition_p1_x = load_location_parameter[5][0] + clientObject.axis_definition_p1_y = load_location_parameter[5][1] + clientObject.axis_definition_p1_z = load_location_parameter[5][2] + clientObject.axis_definition_p2_x = load_location_parameter[6][0] + clientObject.axis_definition_p2_y = load_location_parameter[6][1] + clientObject.axis_definition_p2_z = load_location_parameter[6][2] + clientObject.axis_start_angle = load_location_parameter[7] + + clientObject.load_varying_along_perimeter_parameters = Model.clientModel.factory.create('ns0:free_rectangular_load.load_varying_along_perimeter_parameters') + varying_along_perimeter = load_location_parameter[8] + for i,j in enumerate(varying_along_perimeter): + frllvapp = Model.clientModel.factory.create('ns0:free_rectangular_load_load_varying_along_perimeter_parameters') + frllvapp.no = i+1 + frllvapp.alpha = varying_along_perimeter[i][0] * (pi/180) + frllvapp.factor = varying_along_perimeter[i][1] + clientObject.load_varying_along_perimeter_parameters.free_rectangular_load_load_varying_along_perimeter_parameters.append(frllvapp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Free Concentrated Load to client model + Model.clientModel.service.set_free_rectangular_load(load_case_no, clientObject) + + def CircularLoad(self, + no: int = 1, + load_case_no: int = 1, + surfaces_no = '1', + load_distribution = FreeCircularLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV, + load_direction = FreeCircularLoadLoadDirection.LOAD_DIRECTION_GLOBAL_Z_TRUE, + load_parameter = [], + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:free_circular_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Surfaces No. + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Projection + clientObject.load_projection = load_projection.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Parameter + if load_distribution.name == 'LOAD_DISTRIBUTION_UNIFORM': + if len(load_parameter) != 4: + raise Exception('WARNING: The load parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_uniform = load_parameter[0] + clientObject.load_location_x = load_parameter[1] + clientObject.load_location_y = load_parameter[2] + clientObject.load_location_radius = load_parameter[3] + + elif load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR': + if len(load_parameter) != 5: + raise Exception('WARNING: The load parameter needs to be of length 5. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_center = load_parameter[0] + clientObject.magnitude_radius = load_parameter[1] + clientObject.load_location_x = load_parameter[2] + clientObject.load_location_y = load_parameter[3] + clientObject.load_location_radius = load_parameter[4] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Free Concentrated Load to client model + Model.clientModel.service.set_free_circular_load(load_case_no, clientObject) + + def PolygonLoad(self, + no: int = 1, + load_case_no: int = 1, + surfaces_no = '1', + load_distribution = FreePolygonLoadLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_projection = FreeLoadLoadProjection.LOAD_PROJECTION_XY_OR_UV, + load_direction = FreePolygonLoadLoadDirection.LOAD_DIRECTION_GLOBAL_Z_TRUE, + load_location = [], + load_parameter = [], + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:free_polygon_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Surfaces No. + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Projection + clientObject.load_projection = load_projection.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Location + clientObject.load_location = Model.clientModel.factory.create('ns0:free_polygon_load.load_location') + for i,j in enumerate(load_location): + fplld = Model.clientModel.factory.create('ns0:free_polygon_load_load_location') + fplld.no = i+1 + fplld.first_coordinate = load_location[i][0] + fplld.second_coordinate = load_location[i][1] + clientObject.load_location.free_polygon_load_load_location.append(fplld) + + # Load Parameter + if load_distribution.name == 'LOAD_DISTRIBUTION_UNIFORM': + if len(load_parameter) != 1: + raise Exception('WARNING: The load parameter needs to be of length 1. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_uniform = load_parameter[0] + + elif load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR': + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_linear_1 = load_parameter[0] + clientObject.magnitude_linear_2 = load_parameter[1] + clientObject.magnitude_linear_3 = load_parameter[2] + clientObject.magnitude_linear_location_1 = load_parameter[3] + clientObject.magnitude_linear_location_2 = load_parameter[4] + clientObject.magnitude_linear_location_3 = load_parameter[5] + + elif load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_FIRST' or load_distribution.name == 'LOAD_DISTRIBUTION_LINEAR_SECOND': + if len(load_parameter) != 4: + raise Exception('WARNING: The load parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_linear_1 = load_parameter[0] + clientObject.magnitude_linear_2 = load_parameter[1] + clientObject.magnitude_linear_location_1 = load_parameter[2] + clientObject.magnitude_linear_location_2 = load_parameter[3] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Free Concentrated Load to client model + Model.clientModel.service.set_free_polygon_load(load_case_no, clientObject) diff --git a/package/RFEM/Loads/imposedLineDeformation.py b/package/RFEM/Loads/imposedLineDeformation.py new file mode 100644 index 00000000..f7ea8567 --- /dev/null +++ b/package/RFEM/Loads/imposedLineDeformation.py @@ -0,0 +1,44 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString + +class ImposedLineDeformation(): + + LineDeformationParams = {'imposed_displacement_line_start_x' : 0.0, + 'imposed_displacement_line_start_y' : 0.0, + 'imposed_displacement_line_start_z': 0.003, + 'imposed_rotation_line_start' : 0.0, + 'imposed_displacement_line_end_x': 0.0, + 'imposed_displacement_line_end_y': 0.0, + 'imposed_displacement_line_end_z': 0.0002, + 'imposed_rotation_line_end': 0.0} + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + line_no: str = '1', + comment: str = '', + params: dict = LineDeformationParams): + + # Client model | Imposed Line Deformation + clientObject = Model.clientModel.factory.create('ns0:imposed_line_deformation') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Line No. + clientObject.lines = ConvertToDlString(line_no) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Nodal Support to client model + Model.clientModel.service.set_imposed_line_deformation(load_case_no, clientObject) diff --git a/package/RFEM/Loads/imposedNodalDeformation.py b/package/RFEM/Loads/imposedNodalDeformation.py new file mode 100644 index 00000000..da5d7679 --- /dev/null +++ b/package/RFEM/Loads/imposedNodalDeformation.py @@ -0,0 +1,49 @@ +from RFEM.initModel import Model, clearAtributes + +class ImposedNodalDeformation(): + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + node_no: str = '1', + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + load_parameter = [imposed_displacement_x, imposed_displacement_y, imposed_displacement_z, imposed_rotation_x, imposed_rotation_y imposed_rotation_z] + ''' + # Client model | Imposed Nodal Deformation + clientObject = Model.clientModel.factory.create('ns0:imposed_nodal_deformation') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Node No. + #clientObject.node_no = ConvertToDlString(node_no() + clientObject.nodes = node_no + + # Load Parameter + clientObject.imposed_displacement_x = load_parameter[0] + clientObject.imposed_displacement_y = load_parameter[1] + clientObject.imposed_displacement_z = load_parameter[2] + + clientObject.imposed_rotation_x = load_parameter[3] + clientObject.imposed_rotation_y = load_parameter[4] + clientObject.imposed_rotation_z = load_parameter[5] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Imposed Nodal Deformation to client model + Model.clientModel.service.set_imposed_nodal_deformation(load_case_no, clientObject) diff --git a/package/RFEM/Loads/lineLoad.py b/package/RFEM/Loads/lineLoad.py new file mode 100644 index 00000000..bf1b9c38 --- /dev/null +++ b/package/RFEM/Loads/lineLoad.py @@ -0,0 +1,638 @@ +from RFEM.initModel import Model, ConvertToDlString, clearAtributes +from RFEM.enums import * + +class LineLoad(): + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + lines_no: str = '1', + load_direction = LoadDirectionType.LOAD_DIRECTION_LOCAL_Z, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:line_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Line No. (e.g. '5 6 7 12') + clientObject.lines = ConvertToDlString(lines_no) + + # Line Load Type + load_type = LineLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Line Load Distribution + load_distribution = LineLoadDistribution.LOAD_DISTRIBUTION_UNIFORM + clientObject.load_distribution = load_distribution.name + + # Line Load Direction + clientObject.load_direction = load_direction.name + + # Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Line Load to client model + Model.clientModel.service.set_line_load(load_case_no, clientObject) + + def Force(self, + no: int = 1, + load_case_no: int = 1, + lines_no: str = '1', + load_distribution= LineLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction= LineLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = None, + list_reference: bool= False, + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:line_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Line Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Lines No. (e.g. '5 6 7 12') + clientObject.lines = ConvertToDlString(lines_no) + + # Line Load Type + load_type = LineLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Line Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude and Parameters + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM" or load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM_TOTAL": + clientObject.magnitude = load_parameter + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_1": + if len(load_parameter) != 3: + raise Exception('WARNING: The load parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool): + raise Exception ('WARNING: Load parameter at index 0 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + if not load_parameter[0]: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_absolute = load_parameter[2] + else: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_relative = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_N": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool): + raise Exception ('WARNING: Load parameter at index 0 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude = load_parameter[2] + clientObject.count_n = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2x2": + if len(load_parameter) != 7: + raise Exception('WARNING: The load parameter needs to be of length 7. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool) or not isinstance(load_parameter[2], bool): + raise Exception ('WARNING: Load parameter at index 0, 1 and 2 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.distance_c_is_defined_as_relative = load_parameter[2] + clientObject.magnitude = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + if not load_parameter[2]: + clientObject.distance_c_absolute = load_parameter[6] + else: + clientObject.distance_c_relative = load_parameter[6] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: LineLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:line_load.varying_load_parameters') + + for i,j in enumerate(load_parameter): + if len(load_parameter[i]) != 3: + raise Exception('WARNING: The load parameter sub-lists need to be of length 3. Kindly check sub-list inputs for completeness and correctness.') + mlvlp = Model.clientModel.factory.create('ns0:line_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + + clientObject.varying_load_parameters.line_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_TRAPEZOIDAL": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_TAPERED": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_PARABOLIC": + if len(load_parameter) != 3: + raise Exception('WARNING: The load parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: LineLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:line_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + if len(load_parameter[i]) != 3: + raise Exception('WARNING: The load parameter sub-lists need to be of length 3. Kindly check sub-list inputs for completeness and correctness.') + mlvlp = Model.clientModel.factory.create('ns0:line_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + + clientObject.varying_load_parameters.line_load_varying_load_parameters.append(mlvlp) + + # Line Load Direction + clientObject.load_direction = load_direction.name + + # Reference to List of Lines + clientObject.reference_to_list_of_lines = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Line Load to client model + Model.clientModel.service.set_line_load(load_case_no, clientObject) + + def Moment(self, + no: int = 1, + load_case_no: int = 1, + lines_no: str = '1', + load_distribution = LineLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = LineLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = None, + list_reference: bool = False, + comment: str = '', + params: dict = {}): + + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:line_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Line Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Lines No. (e.g. '5 6 7 12') + clientObject.lines = ConvertToDlString(lines_no) + + # Line Load Type + load_type = LineLoadType.LOAD_TYPE_MOMENT + clientObject.load_type = load_type.name + + # Line Load Distribution + clientObject.load_distribution= load_distribution.name + + #Load Magnitude and Parameters + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + clientObject.magnitude = load_parameter + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_1": + if len(load_parameter) != 3: + raise Exception('WARNING: The load parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool): + raise Exception ('WARNING: Load parameter at index 0 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + if not load_parameter[0]: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_absolute = load_parameter[2] + else: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_relative = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_N": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude = load_parameter[2] + clientObject.count_n = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2x2": + if len(load_parameter) != 7: + raise Exception('WARNING: The load parameter needs to be of length 7. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool) or not isinstance(load_parameter[2], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.distance_c_is_defined_as_relative = load_parameter[2] + clientObject.magnitude = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + if not load_parameter[2]: + clientObject.distance_c_absolute = load_parameter[6] + else: + clientObject.distance_c_relative = load_parameter[6] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: LineLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:line_load.varying_load_parameters') + + for i,j in enumerate(load_parameter): + if len(load_parameter[i]) != 3: + raise Exception('WARNING: The load parameter sub-lists need to be of length 3. Kindly check sub-list inputs for completeness and correctness.') + mlvlp = Model.clientModel.factory.create('ns0:line_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + + clientObject.varying_load_parameters.line_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_TRAPEZOIDAL": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_TAPERED": + if len(load_parameter) != 6: + raise Exception('WARNING: The load parameter needs to be of length 6. Kindly check list inputs for completeness and correctness.') + if not isinstance(load_parameter[0], bool) or not isinstance(load_parameter[1], bool): + raise Exception ('WARNING: Load parameter at index 0 and 1 to be of type "bool"') + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if not load_parameter[0]: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if not load_parameter[1]: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_PARABOLIC": + if len(load_parameter) != 3: + raise Exception('WARNING: The load parameter needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: LineLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:line_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + if len(load_parameter[i]) != 3: + raise Exception('WARNING: The load parameter sub-lists need to be of length 3. Kindly check sub-list inputs for completeness and correctness.') + mlvlp = Model.clientModel.factory.create('ns0:line_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + + clientObject.varying_load_parameters.line_load_varying_load_parameters.append(mlvlp) + + # Line Load Direction + clientObject.load_direction = load_direction.name + + #Reference to List of Lines + clientObject.reference_to_list_of_lines = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Line Load to client model + Model.clientModel.service.set_line_load(load_case_no, clientObject) + + def Mass(self, + no: int = 1, + load_case_no: int = 1, + lines_no: str = '1', + individual_mass_components: bool=True, + mass_components = None, + comment: str = '', + params: dict = {}): + ''' + 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 + clientObject = Model.clientModel.factory.create('ns0:line_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Lines No. (e.g. '5 6 7 12') + clientObject.lines = ConvertToDlString(lines_no) + + # Line Load Type + load_type = LineLoadType.E_TYPE_MASS + clientObject.load_type = load_type.name + + # Line Load Distribution + load_distribution= LineLoadDistribution.LOAD_DISTRIBUTION_UNIFORM + clientObject.load_distribution= load_distribution.name + + # Individual Mass Components + if not isinstance(individual_mass_components, bool): + raise Exception('WARNING: Input to be of type "bool"') + clientObject.individual_mass_components = individual_mass_components + + # Mass magnitude + if not individual_mass_components: + if len(mass_components) != 1: + raise Exception('WARNING: The mass components parameter for global mass assignment needs to be of length 1. Kindly check list inputs for completeness and correctness.') + clientObject.mass_global = mass_components[0] + else: + if len(mass_components) != 3: + raise Exception('WARNING: The mass components parameter for individual mass component assignment needs to be of length 3. Kindly check list inputs for completeness and correctness.') + clientObject.mass_x = mass_components[0] + clientObject.mass_y = mass_components[1] + clientObject.mass_z = mass_components[2] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Line Load to client model + Model.clientModel.service.set_line_load(load_case_no, clientObject) diff --git a/package/RFEM/Loads/memberLoad.py b/package/RFEM/Loads/memberLoad.py new file mode 100644 index 00000000..2312dfe5 --- /dev/null +++ b/package/RFEM/Loads/memberLoad.py @@ -0,0 +1,2114 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import LoadDirectionType, MemberLoadType, MemberLoadDistribution, MemberLoadDirection, MemberLoadDirectionOrientation +from RFEM.enums import MemberLoadEccentricityHorizontalAlignment, MemberLoadEccentricityVerticalAlignment, MemberLoadEccentricitySectionMiddle +from RFEM.enums import MemberLoadAxisDefinitionType, MemberLoadAxisDefinitionAxisOrientation, MemberLoadAxisDefinition + +class MemberLoad(): + def __init__(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_direction = LoadDirectionType.LOAD_DIRECTION_LOCAL_Z, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + members_no (str): Assigned Members + load_direction (enum): Load Directin 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Member Load Distribution + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Force(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution= MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction= MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + force_eccentricity: bool= False, + list_reference: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + 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 == 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], ...] + 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, 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, + 'is_eccentricity_at_end_different_from_start': False, + 'eccentricity_y_at_end': 0.0, + 'eccentricity_y_at_start': 0.0, + 'eccentricity_z_at_end': 0.0, + 'eccentricity_z_at_start': 0.0} + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution= load_distribution.name + + #Load Magnitude and Parameters + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM" or load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM_TOTAL": + clientObject.magnitude = load_parameter + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_1": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + if load_parameter[0] == False: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_absolute = load_parameter[2] + else: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_relative = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_N": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude = load_parameter[2] + clientObject.count_n = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2x2": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.distance_c_is_defined_as_relative = load_parameter[2] + clientObject.magnitude = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + if load_parameter[2] == False: + clientObject.distance_c_absolute = load_parameter[6] + else: + clientObject.distance_c_relative = load_parameter[6] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_TRAPEZOIDAL": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_TAPERED": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_PARABOLIC": + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING_IN_Z": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Reference to List of Members + clientObject.reference_to_list_of_members = list_reference + + #Force Eccentiricity + clientObject.has_force_eccentricity = force_eccentricity + + if force_eccentricity == True: + + params_ecc = {'eccentricity_horizontal_alignment': MemberLoadEccentricityHorizontalAlignment.ALIGN_NONE, + 'eccentricity_vertical_alignment': MemberLoadEccentricityVerticalAlignment.ALIGN_NONE, + 'eccentricity_section_middle': MemberLoadEccentricitySectionMiddle.LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, + 'is_eccentricity_at_end_different_from_start': False, + 'eccentricity_y_at_end': 0.0, + 'eccentricity_y_at_start': 0.0, + 'eccentricity_z_at_end': 0.0, + 'eccentricity_z_at_start': 0.0} + + params_ecc.update(params) + + if params_ecc['is_eccentricity_at_end_different_from_start'] == False: + + clientObject.eccentricity_horizontal_alignment= params_ecc['eccentricity_horizontal_alignment'].name + clientObject.eccentricity_vertical_alignment= params_ecc['eccentricity_vertical_alignment'].name + clientObject.eccentricity_section_middle = params_ecc['eccentricity_section_middle'].name + clientObject.eccentricity_y_at_end= params_ecc['eccentricity_y_at_start'] + clientObject.eccentricity_y_at_start= params_ecc['eccentricity_y_at_start'] + clientObject.eccentricity_z_at_end= params_ecc['eccentricity_z_at_start'] + clientObject.eccentricity_z_at_start= params_ecc['eccentricity_z_at_start'] + + elif params_ecc['is_eccentricity_at_end_different_from_start'] == True: + + clientObject.eccentricity_horizontal_alignment= params_ecc['eccentricity_horizontal_alignment'] + clientObject.eccentricity_vertical_alignment= params_ecc['eccentricity_vertical_alignment'] + clientObject.eccentricity_section_middle = params_ecc['eccentricity_section_middle'] + clientObject.eccentricity_y_at_end= params_ecc['eccentricity_y_at_end'] + clientObject.eccentricity_y_at_start= params_ecc['eccentricity_y_at_start'] + clientObject.eccentricity_z_at_end= params_ecc['eccentricity_z_at_end'] + clientObject.eccentricity_z_at_start= params_ecc['eccentricity_z_at_start'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if 'eccentricity_horizontal_alignment' or 'eccentricity_vertical_alignment' or 'eccentricity_section_middle' or 'is_eccentricity_at_end_different_from_start' or 'eccentricity_y_at_end' or 'eccentricity_y_at_start' or 'eccentricity_z_at_end' or 'eccentricity_z_at_start': + pass + else: + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Moment(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution= MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction= MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + list_reference: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + 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 == LOAD_DISTRIBUTION_UNIFORM: + 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): Enable/Disable List Reference Option + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_MOMENT + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution= load_distribution.name + + #Load Magnitude and Parameters + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + clientObject.magnitude = load_parameter[0] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_1": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + if load_parameter[0] == False: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_absolute = load_parameter[2] + else: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_relative = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_N": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude = load_parameter[2] + clientObject.count_n = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2x2": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.distance_c_is_defined_as_relative = load_parameter[2] + clientObject.magnitude = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + if load_parameter[2] == False: + clientObject.distance_c_absolute = load_parameter[6] + else: + clientObject.distance_c_relative = load_parameter[6] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_TRAPEZOIDAL": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_TAPERED": + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_PARABOLIC": + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Reference to List of Members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Mass(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + individual_mass_components: bool=False, + mass_components = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + members_no (str):Assigned Member(s) + individual_mass_components (bool): Enable/Disable Individual Mass Components Option + 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 + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + clientObject.load_type = MemberLoadType.E_TYPE_MASS.name + + # Member Load Distribution + clientObject.load_distribution= MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Individual Mass Components + clientObject.individual_mass_components = individual_mass_components + + # Mass magnitude + if individual_mass_components == False: + clientObject.mass_global = mass_components[0] + else: + clientObject.mass_x = mass_components[0] + clientObject.mass_y = mass_components[1] + clientObject.mass_z = mass_components[2] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Temperature(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + list_reference: bool= False, + 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 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 + ''' + + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_TEMPERATURE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude_t_b = load_parameter[0] + clientObject.magnitude_t_t = load_parameter[1] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + clientObject.magnitude_t_b_1 = load_parameter[0] + clientObject.magnitude_t_b_2 = load_parameter[1] + clientObject.magnitude_t_t_1 = load_parameter[2] + clientObject.magnitude_t_t_2 = load_parameter[3] + + if load_over_total_length == False: + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + + clientObject.magnitude_t_b_1 = load_parameter[0] + clientObject.magnitude_t_b_2 = load_parameter[1] + clientObject.magnitude_t_t_1 = load_parameter[2] + clientObject.magnitude_t_t_2 = load_parameter[3] + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + + clientObject.magnitude_t_b_1 = load_parameter[0] + clientObject.magnitude_t_b_2 = load_parameter[1] + clientObject.magnitude_t_b_3 = load_parameter[2] + clientObject.magnitude_t_t_1 = load_parameter[3] + clientObject.magnitude_t_t_2 = load_parameter[4] + clientObject.magnitude_t_t_3 = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==4 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = load_parameter[i][2] + mlvlp.magnitude_delta_t = load_parameter[i][3] + mlvlp.magnitude_t_t = load_parameter[i][2] + mlvlp.magnitude_t_b = load_parameter[i][3] + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Reference to list of members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def TemperatureChange(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + list_reference: bool= False, + 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 Member(s) + load_distribution (enum): Load Distribution + load_direction (enum): Load Direction Enumeration + 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 == 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 == True: + load_parameter = [delta_t_1, delta_t_2, t_c_1, t_c_2] + 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: + 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: + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_TEMPERATURE_CHANGE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude_delta_t = load_parameter[0] + clientObject.magnitude_t_c = load_parameter[1] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + clientObject.magnitude_delta_t_1 = load_parameter[0] + clientObject.magnitude_delta_t_2 = load_parameter[1] + clientObject.magnitude_t_c_1 = load_parameter[2] + clientObject.magnitude_t_c_2 = load_parameter[3] + + if load_over_total_length == False: + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + + clientObject.magnitude_delta_t_1 = load_parameter[0] + clientObject.magnitude_delta_t_2 = load_parameter[1] + clientObject.magnitude_t_c_1 = load_parameter[2] + clientObject.magnitude_t_c_2 = load_parameter[3] + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + + clientObject.magnitude_delta_t_1 = load_parameter[0] + clientObject.magnitude_delta_t_2 = load_parameter[1] + clientObject.magnitude_delta_t_3 = load_parameter[2] + clientObject.magnitude_t_c_1 = load_parameter[3] + clientObject.magnitude_t_c_2 = load_parameter[4] + clientObject.magnitude_t_c_3 = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==4 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = load_parameter[i][2] + mlvlp.magnitude_delta_t = load_parameter[i][3] + mlvlp.magnitude_t_t = load_parameter[i][2] + mlvlp.magnitude_t_b = load_parameter[i][3] + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Reference to list of members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def AxialStrain(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_X, + load_parameter = [], + list_reference: bool= False, + 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 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 = [epsilon] + 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: + load_parameter = [epsilon1, epsilon2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [epsilon1, epsilon2, epsilon3] + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_AXIAL_STRAIN + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_over_total_length == False: + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Reference to list of members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def AxialDisplacement(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_X, + magnitude : float = 0.0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_AXIAL_DISPLACEMENT + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Precamber(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + list_reference: bool= False, + 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 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 = [magnitude] + 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: + 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: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_PRECAMBER + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_over_total_length == False: + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Reference to list of members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def InitialPrestress(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_X, + magnitude : float = 0.0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_INITIAL_PRESTRESS + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Displacement(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + list_reference: bool= False, + 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 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 = [magnitude] + 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: + 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: + 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: + 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: + load_parameter = [[distance, delta_distance, magnitude], ...] + 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: + 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: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_DISPLACEMENT + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[2] + else: + clientObject.distance_a_absolute = load_parameter[2] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[3] + else: + clientObject.distance_a_absolute = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[4] + else: + clientObject.distance_b_absolute = load_parameter[4] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + clientObject.distance_c_is_defined_as_relative = load_parameter[3] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + if load_parameter[3]: + clientObject.distance_c_relative = load_parameter[6] + else: + clientObject.distance_c_absolute = load_parameter[6] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_over_total_length == False: + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Reference to list of members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def Rotation(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + list_reference: bool= False, + 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 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 = [magnitude] + 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: + 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: + 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: + 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: + load_parameter = [[distance, delta_distance, magnitude], ...] + 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: + 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: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_ROTATION + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[2] + else: + clientObject.distance_a_absolute = load_parameter[2] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[3] + else: + clientObject.distance_a_absolute = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[4] + else: + clientObject.distance_b_absolute = load_parameter[4] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + clientObject.distance_c_is_defined_as_relative = load_parameter[3] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + if load_parameter[3]: + clientObject.distance_c_relative = load_parameter[6] + else: + clientObject.distance_c_absolute = load_parameter[6] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_over_total_length == False: + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution == MemberLoadDistribution.LOAD_DISTRIBUTION_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_load_varying_load_parameters.append(mlvlp) + + # Reference to list of members + clientObject.reference_to_list_of_members = list_reference + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def PipeContentFull(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_direction_orientation = MemberLoadDirectionOrientation.LOAD_DIRECTION_FORWARD, + 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 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_PIPE_CONTENT_FULL + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = MemberLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + #Member Load Orientation + clientObject.load_direction_orientation = load_direction_orientation.name + + #Load Magnitude + clientObject.magnitude = specific_weight + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def PipeContentPartial(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + load_direction_orientation = MemberLoadDirectionOrientation.LOAD_DIRECTION_FORWARD, + specific_weight : float = 0.0, + 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 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_PIPE_CONTENT_PARTIAL + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = MemberLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + #Member Load Orientation + clientObject.load_direction_orientation = load_direction_orientation.name + + #Load Magnitude + clientObject.magnitude = specific_weight + + #Filling Height + clientObject.filling_height = filling_height + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def PipeInternalPressure(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + pressure : float = 0.0, + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + 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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_PIPE_INTERNAL_PRESSURE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = MemberLoadDirection.LOAD_DIRECTION_LOCAL_X.name + + #Load Magnitude + clientObject.magnitude = pressure + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) + + def RotaryMotion(self, + no: int = 1, + load_case_no: int = 1, + members_no: str = '1', + angular_acceleration : float = 1.0, + angular_velocity : float = 2.0, + axis_definition_type = MemberLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS, + axis_orientation = MemberLoadAxisDefinitionAxisOrientation.AXIS_POSITIVE, + axis_definition = MemberLoadAxisDefinition.AXIS_X, + axis_definition_p1 = [1,0,1], + axis_definition_p2 = [0,1,0], + comment: str = '', + params: dict = {}): + + ''' + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + 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 [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') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.members = ConvertToDlString(members_no) + + # Member Load Type + load_type = MemberLoadType.LOAD_TYPE_ROTARY_MOTION + clientObject.load_type = load_type.name + + #Angular Acceleration + clientObject.angular_acceleration = angular_acceleration + + #Angular Velocity + clientObject.angular_velocity = angular_velocity + + #Axis Definition Type + clientObject.axis_definition_type = axis_definition_type.name + + #Axis definition + if axis_definition_type == MemberLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS.name: + clientObject.axis_definition_p1_x = axis_definition_p1[0] + clientObject.axis_definition_p1_y = axis_definition_p1[1] + clientObject.axis_definition_p1_z = axis_definition_p1[2] + + clientObject.axis_definition_p2_x = axis_definition_p2[0] + clientObject.axis_definition_p2_y = axis_definition_p2[1] + clientObject.axis_definition_p2_z = axis_definition_p2[2] + + elif axis_definition_type == MemberLoadAxisDefinitionType.AXIS_DEFINITION_POINT_AND_AXIS.name: + clientObject.axis_definition_p1_x = axis_definition_p1[0] + clientObject.axis_definition_p1_y = axis_definition_p1[1] + clientObject.axis_definition_p1_z = axis_definition_p1[2] + + clientObject.axis_definition_axis = axis_definition.name + clientObject.axis_definition_axis_orientation = axis_orientation.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_load(load_case_no, clientObject) \ No newline at end of file diff --git a/package/RFEM/Loads/membersetload.py b/package/RFEM/Loads/membersetload.py new file mode 100644 index 00000000..1fc24163 --- /dev/null +++ b/package/RFEM/Loads/membersetload.py @@ -0,0 +1,2270 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import MemberSetLoadType, LoadDirectionType, MemberSetLoadDistribution, MemberSetLoadDirection, MemberSetLoadDirectionOrientation +from RFEM.enums import MemberSetLoadEccentricityHorizontalAlignment, MemberSetLoadEccentricityVerticalAlignment, MemberSetLoadEccentricitySectionMiddle +from RFEM.enums import MemberSetLoadAxisDefinitionType, MemberSetLoadAxisDefinitionAxisOrientation, MemberSetLoadAxisDefinition + +class MemberSetLoad(): + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_direction = LoadDirectionType.LOAD_DIRECTION_LOCAL_Z, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_direction (enum): Load Case Enumeration + magnitude (float): Load Magnitude + comment (str, optional): Comments + params (dict, optional): Parameters + """ + + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Member Sets No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Member Load Distribution + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Force(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution= MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction= MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + force_eccentricity: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameter + force_eccentricity (bool): Force Eccentricity Option + comment (str, optional): Comments + params (dict, optional): Parameters + + for LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude] + for LOAD_DISTRIBUTION_UNIFORM_TOTAL: + load_parameter = [magnitude] + for LOAD_DISTRIBUTION_CONCENTRATED_1: + load_parameter = [relative_distance = False, magnitude, distance_a] + for 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: + 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: + load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] + for LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + for 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: + load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] + for LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + for LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + for LOAD_DISTRIBUTION_VARYING_IN_Z: + load_parameter = [[distance, delta_distance, magnitude], ...] + + params: + {'eccentricity_horizontal_alignment': MemberSetLoadEccentricityHorizontalAlignment.ALIGN_NONE, + 'eccentricity_vertical_alignment': MemberSetLoadEccentricityVerticalAlignment.ALIGN_NONE, + 'eccentricity_section_middle': MemberSetLoadEccentricitySectionMiddle.LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, + 'is_eccentricity_at_end_different_from_start': False, + 'eccentricity_y_at_end': 0.0, + 'eccentricity_y_at_start': 0.0, + 'eccentricity_z_at_end': 0.0, + 'eccentricity_z_at_start': 0.0} + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution= load_distribution.name + + #Load Magnitude and Parameters + if load_parameter == []: + raise Exception("WARNING: Load parameter cannot be empty. Kindly check list inputs completeness and correctness.") + else: + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM" or load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM_TOTAL": + if len(load_parameter) == 1: + clientObject.magnitude = load_parameter[0] + else: + raise Exception("WARNING: Load parameter array length should be 1 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_1": + if len(load_parameter) == 3: + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + if load_parameter[0] == False: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_absolute = load_parameter[2] + else: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_relative = load_parameter[2] + else: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_CONCENTRATED_1. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_N": + if len(load_parameter) == 6: + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude = load_parameter[2] + clientObject.count_n = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + else: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_CONCENTRATED_N. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2x2": + if len(load_parameter) == 7: + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.distance_c_is_defined_as_relative = load_parameter[2] + clientObject.magnitude = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + if load_parameter[2] == False: + clientObject.distance_c_absolute = load_parameter[6] + else: + clientObject.distance_c_relative = load_parameter[6] + else: + raise Exception("WARNING: Load parameter array length should be 7 for LOAD_DISTRIBUTION_CONCENTRATED_N. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2": + if len(load_parameter) == 6: + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + else: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_CONCENTRATED_2. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_TRAPEZOIDAL": + if len(load_parameter) == 6: + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + else: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_TAPERED": + if len(load_parameter)==6: + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + else: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + + elif load_distribution.name == "LOAD_DISTRIBUTION_PARABOLIC": + if len(load_parameter)==3: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + else: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING_IN_Z": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Force Eccentiricity + clientObject.has_force_eccentricity = force_eccentricity + + if force_eccentricity == True: + if 'eccentricity_horizontal_alignment' and 'eccentricity_vertical_alignment' and 'eccentricity_section_middle' \ + 'is_eccentricity_at_end_different_from_start' and 'eccentricity_y_at_end' and 'eccentricity_y_at_start' \ + 'eccentricity_z_at_end' and 'eccentricity_z_at_start' in params: + pass + else: + raise Exception("WARNING: Params does not contain all the necessary parameters. Kindly check dictionary") + + params_ecc = {'eccentricity_horizontal_alignment': MemberSetLoadEccentricityHorizontalAlignment.ALIGN_NONE, + 'eccentricity_vertical_alignment': MemberSetLoadEccentricityVerticalAlignment.ALIGN_NONE, + 'eccentricity_section_middle': MemberSetLoadEccentricitySectionMiddle.LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, + 'is_eccentricity_at_end_different_from_start': False, + 'eccentricity_y_at_end': 0.0, + 'eccentricity_y_at_start': 0.0, + 'eccentricity_z_at_end': 0.0, + 'eccentricity_z_at_start': 0.0} + + params_ecc.update(params) + + if params_ecc['is_eccentricity_at_end_different_from_start'] == False: + + clientObject.eccentricity_horizontal_alignment= params_ecc['eccentricity_horizontal_alignment'].name + clientObject.eccentricity_vertical_alignment= params_ecc['eccentricity_vertical_alignment'].name + clientObject.eccentricity_section_middle = params_ecc['eccentricity_section_middle'].name + clientObject.eccentricity_y_at_end= params_ecc['eccentricity_y_at_start'] + clientObject.eccentricity_y_at_start= params_ecc['eccentricity_y_at_start'] + clientObject.eccentricity_z_at_end= params_ecc['eccentricity_z_at_start'] + clientObject.eccentricity_z_at_start= params_ecc['eccentricity_z_at_start'] + + elif params_ecc['is_eccentricity_at_end_different_from_start'] == True: + + clientObject.eccentricity_horizontal_alignment= params_ecc['eccentricity_horizontal_alignment'] + clientObject.eccentricity_vertical_alignment= params_ecc['eccentricity_vertical_alignment'] + clientObject.eccentricity_section_middle = params_ecc['eccentricity_section_middle'] + clientObject.eccentricity_y_at_end= params_ecc['eccentricity_y_at_end'] + clientObject.eccentricity_y_at_start= params_ecc['eccentricity_y_at_start'] + clientObject.eccentricity_z_at_end= params_ecc['eccentricity_z_at_end'] + clientObject.eccentricity_z_at_start= params_ecc['eccentricity_z_at_start'] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if 'eccentricity_horizontal_alignment' or 'eccentricity_vertical_alignment' or 'eccentricity_section_middle' or 'is_eccentricity_at_end_different_from_start' or 'eccentricity_y_at_end' or 'eccentricity_y_at_start' or 'eccentricity_z_at_end' or 'eccentricity_z_at_start': + pass + else: + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Moment(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution= MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction= MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + + for LOAD_DISTRIBUTION_UNIFORM: + load_parameter = magnitude + for LOAD_DISTRIBUTION_CONCENTRATED_1: + load_parameter = [relative_distance = False, magnitude, distance_a] + for 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: + 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: + load_parameter = [relative_distance_a = False, relative_distance_b = False, magnitude_1, magnitude_2, distance_a, distance_b] + for LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + for 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: + load_parameter = [relative_distance_a = False, relative_distance_b = False,magnitude_1, magnitude_2, distance_a, distance_b] + for LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + for LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_MOMENT + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution= load_distribution.name + + #Load Magnitude and Parameters + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + try: + len(load_parameter)==1 + except: + raise Exception("WARNING: Load parameter array length should be 1 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_1": + try: + len(load_parameter)==3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_CONCENTRATED_1. Kindly check list inputs completeness and correctness.") + + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + if load_parameter[0] == False: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_absolute = load_parameter[2] + else: + clientObject.magnitude = load_parameter[1] + clientObject.distance_a_relative = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_N": + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_CONCENTRATED_N. Kindly check list inputs completeness and correctness.") + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude = load_parameter[2] + clientObject.count_n = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2x2": + try: + len(load_parameter)==7 + except: + raise Exception("WARNING: Load parameter array length should be 7 for LOAD_DISTRIBUTION_CONCENTRATED_2x2. Kindly check list inputs completeness and correctness.") + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.distance_c_is_defined_as_relative = load_parameter[2] + clientObject.magnitude = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + if load_parameter[2] == False: + clientObject.distance_c_absolute = load_parameter[6] + else: + clientObject.distance_c_relative = load_parameter[6] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_2": + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_CONCENTRATED_2. Kindly check list inputs completeness and correctness.") + + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_CONCENTRATED_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + elif load_distribution.name == "LOAD_DISTRIBUTION_TRAPEZOIDAL": + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_TAPERED": + try: + len(load_parameter)==4 + except: + raise Exception("WARNING: Load parameter array length should be 4 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + clientObject.distance_a_is_defined_as_relative = load_parameter[0] + clientObject.distance_b_is_defined_as_relative = load_parameter[1] + clientObject.magnitude_1 = load_parameter[2] + clientObject.magnitude_2 = load_parameter[3] + + if load_parameter[0] == False: + clientObject.distance_a_absolute = load_parameter[4] + else: + clientObject.distance_a_relative = load_parameter[4] + + if load_parameter[1] == False: + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.distance_b_relative = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_PARABOLIC": + try: + len(load_parameter)==3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Member Load Direction + clientObject.load_direction = load_direction.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Mass(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + individual_mass_components: bool=False, + mass_components = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + individual_mass_components (bool): Individiual Mass Components Option + mass_components (list): Mass Components + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + clientObject.load_type = MemberSetLoadType.E_TYPE_MASS.name + + # Member Load Distribution + clientObject.load_distribution= MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Individual Mass Components + if not isinstance(individual_mass_components, bool): + raise Exception("WARNING: Type of individual mass components should be bool. Kindly check inputs correctness.") + clientObject.individual_mass_components = individual_mass_components + + # Mass magnitude + if individual_mass_components == False: + clientObject.mass_global = mass_components[0] + else: + clientObject.mass_x = mass_components[0] + clientObject.mass_y = mass_components[1] + clientObject.mass_z = mass_components[2] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Temperature(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + load_over_total_length: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameters + load_over_total_length (bool): Load Over Total Length Option + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [tt, tb] + for load_distribution = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [tt1, tt2, tb1, tb2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [tb1, tb2, tb3, tt1, tt2, tt3] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_TEMPERATURE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + try: + len(load_parameter)==2 + except: + raise Exception("WARNING: Load parameter array length should be 2 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_t_b = load_parameter[0] + clientObject.magnitude_t_t = load_parameter[1] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + try: + len(load_parameter)==8 + except: + raise Exception("WARNING: Load parameter array length should be 8 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_t_b_1 = load_parameter[0] + clientObject.magnitude_t_b_2 = load_parameter[1] + clientObject.magnitude_t_t_1 = load_parameter[2] + clientObject.magnitude_t_t_2 = load_parameter[3] + + if not isinstance(load_over_total_length, bool): + raise Exception("WARNING: Type of load over total length should be bool. Kindly check inputs correctness.") + + if load_over_total_length == False: + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + try: + len(load_parameter)==8 + except: + raise Exception("WARNING: Load parameter array length should be 8 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_t_b_1 = load_parameter[0] + clientObject.magnitude_t_b_2 = load_parameter[1] + clientObject.magnitude_t_t_1 = load_parameter[2] + clientObject.magnitude_t_t_2 = load_parameter[3] + + if not isinstance(load_parameter[4], bool): + raise Exception("WARNING: Type of the fourth load parameter should be bool. Kindly check inputs correctness.") + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if not isinstance(load_parameter[5], bool): + raise Exception("WARNING: Type of the fifth load parameter should be bool. Kindly check inputs correctness.") + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_t_b_1 = load_parameter[0] + clientObject.magnitude_t_b_2 = load_parameter[1] + clientObject.magnitude_t_b_3 = load_parameter[2] + clientObject.magnitude_t_t_1 = load_parameter[3] + clientObject.magnitude_t_t_2 = load_parameter[4] + clientObject.magnitude_t_t_3 = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==4 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = load_parameter[i][2] + mlvlp.magnitude_delta_t = load_parameter[i][3] + mlvlp.magnitude_t_t = load_parameter[i][2] + mlvlp.magnitude_t_b = load_parameter[i][3] + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def TemperatureChange(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + load_over_total_length: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameters + load_over_total_length (bool): Load Over Total Length Option + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [tc, delta_t] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + for load_over_total_length: bool= 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: + load_parameter = [delta_t_1, delta_t_2, t_c_1, t_c_2] + for load_distribution = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_TEMPERATURE_CHANGE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + try: + len(load_parameter)==2 + except: + raise Exception("WARNING: Load parameter array length should be 2 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_delta_t = load_parameter[0] + clientObject.magnitude_t_c = load_parameter[1] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + try: + len(load_parameter)==8 + except: + raise Exception("WARNING: Load parameter array length should be 8 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_delta_t_1 = load_parameter[0] + clientObject.magnitude_delta_t_2 = load_parameter[1] + clientObject.magnitude_t_c_1 = load_parameter[2] + clientObject.magnitude_t_c_2 = load_parameter[3] + + if not isinstance(load_over_total_length, bool): + raise Exception("WARNING: Type of the load over total length should be bool. Kindly check inputs correctness.") + + if load_over_total_length == False: + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + try: + len(load_parameter)==8 + except: + raise Exception("WARNING: Load parameter array length should be 8 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_delta_t_1 = load_parameter[0] + clientObject.magnitude_delta_t_2 = load_parameter[1] + clientObject.magnitude_t_c_1 = load_parameter[2] + clientObject.magnitude_t_c_2 = load_parameter[3] + + if load_parameter[4] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[6] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[6] + + if load_parameter[5] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[7] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[7] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_delta_t_1 = load_parameter[0] + clientObject.magnitude_delta_t_2 = load_parameter[1] + clientObject.magnitude_delta_t_3 = load_parameter[2] + clientObject.magnitude_t_c_1 = load_parameter[3] + clientObject.magnitude_t_c_2 = load_parameter[4] + clientObject.magnitude_t_c_3 = load_parameter[5] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==4 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = load_parameter[i][2] + mlvlp.magnitude_delta_t = load_parameter[i][3] + mlvlp.magnitude_t_t = load_parameter[i][2] + mlvlp.magnitude_t_b = load_parameter[i][3] + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def AxialStrain(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_X, + load_parameter = [], + load_over_total_length: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameters + load_over_total_length (bool): Load Over Total Length Option + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [epsilon] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + load_parameter = [epsilon1, epsilon2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [epsilon1, epsilon2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [epsilon1, epsilon2, epsilon3] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_AXIAL_STRAIN + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + try: + len(load_parameter)==1 + except: + raise Exception("WARNING: Load parameter array length should be 1 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if not isinstance(load_over_total_length, bool): + raise Exception("WARNING: Type of the load over total length should be bool. Kindly check inputs correctness.") + + if load_over_total_length == False: + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + try: + len(load_parameter)==3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def AxialDisplacement(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_X, + magnitude : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Set + 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_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_AXIAL_DISPLACEMENT + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Precamber(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + load_over_total_length: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (enum): Load Parameters + load_over_total_length (bool): Load Over Total Lenth Option + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_PRECAMBER + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + try: + len(load_parameter)==1 + except: + raise Exception("WARNING: Load parameter array length should be 1 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if not isinstance(load_over_total_length, bool): + raise Exception("WARNING: Type of the load over total length should be bool. Kindly check inputs correctness.") + + if load_over_total_length == False: + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if load_parameter[2] == True: + clientObject.distance_a_is_defined_as_relative = True + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_is_defined_as_relative = False + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3] == True: + clientObject.distance_b_is_defined_as_relative = True + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_is_defined_as_relative = False + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + try: + len(load_parameter)==3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution.name == "LOAD_DISTRIBUTION_VARYING": + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def InitialPrestress(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_X, + magnitude : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_direction (enum): Load Direction Enumeration + magnitude (float): Load Magnitude + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_INITIAL_PRESTRESS + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + clientObject.magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Displacement(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + load_over_total_length: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameters + load_over_total_length (bool): Load Over Total Length Option + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude] + for load_distrubition = MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_a] + for load_distrubition = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_DISPLACEMENT + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + try: + len(load_parameter)==1 + except: + raise Exception("WARNING: Load parameter array length should be 1 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + try: + len(load_parameter)==3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_CONCENTRATED_1. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[2] + else: + clientObject.distance_a_absolute = load_parameter[2] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: + try: + len(load_parameter)==5 + except: + raise Exception("WARNING: Load parameter array length should be 5 for LOAD_DISTRIBUTION_CONCENTRATED_N. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[3] + else: + clientObject.distance_a_absolute = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[4] + else: + clientObject.distance_b_absolute = load_parameter[4] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: + try: + len(load_parameter)==7 + except: + raise Exception("WARNING: Load parameter array length should be 7 for LOAD_DISTRIBUTION_CONCENTRATED_2x2. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + clientObject.distance_c_is_defined_as_relative = load_parameter[3] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + if load_parameter[3]: + clientObject.distance_c_relative = load_parameter[6] + else: + clientObject.distance_c_absolute = load_parameter[6] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_CONCENTRATED_2. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if not isinstance(load_over_total_length, bool): + raise Exception("WARNING: Type of the load over total length should be bool. Kindly check inputs correctness.") + + if load_over_total_length == False: + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + try: + len(load_parameter)==6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + try: + len(load_parameter)==3 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def Rotation(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_Z, + load_parameter = [], + load_over_total_length: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_distribution (enum): Load Distribution Enumeration + load_direction (enum): Load Direction Enumeration + load_parameter (list): Load Parameters + load_over_total_length (bool): Load Over Total Length + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude] + for load_distrubition = MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + load_parameter = [magnitude, distance_a_is_defined_as_relative = False, distance_a] + for load_distrubition = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.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 = MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZIODAL: + load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + load_parameter = [magnitude_1, magnitude_2, distance_a_relative = False, distance_a_relative = False, a_distance, b_distance] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + load_parameter = [magnitude_1, magnitude_2, magnitude_3] + for load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + load_parameter = [[distance, delta_distance, magnitude], ...] + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_ROTATION + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = load_distribution.name + + # Member Load Direction + clientObject.load_direction = load_direction.name + + #Load Magnitude + if load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + try: + len(load_parameter)==1 + except: + raise Exception("WARNING: Load parameter array length should be 1 for LOAD_DISTRIBUTION_UNIFORM. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_1: + try: + len(load_parameter) == 3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_CONCENTRATED_1. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[2] + else: + clientObject.distance_a_absolute = load_parameter[2] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_N: + try: + len(load_parameter) == 5 + except: + raise Exception("WARNING: Load parameter array length should be 5 for LOAD_DISTRIBUTION_CONCENTRATED_N. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[3] + else: + clientObject.distance_a_absolute = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[4] + else: + clientObject.distance_b_absolute = load_parameter[4] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2x2: + try: + len(load_parameter) == 7 + except: + raise Exception("WARNING: Load parameter array length should be 7 for LOAD_DISTRIBUTION_CONCENTRATED_2x2. Kindly check list inputs completeness and correctness.") + clientObject.magnitude = load_parameter[0] + clientObject.distance_a_is_defined_as_relative = load_parameter[1] + clientObject.distance_b_is_defined_as_relative = load_parameter[2] + clientObject.distance_c_is_defined_as_relative = load_parameter[3] + + if load_parameter[1]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[2]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + if load_parameter[3]: + clientObject.distance_c_relative = load_parameter[6] + else: + clientObject.distance_c_absolute = load_parameter[6] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_2: + try: + len(load_parameter) == 6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_CONCENTRATED_2. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_CONCENTRATED_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TRAPEZOIDAL: + try: + len(load_parameter) == 6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TRAPEZOIDAL. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + if not isinstance(load_over_total_length, bool): + raise Exception("WARNING: Type of the load over total length should be bool. Kindly check inputs correctness.") + + if load_over_total_length == False: + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + else: + clientObject.load_is_over_total_length = True + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_TAPERED: + try: + len(load_parameter) == 6 + except: + raise Exception("WARNING: Load parameter array length should be 6 for LOAD_DISTRIBUTION_TAPERED. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.distance_a_is_defined_as_relative = load_parameter[2] + clientObject.distance_b_is_defined_as_relative = load_parameter[3] + + if load_parameter[2]: + clientObject.distance_a_relative = load_parameter[4] + else: + clientObject.distance_a_absolute = load_parameter[4] + + if load_parameter[3]: + clientObject.distance_b_relative = load_parameter[5] + else: + clientObject.distance_b_absolute = load_parameter[5] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_PARABOLIC: + try: + len(load_parameter) == 3 + except: + raise Exception("WARNING: Load parameter array length should be 3 for LOAD_DISTRIBUTION_PARABOLIC. Kindly check list inputs completeness and correctness.") + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + elif load_distribution == MemberSetLoadDistribution.LOAD_DISTRIBUTION_VARYING: + try: + len(load_parameter[0])==3 + except: + print("WARNING: MemberSetLoad no: %x, load case: %x - Wrong data input." % (no, load_case_no)) + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:member_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:member_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + mlvlp.magnitude_t_c = 0.0 + mlvlp.magnitude_delta_t = 0.0 + mlvlp.magnitude_t_t = 0.0 + mlvlp.magnitude_t_b = 0.0 + + clientObject.varying_load_parameters.member_set_load_varying_load_parameters.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def PipeContentFull(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_direction_orientation = MemberSetLoadDirectionOrientation.LOAD_DIRECTION_FORWARD, + specific_weight : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_direction_orientation (enum): Load Direction Orientation Enumeration + specific_weight (float): Specific Weight + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_PIPE_CONTENT_FULL + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = MemberSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + #Member Load Orientation + clientObject.load_direction_orientation = load_direction_orientation.name + + #Load Magnitude + clientObject.magnitude = specific_weight + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def PipeContentPartial(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + load_direction_orientation = MemberSetLoadDirectionOrientation.LOAD_DIRECTION_FORWARD, + specific_weight : float = 0.0, + filling_height : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + load_direction_orientation (enum): Load Direction Orientation Enumeration + specific_weight (float): Specific Weight + filling_height (float): Filling Height + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_PIPE_CONTENT_PARTIAL + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = MemberSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + #Member Load Orientation + clientObject.load_direction_orientation = load_direction_orientation.name + + #Load Magnitude + clientObject.magnitude = specific_weight + + #Filling Height + clientObject.filling_height = filling_height + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def PipeInternalPressure(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + pressure : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + pressure (float): Pressure + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_PIPE_INTERNAL_PRESSURE + clientObject.load_type = load_type.name + + # Member Load Distribution + clientObject.load_distribution = MemberSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Member Load Direction + clientObject.load_direction = MemberSetLoadDirection.LOAD_DIRECTION_LOCAL_X.name + + #Load Magnitude + clientObject.magnitude = pressure + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) + + def RotaryMotion(self, + no: int = 1, + load_case_no: int = 1, + member_sets: str = '1', + angular_acceleration : float = 0.0, + angular_velocity : float = 0.0, + axis_definition_type = MemberSetLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS, + axis_orientation = MemberSetLoadAxisDefinitionAxisOrientation.AXIS_POSITIVE, + axis_definition = MemberSetLoadAxisDefinition.AXIS_X, + axis_definition_p1 = [], + axis_definition_p2 = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + member_sets (str): Assigned Member Sets + 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):Axis Definition First Point + axis_definition_p2 (list): Axis Definition Second Point + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Member Load + clientObject = Model.clientModel.factory.create('ns0:member_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Members No. (e.g. '5 6 7 12') + clientObject.member_sets = ConvertToDlString(member_sets) + + # Member Load Type + load_type = MemberSetLoadType.LOAD_TYPE_ROTARY_MOTION + clientObject.load_type = load_type.name + + #Angular Acceleration + clientObject.angular_acceleration = angular_acceleration + + #Angular Velocity + clientObject.angular_velocity = angular_velocity + + #Axis Definition Type + clientObject.axis_definition_type = axis_definition_type.name + + #Axis definition + if clientObject.axis_definition_type == "AXIS_DEFINITION_TWO_POINTS": + clientObject.axis_definition_p1_x = axis_definition_p1[0] + clientObject.axis_definition_p1_y = axis_definition_p1[1] + clientObject.axis_definition_p1_z = axis_definition_p1[2] + + clientObject.axis_definition_p2_x = axis_definition_p2[0] + clientObject.axis_definition_p2_y = axis_definition_p2[1] + clientObject.axis_definition_p2_z = axis_definition_p2[2] + + elif clientObject.axis_definition_type == "AXIS_DEFINITION_POINT_AND_AXIS": + clientObject.axis_definition_p1_x = axis_definition_p1[0] + clientObject.axis_definition_p1_y = axis_definition_p1[1] + clientObject.axis_definition_p1_z = axis_definition_p1[2] + + clientObject.axis_definition_axis = axis_definition.name + clientObject.axis_definition_axis_orientation = axis_orientation.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Load Member Load to client model + Model.clientModel.service.set_member_set_load(load_case_no, clientObject) diff --git a/package/RFEM/Loads/nodalLoad.py b/package/RFEM/Loads/nodalLoad.py new file mode 100644 index 00000000..9f2f2227 --- /dev/null +++ b/package/RFEM/Loads/nodalLoad.py @@ -0,0 +1,525 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import LoadDirectionType, NodalLoadType, NodalLoadSpecificDirectionType + +class NodalLoad(): + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + nodes_no: str= '1', + load_direction= LoadDirectionType.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W, + magnitude: float = 0.0, + comment: str= '', + params: dict= {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + nodes_no (str): Assigned Nodes + load_direction (enum): Load Direction Enumeration + magnitude (float): Force Magnitude + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Nodal Force + clientObject = Model.clientModel.factory.create('ns0:nodal_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Nodal Force No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Nodes No. (e.g. '5 6 7 12') + clientObject.nodes = ConvertToDlString(nodes_no) + + # Force Direction + clientObject.load_direction = load_direction.name + + # Load Type + load_type = NodalLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + # Magnitude + clientObject.force_magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Nodal Force to client model + Model.clientModel.service.set_nodal_load(load_case_no, clientObject) + + def Force(self, + no: int= 1, + load_case_no: int = 1, + nodes_no: str= '1', + load_direction= LoadDirectionType.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W, + magnitude: float= 0.0, + force_eccentricity: bool = False, + specific_direction: bool = False, + shifted_display: bool = False, + comment: str= '', + params= {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + nodes_no (str): Assigned Nodes + load_direction (enum): Load Direction Enumeration + magnitude (float): Force Magnitude + force_eccentricity (bool): Enable/Disable Force Eccentricity Option + specific_direction (bool): Enable/Disable Specific Direction Option + shifted_display (bool): Enable/Disable Shifted Display Option + comment (str, optional): Comments + params (dict, optional): + + For specific_direction type DIRECTION_TYPE_ROTATED_VIA_3_ANGLES; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_ROTATED_VIA_3_ANGLES, NodalLoadAxesSequence, angle_1, angle_2, angle_3, angle_x, angle_y, angle_z]} + For specific_direction type DIRECTION_TYPE_DIRECTED_TO_NODE; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_DIRECTED_TO_NODE, nodes_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_TWO_NODES; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_TWO_NODES, nodes_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE, line_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER, member_no]} + For force_eccentricity; + params={'force_eccentricity' : [ex, ey, ez]} + For shifted_display; + params={'shifted_display' : [offset_x, offset_y, offset_y, distance]} + """ + # Client model | Nodal Force + clientObject = Model.clientModel.factory.create('ns0:nodal_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Nodal Force No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Nodes No. (e.g. '5 6 7 12') + clientObject.nodes = ConvertToDlString(nodes_no) + + # Force Direction + clientObject.load_direction = load_direction.name + + # Load Type + load_type = NodalLoadType.LOAD_TYPE_FORCE + clientObject.load_type = load_type.name + + ## Force Magnitude + clientObject.force_magnitude = magnitude + + #Option Check + if force_eccentricity and shifted_display: + raise Exception("Only one of force_eccentiricity and shifted_display could be TRUE") + + # Specific Direction + if specific_direction: + + if 'specific_direction' not in list(params.keys()): + raise Exception("Required key is missing") + + params_s = params['specific_direction'] + + clientObject.has_specific_direction = specific_direction + clientObject.specific_direction_type = params_s[0].name + + if params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_ROTATED_VIA_3_ANGLES: + clientObject.axes_sequence = params_s[1].name + clientObject.rotated_about_angle_1 = params_s[2] + clientObject.rotated_about_angle_2 = params_s[3] + clientObject.rotated_about_angle_3 = params_s[4] + clientObject.rotated_about_angle_x = params_s[5] + clientObject.rotated_about_angle_y = params_s[6] + clientObject.rotated_about_angle_z = params_s[7] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_DIRECTED_TO_NODE: + clientObject.directed_to_node_direction_node = params_s[1] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_TWO_NODES: + clientObject.parallel_to_two_nodes_first_node = params_s[1] + clientObject.parallel_to_two_nodes_second_node = params_s[2] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE: + clientObject.parallel_to_line = params_s[1] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER: + clientObject.parallel_to_member = params_s[1] + + #Force Eccentiricity + if force_eccentricity: + + if 'force_eccentricity' not in list(params.keys()): + raise Exception("Required key is missing") + + params_e = params['force_eccentricity'] + + clientObject.has_force_eccentricity = True + + clientObject.force_eccentricity_x = params_e[0] + clientObject.force_eccentricity_y = params_e[1] + clientObject.force_eccentricity_z = params_e[2] + + #Shifted Display + if shifted_display: + + if 'shifted_display' not in list(params.keys()): + raise Exception("Required key is missing") + + params_d = params['shifted_display'] + + clientObject.has_shifted_display = shifted_display + + clientObject.offset_x = params_d[0] + clientObject.offset_y = params_d[1] + clientObject.offset_z = params_d[2] + clientObject.size_or_distance = params_d[3] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if 'specific_direction' or 'force_eccentricity' or 'force_eccentricity' in params.keys(): + pass + else: + for key in params: + clientObject[key] = params[key] + + # Add Nodal Force to client model + Model.clientModel.service.set_nodal_load(load_case_no, clientObject) + + def Moment(self, + no: int= 1, + load_case_no: int= 1, + nodes_no: str= '1', + load_direction= LoadDirectionType.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W, + moment_magnitude: float= 0.0, + specific_direction: bool= False, + shifted_display: bool= False, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + nodes_no (str): Assigned Nodes + load_direction (enum): Load Direction Enumeration + moment_magnitude (float): Moment Magnitude + specific_direction (bool): Enable/Disable Specific Direction Option + shifted_display (bool): Enable/Disable Shifted Display Option + comment (str, optional): Comments + params (dict, optional): + For specific_direction type DIRECTION_TYPE_ROTATED_VIA_3_ANGLES; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_ROTATED_VIA_3_ANGLES, NodalLoadAxesSequence, angle_1, angle_2, angle_3, angle_x, angle_y, angle_z]} + For specific_direction type DIRECTION_TYPE_DIRECTED_TO_NODE; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_DIRECTED_TO_NODE, nodes_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_TWO_NODES; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_TWO_NODES, nodes_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE, line_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER, member_no]} + For shifted_display; + params={'shifted_display' : [offset_x, offset_y, offset_y, distance]} + """ + # Client model | Nodal Force + clientObject = Model.clientModel.factory.create('ns0:nodal_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Nodal Force No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Nodes No. (e.g. '5 6 7 12') + clientObject.nodes = ConvertToDlString(nodes_no) + + # Force Direction + clientObject.load_direction = load_direction.name + + # Load Type + load_type = NodalLoadType.LOAD_TYPE_MOMENT + clientObject.load_type = load_type.name + + ## Force Magnitude + clientObject.moment_magnitude = moment_magnitude + + # Specific Direction + if specific_direction: + + if 'specific_direction' not in list(params.keys()): + raise Exception("Required key is missing") + + params_s = params['specific_direction'] + + clientObject.has_specific_direction = specific_direction + clientObject.specific_direction_type = params_s[0].name + + if params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_ROTATED_VIA_3_ANGLES: + clientObject.axes_sequence = params_s[1].name + clientObject.rotated_about_angle_1 = params_s[2] + clientObject.rotated_about_angle_2 = params_s[3] + clientObject.rotated_about_angle_3 = params_s[4] + clientObject.rotated_about_angle_x = params_s[5] + clientObject.rotated_about_angle_y = params_s[6] + clientObject.rotated_about_angle_z = params_s[7] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_DIRECTED_TO_NODE: + clientObject.directed_to_node_direction_node = params_s[1] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_TWO_NODES: + clientObject.parallel_to_two_nodes_first_node = params_s[1] + clientObject.parallel_to_two_nodes_second_node = params_s[2] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE: + clientObject.parallel_to_line = params_s[1] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER: + clientObject.parallel_to_member = params_s[1] + + #Shifted Display + if shifted_display: + + if 'shifted_display' not in list(params.keys()): + raise Exception("Required key is missing") + + params_d = params['shifted_display'] + + clientObject.has_shifted_display = shifted_display + + clientObject.offset_x = params_d[0] + clientObject.offset_y = params_d[1] + clientObject.offset_z = params_d[2] + clientObject.size_or_distance = params_d[3] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if 'specific_direction' or 'force_eccentricity' in params.keys(): + pass + else: + for key in params: + clientObject[key] = params[key] + + # Add Nodal Force to client model + Model.clientModel.service.set_nodal_load(load_case_no, clientObject) + + def Components(self, + no: int= 1, + load_case_no: int= 1, + nodes_no: str= '1', + components = [], + specific_direction: bool= False, + force_eccentricity: bool= False, + shifted_display: bool= False, + comment: str= '', + params: dict= {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + nodes_no (str): Assigned Nodes + components (list): Component Magnitude List + specific_direction (bool): Enable/Disable Specific Direction Option + force_eccentricity(bool): Enable/Disable Force Direction Option + shifted_display(bool): Enable/Disable Shifted Display Option + comment (str, optional): Comments + params (dict, optional): + For specific_direction type DIRECTION_TYPE_ROTATED_VIA_3_ANGLES; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_ROTATED_VIA_3_ANGLES, NodalLoadAxesSequence, angle_1, angle_2, angle_3, angle_x, angle_y, angle_z]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE, line_no]} + For specific_direction type DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER; + params={'specific_direction' : [NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER, member_no]} + For force_eccentricity; + params={'force_eccentricity' : [ex, ey, ez]} + + For shifted_display; + params={'shifted_display' : [offset_x, offset_y, offset_y, distance]} + """ + # Client model | Nodal Force + clientObject = Model.clientModel.factory.create('ns0:nodal_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Nodal Force No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Nodes No. (e.g. '5 6 7 12') + clientObject.nodes = ConvertToDlString(nodes_no) + + # Load Type + load_type = NodalLoadType.LOAD_TYPE_COMPONENTS + clientObject.load_type = load_type.name + + #Load Magnitudes + if len(components) == 6: + clientObject.components_force_x = components[0] + clientObject.components_force_y = components[1] + clientObject.components_force_z = components[2] + + clientObject.components_moment_x = components[3] + clientObject.components_moment_y = components[4] + clientObject.components_moment_z = components[5] + else: + raise Exception("WARNING: The components must contain 6 elements. Kindly check list inputs for completeness and correctness.") + + #Option Check + if force_eccentricity and shifted_display: + raise Exception("WARNING: Only one of force_eccentiricity and shifted_display could be TRUE") + + # Specific Direction + if specific_direction: + + if 'specific_direction' not in list(params.keys()): + raise Exception("Required key is missing") + + params_s = params['specific_direction'] + + clientObject.has_specific_direction = specific_direction + clientObject.specific_direction_type = params_s[0].name + + if params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_ROTATED_VIA_3_ANGLES: + clientObject.axes_sequence = params_s[1].name + clientObject.rotated_about_angle_1 = params_s[2] + clientObject.rotated_about_angle_2 = params_s[3] + clientObject.rotated_about_angle_3 = params_s[4] + clientObject.rotated_about_angle_x = params_s[5] + clientObject.rotated_about_angle_y = params_s[6] + clientObject.rotated_about_angle_z = params_s[7] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE: + clientObject.parallel_to_line = params_s[1] + + elif params_s[0] == NodalLoadSpecificDirectionType.DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER: + clientObject.parallel_to_member = params_s[1] + + #Force Eccentiricity + if force_eccentricity: + + if 'force_eccentricity' not in list(params.keys()): + raise Exception("Required key is missing") + + params_e = params['force_eccentricity'] + + clientObject.has_force_eccentricity = force_eccentricity + + clientObject.force_eccentricity_x = params_e[0] + clientObject.force_eccentricity_y = params_e[1] + clientObject.force_eccentricity_z = params_e[2] + + #Shifted Display + if shifted_display: + + if 'shifted_display' not in list(params.keys()): + raise Exception("Required key is missing") + + params_d = params['shifted_display'] + + clientObject.has_shifted_display = shifted_display + + clientObject.offset_x = params_d[0] + clientObject.offset_y = params_d[1] + clientObject.offset_z = params_d[2] + clientObject.size_or_distance = params_d[3] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if 'specific_direction' or 'force_eccentricity' or 'force_eccentricity' in params.keys(): + pass + else: + for key in params: + clientObject[key] = params[key] + + # Add Nodal Force to client model + Model.clientModel.service.set_nodal_load(load_case_no, clientObject) + + def Mass(self, + no: int = 1, + load_case_no: int = 1, + nodes_no: str = '1', + individual_mass_components : bool = False, + mass = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Load Case Number + nodes_no (str): Assigned Nodes + individual_mass_components (bool): Enable/Disable Mass Component Option + mass (list): + if individual_mass_components == False: + mass = [M] + elif individual_mass_components == True: + mass = [Mx, My, Mz, Ix, Iy, Iz] + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Nodal Force + clientObject = Model.clientModel.factory.create('ns0:nodal_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Nodal Force No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Nodes No. (e.g. '5 6 7 12') + clientObject.nodes = ConvertToDlString(nodes_no) + + # Load Type + load_type = NodalLoadType.LOAD_TYPE_MASS + clientObject.load_type = load_type.name + + # Magnitude + if individual_mass_components: + + clientObject.individual_mass_components = individual_mass_components + clientObject.mass_x = mass[0] + clientObject.mass_y = mass[1] + clientObject.mass_z = mass[2] + + clientObject.mass_moment_of_inertia_x = mass[3] + clientObject.mass_moment_of_inertia_y = mass[4] + clientObject.mass_moment_of_inertia_z = mass[5] + + else: + clientObject.individual_mass_components = individual_mass_components + + clientObject.mass_global = mass[0] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + if 'individual_mass_components' not in params.keys(): + for key in params: + clientObject[key] = params[key] + + # Add Nodal Force to client model + Model.clientModel.service.set_nodal_load(load_case_no, clientObject) diff --git a/package/RFEM/Loads/solidLoad.py b/package/RFEM/Loads/solidLoad.py new file mode 100644 index 00000000..5749247c --- /dev/null +++ b/package/RFEM/Loads/solidLoad.py @@ -0,0 +1,277 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SolidLoadType, SolidLoadDistribution, SolidLoadDirection + +class SolidLoad(): + + def __init__(self, + no: int =1, + load_case_no: int = 1, + solids_no: str= '1', + load_type = SolidLoadType.LOAD_TYPE_FORCE, + load_distribution = SolidLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = SolidLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solids = ConvertToDlString(solids_no) + + # Load Type + clientObject.load_type = load_type.name + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Magnitude + clientObject.uniform_magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_load(load_case_no, clientObject) + + def Force(self, + no: int =1, + load_case_no: int = 1, + solids_no: str= '1', + load_direction = SolidLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solids = ConvertToDlString(solids_no) + + # Load Type + clientObject.load_type = SolidLoadType.LOAD_TYPE_FORCE.name + + # Load Distribution + clientObject.load_distribution = SolidLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Magnitude + clientObject.uniform_magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_load(load_case_no, clientObject) + + def Temperature(self, + no: int = 1, + load_case_no: int = 1, + solids_no: str= '1', + load_distribution = SolidLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude + LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + params: + {''} + ''' + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solids = ConvertToDlString(solids_no) + + # Load Type + clientObject.load_type = SolidLoadType.LOAD_TYPE_TEMPERATURE.name + + # Load Distribution + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + clientObject.uniform_magnitude = load_parameter + else: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.node_1 = load_parameter[2] + clientObject.node_2 = load_parameter[3] + + clientObject.load_distribution = load_distribution.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_load(load_case_no, clientObject) + + def Strain(self, + no: int = 1, + load_case_no: int = 1, + solids_no: str= '1', + load_distribution = SolidLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + LOAD_DISTRIBUTION_UNIFORM: load_parameter = [strain_uniform_magnitude_x, strain_uniform_magnitude_y, strain_uniform_magnitude_z] + LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2] + params: + {''} + ''' + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solids = ConvertToDlString(solids_no) + + # Load Type + clientObject.load_type = SolidLoadType.LOAD_TYPE_STRAIN.name + + # Load Distribution + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + clientObject.strain_uniform_magnitude_x = load_parameter[0] + clientObject.strain_uniform_magnitude_y = load_parameter[1] + clientObject.strain_uniform_magnitude_z = load_parameter[2] + else: + clientObject.strain_magnitude_x1 = load_parameter[0] + clientObject.strain_magnitude_y1 = load_parameter[1] + clientObject.strain_magnitude_z1 = load_parameter[2] + clientObject.strain_magnitude_x2 = load_parameter[3] + clientObject.strain_magnitude_y2 = load_parameter[4] + clientObject.strain_magnitude_z2 = load_parameter[6] + clientObject.node_1 = load_parameter[6] + clientObject.node_2 = load_parameter[7] + + clientObject.load_distribution = load_distribution.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_load(load_case_no, clientObject) + + def Motion(self, + no: int = 1, + load_case_no: int = 1, + solids_no: str= '1', + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + load_parameter = [angular_velocity, angular_acceleration, axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z, axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z] + params: + {''} + ''' + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solids = ConvertToDlString(solids_no) + + # Load Type + clientObject.load_type = SolidLoadType.LOAD_TYPE_ROTARY_MOTION.name + + # Velocity + clientObject.angular_velocity = load_parameter[0] + + # Acceleration + clientObject.angular_acceleration = load_parameter[1] + + # Axis Definition + clientObject.axis_definition_p1_x = load_parameter[2] + clientObject.axis_definition_p1_y = load_parameter[3] + clientObject.axis_definition_p1_z = load_parameter[4] + clientObject.axis_definition_p2_x = load_parameter[5] + clientObject.axis_definition_p2_y = load_parameter[6] + clientObject.axis_definition_p2_z = load_parameter[7] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_load(load_case_no, clientObject) + + #def Buoyancy(): + # print('The function Buoyancy() is not implemented yet.') + + #def Gas(): + # print('The function Gas() is not implemented yet.') diff --git a/package/RFEM/Loads/solidSetLoad.py b/package/RFEM/Loads/solidSetLoad.py new file mode 100644 index 00000000..90faa5d3 --- /dev/null +++ b/package/RFEM/Loads/solidSetLoad.py @@ -0,0 +1,278 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SolidSetLoadType, SolidSetLoadDistribution, SolidSetLoadDirection + +class SolidSetLoad(): + + def __init__(self, + no: int =1, + load_case_no: int = 1, + solid_sets_no: str= '1', + load_type = SolidSetLoadType.LOAD_TYPE_FORCE, + load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_direction = SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_set_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solid_sets = ConvertToDlString(solid_sets_no) + + # Load Type + clientObject.load_type = load_type.name + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Magnitude + clientObject.uniform_magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_set_load(load_case_no, clientObject) + + + def Force(self, + no: int =1, + load_case_no: int = 1, + solid_sets_no: str= '1', + load_direction = SolidSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, + magnitude: float = 0, + comment: str = '', + params: dict = {}): + + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_set_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solid_sets = ConvertToDlString(solid_sets_no) + + # Load Type + clientObject.load_type = SolidSetLoadType.LOAD_TYPE_FORCE.name + + # Load Distribution + clientObject.load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Magnitude + clientObject.uniform_magnitude = magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_set_load(load_case_no, clientObject) + + def Temperature(self, + no: int = 1, + load_case_no: int = 1, + solid_sets_no: str= '1', + load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + LOAD_DISTRIBUTION_UNIFORM: load_parameter = magnitude + LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + params: + {''} + ''' + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_set_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solid_sets = ConvertToDlString(solid_sets_no) + + # Load Type + clientObject.load_type = SolidSetLoadType.LOAD_TYPE_TEMPERATURE.name + + # Load Distribution + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + clientObject.uniform_magnitude = load_parameter + else: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.node_1 = load_parameter[2] + clientObject.node_2 = load_parameter[3] + + clientObject.load_distribution = load_distribution.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_set_load(load_case_no, clientObject) + + def Strain(self, + no: int = 1, + load_case_no: int = 1, + solid_sets_no: str= '1', + load_distribution = SolidSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + LOAD_DISTRIBUTION_UNIFORM: load_parameter = [strain_uniform_magnitude_x, strain_uniform_magnitude_y, strain_uniform_magnitude_z] + LOAD_DISTRIBUTION_LINEAR_IN_X: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Y: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2] + LOAD_DISTRIBUTION_LINEAR_IN_Z: load_parameter = [strain_magnitude_x1, strain_magnitude_y1, strain_magnitude_z1, strain_magnitude_x2, strain_magnitude_y2, strain_magnitude_z2, node_1, node_2] + params: + {''} + ''' + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_set_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solid_sets = ConvertToDlString(solid_sets_no) + + # Load Type + clientObject.load_type = SolidSetLoadType.LOAD_TYPE_STRAIN.name + + # Load Distribution + if load_distribution.name == "LOAD_DISTRIBUTION_UNIFORM": + clientObject.strain_uniform_magnitude_x = load_parameter[0] + clientObject.strain_uniform_magnitude_y = load_parameter[1] + clientObject.strain_uniform_magnitude_z = load_parameter[2] + else: + clientObject.strain_magnitude_x1 = load_parameter[0] + clientObject.strain_magnitude_y1 = load_parameter[1] + clientObject.strain_magnitude_z1 = load_parameter[2] + clientObject.strain_magnitude_x2 = load_parameter[3] + clientObject.strain_magnitude_y2 = load_parameter[4] + clientObject.strain_magnitude_z2 = load_parameter[5] + clientObject.node_1 = load_parameter[6] + clientObject.node_2 = load_parameter[7] + + clientObject.load_distribution = load_distribution.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_set_load(load_case_no, clientObject) + + def Motion(self, + no: int = 1, + load_case_no: int = 1, + solid_sets_no: str= '1', + load_parameter = None, + comment: str = '', + params: dict = {}): + ''' + load_parameter: + load_parameter = [angular_velocity, angular_acceleration, axis_definition_p1_x, axis_definition_p1_y, axis_definition_p1_z, axis_definition_p2_x, axis_definition_p2_y, axis_definition_p2_z] + params: + {''} + ''' + # Client model | Solid Load + clientObject = Model.clientModel.factory.create('ns0:solid_set_load') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Load No. + clientObject.no = no + + # Load Case No. + clientObject.load_case = load_case_no + + # Assigned Solid No. + clientObject.solid_sets = ConvertToDlString(solid_sets_no) + + # Load Type + clientObject.load_type = SolidSetLoadType.LOAD_TYPE_ROTARY_MOTION.name + + # Velocity + clientObject.angular_velocity = load_parameter[0] + + # Acceleration + clientObject.angular_acceleration = load_parameter[1] + + # Axis Definition + clientObject.axis_definition_p1_x = load_parameter[2] + clientObject.axis_definition_p1_y = load_parameter[3] + clientObject.axis_definition_p1_z = load_parameter[4] + clientObject.axis_definition_p2_x = load_parameter[5] + clientObject.axis_definition_p2_y = load_parameter[6] + clientObject.axis_definition_p2_z = load_parameter[7] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Load to client model + Model.clientModel.service.set_solid_set_load(load_case_no, clientObject) + + #def Buoyancy(): + # print('The function Buoyancy() is not implemented yet.') + + #def Gas(): + # print('The function Gas() is not implemented yet.') diff --git a/package/RFEM/Loads/surfaceLoad.py b/package/RFEM/Loads/surfaceLoad.py new file mode 100644 index 00000000..756c5010 --- /dev/null +++ b/package/RFEM/Loads/surfaceLoad.py @@ -0,0 +1,567 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SurfaceLoadType, SurfaceLoadDirection, SurfaceLoadDistribution, SurfaceLoadAxisDefinitionType + +class SurfaceLoad(): + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + magnitude: float = 1.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigend Surfaces + magnitude (float): Load Magnitude + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_FORCE.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Direction + clientObject.load_direction = SurfaceLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + # Load Magnitude + clientObject.uniform_magnitude = magnitude + + # Load Distribution + clientObject.load_distribution = SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) + + def Force(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + load_direction = SurfaceLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, + load_distribution = SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigned Surfaces + load_direction (enum): Load Direction Enumeration + load_distribution (enum): Load Distribution Enumeration + load_parameter (list): + + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [magnitude_1, magnitude_2, magnitude_3, node_1, node_2, node_3] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_X: + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Y: + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Z: + load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + if SurfaceLoadAxisDefinitionType == AXIS_DEFINITION_TWO_POINTS: + load_parameter = [magnitude_1, magnitude_2, node_1, node_2, SurfaceLoadAxisDefinitionType, axis_definition_p1, axis_definition_p2] + if SurfaceLoadAxisDefinitionType == AXIS_DEFINITION_POINT_AND_AXIS: + load_parameter = [magnitude_1, magnitude_2, node_1, node_2, SurfaceLoadAxisDefinitionType, SurfaceLoadAxisDefinitionAxis, axis_definition_p1] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: + load_parameter = [[distance_1, delta_distance_1, magnitude_1], [distance_2, delta_distance_2, magnitude_2]...] + + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_FORCE.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude + if load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.uniform_magnitude = load_parameter[0] + + elif load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + clientObject.node_1 = load_parameter[3] + clientObject.node_2 = load_parameter[4] + clientObject.node_3 = load_parameter[5] + + elif load_distribution in (SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y, \ + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Z): + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.node_1 = load_parameter[2] + clientObject.node_2 = load_parameter[3] + + elif load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.node_1 = load_parameter[2] + clientObject.node_2 = load_parameter[3] + + clientObject.axis_definition_type = load_parameter[4].name + if load_parameter[4] == SurfaceLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + clientObject.axis_definition_p1_x = load_parameter[5][0] + clientObject.axis_definition_p1_y = load_parameter[5][1] + clientObject.axis_definition_p1_z = load_parameter[5][2] + clientObject.axis_definition_p2_x = load_parameter[6][0] + clientObject.axis_definition_p2_y = load_parameter[6][1] + clientObject.axis_definition_p2_z = load_parameter[6][2] + + else: + clientObject.axis_definition_axis = load_parameter[5].name + clientObject.axis_definition_p1_x = load_parameter[6][0] + clientObject.axis_definition_p1_y = load_parameter[6][1] + clientObject.axis_definition_p1_z = load_parameter[6][2] + + elif load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:surface_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:surface_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + clientObject.varying_load_parameters.surface_load_varying_load_parameters.append(mlvlp) + clientObject.varying_load_parameters_sorted = True + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) + + def Temperature(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + load_distribution = SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigned Surfaces + load_distribution (enum): Load Distribution Enumeration + load_parameter (list): + + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [t_c, delta_t] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, t_c_3, delta_t_3, node_1, node_2, node_3] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_X: + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Y: + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Z: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, node_1, node_2] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + if SurfaceLoadAxisDefinitionType == AXIS_DEFINITION_TWO_POINTS: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, node_1, node_2, SurfaceLoadAxisDefinitionType, axis_definition_p1, axis_definition_p2] + if SurfaceLoadAxisDefinitionType == AXIS_DEFINITION_POINT_AND_AXIS: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, node_1, node_2, SurfaceLoadAxisDefinitionType, SurfaceLoadAxisDefinitionAxis, axis_definition_p1] + + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_TEMPERATURE.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude + if load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.uniform_magnitude_t_c = load_parameter[0] + clientObject.uniform_magnitude_delta_t = load_parameter[1] + + elif load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + clientObject.magnitude_t_c_1 = load_parameter[0] + clientObject.magnitude_delta_t_1 = load_parameter[1] + clientObject.magnitude_t_c_2 = load_parameter[2] + clientObject.magnitude_delta_t_2 = load_parameter[3] + clientObject.magnitude_t_c_3 = load_parameter[4] + clientObject.magnitude_delta_t_3 = load_parameter[5] + + clientObject.node_1 = load_parameter[6] + clientObject.node_2 = load_parameter[7] + clientObject.node_3 = load_parameter[8] + + elif load_distribution in (SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y,\ + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Z): + clientObject.magnitude_t_c_1 = load_parameter[0] + clientObject.magnitude_delta_t_1 = load_parameter[1] + clientObject.magnitude_t_c_2 = load_parameter[2] + clientObject.magnitude_delta_t_2 = load_parameter[3] + + clientObject.node_1 = load_parameter[4] + clientObject.node_2 = load_parameter[5] + + elif load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + clientObject.magnitude_t_c_1 = load_parameter[0] + clientObject.magnitude_delta_t_1 = load_parameter[1] + + clientObject.magnitude_t_c_2 = load_parameter[2] + clientObject.magnitude_delta_t_2 = load_parameter[3] + + clientObject.node_1 = load_parameter[4] + clientObject.node_2 = load_parameter[5] + + clientObject.axis_definition_type = load_parameter[6].name + if load_parameter[6] == SurfaceLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + clientObject.axis_definition_p1_x = load_parameter[7] + clientObject.axis_definition_p1_y = load_parameter[8] + clientObject.axis_definition_p1_z = load_parameter[9] + + else: + clientObject.axis_definition_axis = load_parameter[7] + clientObject.axis_definition_p1 = load_parameter[8] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) + + def AxialStrain(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + load_distribution = SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigned Surfaces + load_distribution (enum):Load Distribution Enumeration + load_parameter (list): + + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [axial_strain_x, axial_strain_y] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [magnitude_axial_strain_1x, magnitude_axial_strain_1y, magnitude_axial_strain_2x, magnitude_axial_strain_2y, magnitude_axial_strain_3x, magnitude_axial_strain_3y, node_1, node_2, node_3] + for load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_X: + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Y: + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Z: + load_parameter = [magnitude_axial_strain_1x, magnitude_axial_strain_1y, magnitude_axial_strain_2x, magnitude_axial_strain_2y, node_1, node_2] + + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_AXIAL_STRAIN.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude + if load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude_axial_strain_x = load_parameter[0] + clientObject.magnitude_axial_strain_y = load_parameter[1] + + elif load_distribution == SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + clientObject.magnitude_axial_strain_1x = load_parameter[0] + clientObject.magnitude_axial_strain_1y = load_parameter[1] + clientObject.magnitude_axial_strain_2x = load_parameter[2] + clientObject.magnitude_axial_strain_2y = load_parameter[3] + clientObject.magnitude_axial_strain_3x = load_parameter[4] + clientObject.magnitude_axial_strain_3y = load_parameter[5] + + clientObject.node_1 = load_parameter[6] + clientObject.node_2 = load_parameter[7] + clientObject.node_3 = load_parameter[8] + + elif load_distribution in (SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y,\ + SurfaceLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Z): + clientObject.magnitude_axial_strain_1x = load_parameter[0] + clientObject.magnitude_axial_strain_1y = load_parameter[1] + clientObject.magnitude_axial_strain_2x = load_parameter[2] + clientObject.magnitude_axial_strain_2y = load_parameter[3] + + clientObject.node_1 = load_parameter[4] + clientObject.node_2 = load_parameter[5] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) + + def Precamber(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + uniform_magnitude : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigned Surfaces + uniform_magnitude (float): Magnitude + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_PRECAMBER.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Distribution + clientObject.load_distribution = SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + #Load Direction + clientObject.load_direction = SurfaceLoadDirection.LOAD_DIRECTION_LOCAL_Z.name + + # Load Magnitude + clientObject.uniform_magnitude = uniform_magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) + + def RotaryMotion(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigned Surfaces + load_parameter (list): + + for axis_definition_type = SurfaceLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + load_parameter = [angular_velocity, angular_acceleration, SurfaceLoadAxisDefinitionType, [x1, y1, z1], [x2, y2, z2]] + for axis_definition_type = SurfaceLoadAxisDefinitionType.AXIS_DEFINITION_POINT_AND_AXIS: + load_parameter = [angular_velocity, angular_acceleration, SurfaceLoadAxisDefinitionType, SurfaceLoadAxisDefinitionAxis, SurfaceLoadAxisDirectionType; [x1, y1, z1]] + + comment (str, optional): Comments + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_ROTARY_MOTION.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Magnitude + clientObject.angular_acceleration = load_parameter[0] + clientObject.angular_velocity = load_parameter[1] + clientObject.axis_definition_type = load_parameter[2].name + + if load_parameter[2] == SurfaceLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + clientObject.axis_definition_p1_x = load_parameter[3][0] + clientObject.axis_definition_p1_y = load_parameter[3][1] + clientObject.axis_definition_p1_z = load_parameter[3][2] + + clientObject.axis_definition_p1_x = load_parameter[4][0] + clientObject.axis_definition_p1_y = load_parameter[4][1] + clientObject.axis_definition_p1_z = load_parameter[4][2] + + else: + clientObject.axis_definition_axis = load_parameter[3].name + clientObject.axis_definition_axis_orientation = load_parameter[4].name + clientObject.axis_definition_p1_x = load_parameter[5][0] + clientObject.axis_definition_p1_y = load_parameter[5][1] + clientObject.axis_definition_p1_z = load_parameter[5][2] + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) + + def Mass(self, + no: int = 1, + load_case_no: int = 1, + surface_no: str = '1', + individual_mass_components : bool = False, + mass_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_no (str): Assigned Surfaces + individual_mass_components (bool): Enable/Disable Individual Mass Components Option + mass_parameter (list): + + if individual_mass_components == True: + mass_parameter = [mass_global] + elif individual_mass_components == False: + mass_parameter = [mass_x, mass_y, mass_z] + + comment (str, optional): + params (dict, optional): + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceLoadType.LOAD_TYPE_MASS.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surfaces = ConvertToDlString(surface_no) + + # Load Distribution + clientObject.load_distribution = SurfaceLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + #Load Direction + clientObject.load_direction = SurfaceLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + #Individual Mass Components + clientObject.individual_mass_components = individual_mass_components + + # Load Magnitude + if individual_mass_components: + clientObject.magnitude_mass_x = mass_parameter[0] + clientObject.magnitude_mass_y = mass_parameter[1] + clientObject.magnitude_mass_z = mass_parameter[2] + else: + clientObject.magnitude_mass_global = mass_parameter[0] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_load(load_case_no, clientObject) diff --git a/package/RFEM/Loads/surfacesetload.py b/package/RFEM/Loads/surfacesetload.py new file mode 100644 index 00000000..d58b2d2c --- /dev/null +++ b/package/RFEM/Loads/surfacesetload.py @@ -0,0 +1,561 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SurfaceSetLoadType, SurfaceSetLoadDirection, SurfaceSetLoadDistribution, SurfaceSetLoadAxisDefinitionType + +class SurfaceSetLoad(): + + def __init__(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + magnitude: float = 1.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + magnitude (float): Load Magnitude + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_FORCE.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + # Load Direction + clientObject.load_direction = SurfaceSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE.name + + # Load Magnitude + clientObject.uniform_magnitude = magnitude + + # Load Distribution + clientObject.load_distribution = SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) + + def Force(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + load_direction = SurfaceSetLoadDirection.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, + load_distribution = SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + load_direction (enum): Load Direction Enumeration + load_distribution (enum): Load Distribution Enumeration + load_parameter (list): Load Parameters + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [magnitude] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [magnitude_1, magnitude_2, magnitude_3, node_1, node_2, node_3] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_X: + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Y: + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Z: + load_parameter = [magnitude_1, magnitude_2, node_1, node_2] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + if SurfaceSetLoadAxisDefinitionType == AXIS_DEFINITION_TWO_POINTS: + load_parameter = [magnitude_1, magnitude_2, node_1, node_2, SurfaceLoadAxisDefinitionType, axis_definition_p1, axis_definition_p2] + if SurfaceSetLoadAxisDefinitionType == AXIS_DEFINITION_POINT_AND_AXIS: + load_parameter = [magnitude_1, magnitude_2, node_1, node_2, SurfaceLoadAxisDefinitionType, SurfaceLoadAxisDefinitionAxis, axis_definition_p1] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: + load_parameter = [[distance_1, delta_distance_1, magnitude_1], [distance_2, delta_distance_2, magnitude_2]...] + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_FORCE.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + # Load Direction + clientObject.load_direction = load_direction.name + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude + if load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.uniform_magnitude = load_parameter[0] + + elif load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + clientObject.magnitude_3 = load_parameter[2] + + clientObject.node_1 = load_parameter[3] + clientObject.node_2 = load_parameter[4] + clientObject.node_3 = load_parameter[5] + + elif load_distribution in (SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y, + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Z): + + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.node_1 = load_parameter[2] + clientObject.node_2 = load_parameter[3] + + elif load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + clientObject.magnitude_1 = load_parameter[0] + clientObject.magnitude_2 = load_parameter[1] + + clientObject.node_1 = load_parameter[2] + clientObject.node_2 = load_parameter[3] + + clientObject.axis_definition_type = load_parameter[4].name + if load_parameter[4] == SurfaceSetLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + clientObject.axis_definition_p1_x = load_parameter[5][0] + clientObject.axis_definition_p1_y = load_parameter[5][1] + clientObject.axis_definition_p1_z = load_parameter[5][2] + clientObject.axis_definition_p2_x = load_parameter[6][0] + clientObject.axis_definition_p2_y = load_parameter[6][1] + clientObject.axis_definition_p2_z = load_parameter[6][2] + + else: + clientObject.axis_definition_axis = load_parameter[5].name + clientObject.axis_definition_p1_x = load_parameter[6][0] + clientObject.axis_definition_p1_y = load_parameter[6][1] + clientObject.axis_definition_p1_z = load_parameter[6][2] + + elif load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_VARYING_IN_Z: + + clientObject.varying_load_parameters = Model.clientModel.factory.create('ns0:surface_set_load.varying_load_parameters') + for i,j in enumerate(load_parameter): + mlvlp = Model.clientModel.factory.create('ns0:surface_set_load_varying_load_parameters') + mlvlp.no = i+1 + mlvlp.distance = load_parameter[i][0] + mlvlp.delta_distance = load_parameter[i][1] + mlvlp.magnitude = load_parameter[i][2] + mlvlp.note = None + clientObject.varying_load_parameters.surface_set_load_varying_load_parameters.append(mlvlp) + clientObject.varying_load_parameters_sorted = True + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) + + def Temperature(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + load_distribution = SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = None, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + load_distribution (enum): Load Distribution Enumeration + load_parameter (enum): Load Parameter Enumeration + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [t_c, delta_t] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, t_c_3, delta_t_3, node_1, node_2, node_3] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_X: + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Y: + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Z: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, node_1, node_2] + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + if SurfaceSetLoadAxisDefinitionType == AXIS_DEFINITION_TWO_POINTS: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, node_1, node_2, SurfaceLoadAxisDefinitionType, axis_definition_p1, axis_definition_p2] + if SurfaceSetLoadAxisDefinitionType == AXIS_DEFINITION_POINT_AND_AXIS: + load_parameter = [t_c_1, delta_t_1, t_c_2, delta_t_2, node_1, node_2, SurfaceLoadAxisDefinitionType, SurfaceLoadAxisDefinitionAxis, axis_definition_p1] + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_TEMPERATURE.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude + if load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.uniform_magnitude_t_c = load_parameter[0] + clientObject.uniform_magnitude_delta_t = load_parameter[1] + + elif load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + clientObject.magnitude_t_c_1 = load_parameter[0] + clientObject.magnitude_delta_t_1 = load_parameter[1] + clientObject.magnitude_t_c_2 = load_parameter[2] + clientObject.magnitude_delta_t_2 = load_parameter[3] + clientObject.magnitude_t_c_3 = load_parameter[4] + clientObject.magnitude_delta_t_3 = load_parameter[5] + + clientObject.node_1 = load_parameter[6] + clientObject.node_2 = load_parameter[7] + clientObject.node_3 = load_parameter[8] + + elif load_distribution in (SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y, + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Z): + clientObject.magnitude_t_c_1 = load_parameter[0] + clientObject.magnitude_delta_t_1 = load_parameter[1] + clientObject.magnitude_t_c_2 = load_parameter[2] + clientObject.magnitude_delta_t_2 = load_parameter[3] + + clientObject.node_1 = load_parameter[4] + clientObject.node_2 = load_parameter[5] + + elif load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_RADIAL: + clientObject.magnitude_t_c_1 = load_parameter[0] + clientObject.magnitude_delta_t_1 = load_parameter[1] + + clientObject.magnitude_t_c_2 = load_parameter[2] + clientObject.magnitude_delta_t_2 = load_parameter[3] + + clientObject.node_1 = load_parameter[4] + clientObject.node_2 = load_parameter[5] + + clientObject.axis_definition_type = load_parameter[6].name + if load_parameter[6] == SurfaceSetLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + clientObject.axis_definition_p1_x = load_parameter[7] + clientObject.axis_definition_p1_y = load_parameter[8] + clientObject.axis_definition_p1_z = load_parameter[9] + + else: + clientObject.axis_definition_axis = load_parameter[7] + clientObject.axis_definition_p1 = load_parameter[8] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) + + def AxialStrain(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + load_distribution = SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM, + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + load_distribution (enum): Load Distribution Enumeration + load_parameter (list): Load Parameter + comment (str, optional): Comment + params (dict, optional): Parameters + + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + load_parameter = [axial_strain_x, axial_strain_y] + + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + load_parameter = [magnitude_axial_strain_1x, magnitude_axial_strain_1y, magnitude_axial_strain_2x, magnitude_axial_strain_2y, magnitude_axial_strain_3x, magnitude_axial_strain_3y, node_1, node_2, node_3] + + for load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_X: + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Y: + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_Z: + load_parameter = [magnitude_axial_strain_1x, magnitude_axial_strain_1y, magnitude_axial_strain_2x, magnitude_axial_strain_2y, node_1, node_2] + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_AXIAL_STRAIN.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + # Load Distribution + clientObject.load_distribution = load_distribution.name + + # Load Magnitude + if load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM: + clientObject.magnitude_axial_strain_x = load_parameter[0] + clientObject.magnitude_axial_strain_y = load_parameter[1] + + elif load_distribution == SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR: + clientObject.magnitude_axial_strain_1x = load_parameter[0] + clientObject.magnitude_axial_strain_1y = load_parameter[1] + clientObject.magnitude_axial_strain_2x = load_parameter[2] + clientObject.magnitude_axial_strain_2y = load_parameter[3] + clientObject.magnitude_axial_strain_3x = load_parameter[4] + clientObject.magnitude_axial_strain_3y = load_parameter[5] + + clientObject.node_1 = load_parameter[6] + clientObject.node_2 = load_parameter[7] + clientObject.node_3 = load_parameter[8] + + elif load_distribution in (SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_X, + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Y, + SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_LINEAR_IN_Z): + clientObject.magnitude_axial_strain_1x = load_parameter[0] + clientObject.magnitude_axial_strain_1y = load_parameter[1] + clientObject.magnitude_axial_strain_2x = load_parameter[2] + clientObject.magnitude_axial_strain_2y = load_parameter[3] + + clientObject.node_1 = load_parameter[4] + clientObject.node_2 = load_parameter[5] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) + + def Precamber(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + uniform_magnitude : float = 0.0, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + uniform_magnitude (float): Load Magnitude + comment (str, optional): Comment + params (dict, optional): Parameters + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_PRECAMBER.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + # Load Distribution + clientObject.load_distribution = SurfaceSetLoadDistribution.LOAD_DISTRIBUTION_UNIFORM.name + + #Load Direction + clientObject.load_direction = SurfaceSetLoadDirection.LOAD_DIRECTION_LOCAL_Z.name + + # Load Magnitude + clientObject.uniform_magnitude = uniform_magnitude + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) + + def RotaryMotion(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + load_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + load_parameter (list): Load Parameters + comment (str, optional): Comment + params (dict, optional): Parameters + + for axis_definition_type = SurfaceSetLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + load_parameter = [angular_velocity, angular_acceleration, SurfaceLoadAxisDefinitionType, [x1, y1, z1], [x2, y2, z2]] + for axis_definition_type = SurfaceSetLoadAxisDefinitionType.AXIS_DEFINITION_POINT_AND_AXIS: + load_parameter = [angular_velocity, angular_acceleration, SurfaceLoadAxisDefinitionType, SurfaceLoadAxisDefinitionAxis, SurfaceLoadAxisDirectionType; [x1, y1, z1]] + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_ROTARY_MOTION.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + # Load Magnitude + clientObject.angular_acceleration = load_parameter[0] + clientObject.angular_velocity = load_parameter[1] + clientObject.axis_definition_type = load_parameter[2].name + + if load_parameter[2] == SurfaceSetLoadAxisDefinitionType.AXIS_DEFINITION_TWO_POINTS: + clientObject.axis_definition_p1_x = load_parameter[3][0] + clientObject.axis_definition_p1_y = load_parameter[3][1] + clientObject.axis_definition_p1_z = load_parameter[3][2] + + clientObject.axis_definition_p1_x = load_parameter[4][0] + clientObject.axis_definition_p1_y = load_parameter[4][1] + clientObject.axis_definition_p1_z = load_parameter[4][2] + + else: + clientObject.axis_definition_axis = load_parameter[3].name + clientObject.axis_definition_axis_orientation = load_parameter[4].name + clientObject.axis_definition_p1_x = load_parameter[5][0] + clientObject.axis_definition_p1_y = load_parameter[5][1] + clientObject.axis_definition_p1_z = load_parameter[5][2] + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) + + def Mass(self, + no: int = 1, + load_case_no: int = 1, + surface_sets: str = '1', + individual_mass_components : bool = False, + mass_parameter = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Load Tag + load_case_no (int): Assigned Load Case + surface_sets (str): Assigned Surface Sets + individual_mass_components (bool): Individiual Mass Components Option + mass_parameter (list): Mass Parameters + comment (str, optional): Comment + params (dict, optional): Parameters + + for individual_mass_components == True: + mass_parameter = [mass_global] + for individual_mass_components == False: + mass_parameter = [mass_x, mass_y, mass_z] + """ + # Client model | Surface Load + clientObject = Model.clientModel.factory.create('ns0:surface_set_load') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Load No. + clientObject.no = no + + # Load Type + clientObject.load_type = SurfaceSetLoadType.LOAD_TYPE_MASS.name + # Load Case No. + clientObject.load_case = load_case_no + + # Surfaces No. (e.g. '5 6 7 12') + clientObject.surface_sets = ConvertToDlString(surface_sets) + + #Individual Mass Components + clientObject.individual_mass_components = individual_mass_components + + # Load Magnitude + if individual_mass_components: + clientObject.magnitude_mass_x = mass_parameter[0] + clientObject.magnitude_mass_y = mass_parameter[1] + clientObject.magnitude_mass_z = mass_parameter[2] + else: + clientObject.magnitude_mass_global = mass_parameter[0] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Load to client model + Model.clientModel.service.set_surface_set_load(load_case_no, clientObject) diff --git a/package/RFEM/Reports/favicon32.png b/package/RFEM/Reports/favicon32.png new file mode 100644 index 00000000..0e560f7a Binary files /dev/null and b/package/RFEM/Reports/favicon32.png differ diff --git a/package/RFEM/Reports/html.py b/package/RFEM/Reports/html.py new file mode 100644 index 00000000..f0ce9bc9 --- /dev/null +++ b/package/RFEM/Reports/html.py @@ -0,0 +1,260 @@ +################################# +## DEFINITION: +## This feature allows the user to create an output HTML file with the results. +## The results are in the same form as result tables in RFEM. +## The output file is written in HTML and consists of embedded tabular data. +## It will also include dropdown menu with all tables/files. +## Result files are language dependent, so parsing based on strings is impossible. +################################# + +from os import listdir, walk, path, getcwd, system +from RFEM.initModel import ExportResultTablesToCsv +from re import findall, match +from shutil import copy + +columns = 0 + +def __HTMLheadAndHeader(modelName, fileNames): + output = ['', + '', + '', + 'Results', + '', + '', + '
', + '', + '
', + 'Dlubal logo', + '

Result report

', + f'

Model: {modelName}

', + '
', + '
', + '', + ''] + for f in fileNames: + output.append(f'') + output += ['', + '', + '', + '
', + '
', + '', + '
'] + for f in fileNames: + output.append(f'') + return output + +def __HTMLfooter(): + return ['', + '
'] + +def __isEmpty(dividedLine): + # returns True if all strings are empty + return not any (dividedLine) + +def __numberOfPOsitiveItems(dividedLine): + # return number of list items which are not empty + counter = 0 + for i in dividedLine: + if i: + counter += 1 + + return counter + +def __isWords(word): + isWords = False + dividedWords = word.split(' ') + + for oneWord in dividedWords: + if oneWord and bool(match(r"[A-Z]", oneWord[0])) and oneWord.isalpha(): + isWords = True + else: + break + + return isWords + +def __tableHeader(dividedLine_1, dividedLine_2): + # define htnl of header lines, rowspan and colspan + # parameters are lists of strings + global columns + columns = max(len(dividedLine_1), len(dividedLine_2)) + output = ['
', + '', + '', + '', + ''] + if __isEmpty(dividedLine_1): + __emptyLine() + else: + for i in range(columns): + if dividedLine_1[i] and not dividedLine_2[i]: + output.append(f'') + elif not dividedLine_1[i] and not dividedLine_2[i]: + output.append('') + elif dividedLine_1[i] and dividedLine_2[i]: + colspan = 1 + for ii in range(i+1, columns): + if ii == columns-1 and not dividedLine_1[ii] and __isWords(dividedLine_2[ii]): + break + if not dividedLine_1[ii] and dividedLine_2[ii]: + colspan += 1 + else: + break + output.append(f'') + i += colspan-1 + elif i==columns-1 and not dividedLine_1[i] and dividedLine_2[i]: + output.append('') + output += ['', ''] + + for y in range(columns): + if not dividedLine_1[y] and not dividedLine_2[y]: + output.append('') + elif dividedLine_1[y] and not dividedLine_2[y]: + pass + else: + output.append(f'') + + output += ['', ''] + return output + +def __tableSubHeader(dividedLine): + # sub header; one liner; in the body of table + return f'' + +def __emptyLine(): + # define html of empty lines + return f'' + +def __otherLines(dividedLine): + # define html of other lines + colspan = 1 + output = [] + for c in range(columns): + if colspan == 1: + sCheckIfDigit = dividedLine[c].replace('.','',1) + sCheckIfDigit = sCheckIfDigit.replace(',','',1) + sCheckIfDigit = sCheckIfDigit.replace('-','',1) + sCheckIfDigit = sCheckIfDigit.replace('+','',1) + align = 'left' + tag = 'td' + if c == 0: + align = 'center' + elif sCheckIfDigit.isdigit(): + align = 'right' + elif bool(match(r"^\D+\.$", dividedLine[c])) or "|" in dividedLine[c]: + for cc in range(c+1, columns-1): + if not dividedLine[cc]: + colspan += 1 + else: + break + else: + if '' in dividedLine[c] or '[' in dividedLine[c]: + tag = 'th' + align = 'center' + output.append(f'<{tag} colspan="{colspan}"align="{align}">{dividedLine[c]}') + else: + colspan -= 1 + return output + +def __writeToFile(TargetFilePath, output): + # Write into html file + with open(TargetFilePath, "w", encoding="utf-8") as f: + for line in output: + while '_' in line: + beginId = line.find('_') + endBySpace = line[beginId:].find(' ') + endByArrow = line.rfind('<') + if endBySpace == -1: + line = line[:beginId]+''+line[beginId+1:endByArrow]+''+line[endByArrow:] + else: + endId = min(endBySpace + beginId, endByArrow) + line = line[:beginId]+''+line[beginId+1:endId]+''+line[endId:] + while '^' in line: + beginId = line.find('^') + endBySpace = line[beginId:].find(' ') + endByArrow = line.rfind('<') + if endBySpace == -1: + line = line[:beginId]+''+line[beginId+1:endByArrow]+''+line[endByArrow:] + else: + endId = min(endBySpace + beginId, endByArrow) + line = line[:beginId]+''+line[beginId+1:endId]+''+line[endId:] + f.write(line+'\n') + +def ExportResultTablesToHtml(TargetFolderPath: str): + # Create collection of source files + ExportResultTablesToCsv(TargetFolderPath) + + modelName = next(walk(TargetFolderPath))[1][0] + dirList = listdir(path.join(TargetFolderPath, modelName)) + # Parse CSV file names into LC and CO, analysis type, types of object (nodes, lines, members, surfaces), + # and tabs (such as summary, Global Deformations, or Support Forces) + + fileNames = [] + + dirList.sort() + + print('') + + for fileName in dirList: + cats = fileName[:-4].split('_') + + fileNameCapitalized = '' + for c in cats: + if findall('[0-9]+', c): + fileNameCapitalized += c+' ' + else: + fileNameCapitalized += c.capitalize()+' ' + fileNameCapitalized = fileNameCapitalized[:-1] + fileNames.append(fileNameCapitalized) + + with open(path.join(TargetFolderPath, modelName, fileName), mode='r', encoding='utf-8-sig') as f: + lines = f.readlines() + # 1st header always consists of first 2 lines + line_1 = lines[0].split(';') + line_1[-1] = line_1[-1].rstrip('\n') + line_2 = lines[1].split(';') + line_2[-1] = line_2[-1].rstrip('\n') + + output = __tableHeader(line_1, line_2) + output.append('') + + for line in lines[2:]: + output.append('') + dividedLine = line.split(';') + dividedLine[-1] = dividedLine[-1].rstrip('\n') + + # check if number of columns is always same + #assert columns-len(dividedLine) == 0 + + if __isEmpty(dividedLine): + # if empty line + output.append(__emptyLine()) + elif __numberOfPOsitiveItems(dividedLine) == 1 and dividedLine[0]: + # add empty line, these values doesn't make sence + output.append(__emptyLine()) + elif __numberOfPOsitiveItems(dividedLine) == 1 and dividedLine[1]: + # if only one string in the list, it is sub header consisting of only 1 line + output.append(__tableSubHeader(dividedLine[1])) + else: + output += __otherLines(dividedLine) + + output += ['', '', '
{dividedLine_1[i]}{dividedLine_1[i]}
{dividedLine_2[y]}
{dividedLine}
', '
'] + + __writeToFile(path.join(TargetFolderPath, fileNameCapitalized+'.html'), output) + + indexOutput = ['
'] + indexOutput += __HTMLfooter() + indexOutput = __HTMLheadAndHeader(modelName, fileNames) + indexOutput + + # Copy basic files + dirname = path.join(getcwd(), path.dirname(__file__)) + copy(path.join(dirname, 'htmlStyles.css'), TargetFolderPath) + copy(path.join(dirname, 'htmlScript.js'), TargetFolderPath) + copy(path.join(dirname, 'favicon32.png'), TargetFolderPath) + + with open(path.join(TargetFolderPath,'index.html'), "w", encoding="utf-8") as f: + for line in indexOutput: + f.write(line+'\n') + + # Open result html page + system(f"start {path.join(TargetFolderPath, 'index.html')}") \ No newline at end of file diff --git a/package/RFEM/Reports/htmlScript.js b/package/RFEM/Reports/htmlScript.js new file mode 100644 index 00000000..0f1e3d75 --- /dev/null +++ b/package/RFEM/Reports/htmlScript.js @@ -0,0 +1,53 @@ +function showPanel(){ + var framePanels = document.getElementsByTagName("iframe"); + var datalist = document.getElementById('filter'); + var searchField = document.getElementById('fl'); + var searchFieldTableName = searchField.value; + for (let i = 0; i < datalist.options.length; i++) { + if (searchFieldTableName == datalist.options[i].label){ + framePanels[i].style.display="block"; + } + else{ + framePanels[i].style.display="none"; + } + } + searchField.blur(); +}; +function switchButtonDown(){ + var datalist = document.getElementById('filter'); + var searchField = document.getElementById('fl'); + var searchFieldTableName = searchField.value; + var index = 0; + for (let i = 0; i < datalist.options.length; i++) { + if (searchFieldTableName == datalist.options[i].label){ + index = i; + break; + } + } + index = index - 1; + index = Math.max(0, index); + searchField.value = datalist.options[index].label; + showPanel(); +}; +function switchButtonUp(){ + var datalist = document.getElementById('filter'); + var searchField = document.getElementById('fl'); + var searchFieldTableName = searchField.value; + var index = 0; + for (let i = 0; i < datalist.options.length; i++) { + if (searchFieldTableName == datalist.options[i].label){ + index = i; + break; + } + } + index = index + 1 + index = Math.min(datalist.options.length-1, index); + searchField.value = datalist.options[index].label; + showPanel(); +}; +function atTheEnd(){ + var datalist = document.getElementById('filter'); + var searchField = document.getElementById('fl'); + searchField.value = datalist.options[0].label; + showPanel(); +}; diff --git a/package/RFEM/Reports/htmlStyles.css b/package/RFEM/Reports/htmlStyles.css new file mode 100644 index 00000000..cbaa4502 --- /dev/null +++ b/package/RFEM/Reports/htmlStyles.css @@ -0,0 +1,72 @@ +body{ + background: white; + color: black; + font-family: sans-serif; +} +table{ + width: 100%; + margin: auto; + font-size: 13px; +} +table, th, td{ + border: 1px solid #d7d4d4; + border-collapse: separate; /* Don't collapse */ + border-spacing: 0; +} +th{ + padding: 5px; +} +td{ + padding: 5px; + min-width: 40px; +} +tr:nth-child(even) {background-color: #fffae6;} +thead{ + position: sticky; + top: 0; + background-color: white; +} +.tabContainer{ + padding-top:10px; +} +.button { + background-color: #D4E6F1; /* Blue Gray */ + border: none; + color: black; + padding: 6px 3px; + font-family: sans-serif; + text-align: center; + text-decoration: none; + display: inline-block; + font-size: 11px; + transition-duration: 0.2s; + position: relative; + display: inline-block; +} +.button:hover { + background-color: #d7d4d4; + color: black; +} +.title{ + font-family: sans-serif; + color: #ECF0F1; + text-align: top; +} +progress { + position: absolute; + left: 50%; + top: 50%; +} +input { + /*border: 1px solid transparent;*/ + height: 25px; + width: 500px; + border: solid 1px black; + border-radius: 3px; + padding-left: 5px; + cursor: pointer; +} +iframe { + height: 90%; + width: 100%; +} diff --git a/package/RFEM/Reports/partsList.py b/package/RFEM/Reports/partsList.py new file mode 100644 index 00000000..637bf8d0 --- /dev/null +++ b/package/RFEM/Reports/partsList.py @@ -0,0 +1,62 @@ + +from RFEM.initModel import Model + +def GetPartsListAllByMaterial(): + ''' + Returns Parts List All By Material + ''' + try: + return Model.clientModel.service.get_parts_list_all_by_material() + except: + Model.clientModel.service.generate_parts_lists() + return Model.clientModel.service.get_parts_list_all_by_material() + +def GetPartsListMemberRepresentativesByMaterial(): + ''' + Returns Parts List Member Representatives By Material + ''' + try: + return Model.clientModel.service.get_parts_list_member_representatives_by_material() + except: + Model.clientModel.service.generate_parts_lists() + return Model.clientModel.service.get_parts_list_member_representatives_by_material() + +def GetPartsListMemberSetsByMaterial(): + ''' + Returns Parts List Member Sets By Material + ''' + try: + return Model.clientModel.service.get_parts_list_member_sets_by_material() + except: + Model.clientModel.service.generate_parts_lists() + return Model.clientModel.service.get_parts_list_member_sets_by_material() + +def GetPartsListMembersByMaterial(): + ''' + Returns Parts List Members By Material + ''' + try: + return Model.clientModel.service.get_parts_list_members_by_material() + except: + Model.clientModel.service.generate_parts_lists() + return Model.clientModel.service.get_parts_list_members_by_material() + +def GetPartsListSolidsByMaterial(): + ''' + Returns Parts List Solids By Material + ''' + try: + return Model.clientModel.service.get_parts_list_solids_by_material() + except: + Model.clientModel.service.generate_parts_lists() + return Model.clientModel.service.get_parts_list_solids_by_material() + +def GetPartsListSurfacessByMaterial(): + ''' + Returns Parts List Surfaces By Material + ''' + try: + return Model.clientModel.service.get_parts_list_surfaces_by_material() + except: + Model.clientModel.service.generate_parts_lists() + return Model.clientModel.service.get_parts_list_surfaces_by_material() diff --git a/package/RFEM/Results/designOverview.py b/package/RFEM/Results/designOverview.py new file mode 100644 index 00000000..a7c731c0 --- /dev/null +++ b/package/RFEM/Results/designOverview.py @@ -0,0 +1,31 @@ +from RFEM.initModel import Model + +def GetDesignOverview(): + ''' + Returns whole Design Overview list. + ''' + # Return Design Overview + return Model.clientModel.service.get_design_overview() + +def GetPartialDesignOverview(comply: bool = False): + """ + Returns part of Design Overview that do(esn't) comply. + If comply == False, function resturns checks with Design Ration > 1 + If comply == True, function resturns checks with Design Ration <= 1 + """ + designOverview = GetDesignOverview() + + designRatioLessThanOne = [] + designRationOverOne = [] + for do in designOverview[0]: + if round(do['design_ratio'], 5) <= 1.0: + designRatioLessThanOne.append(do) + else: + designRationOverOne.append(do) + + if comply: + return designRatioLessThanOne + else: + return designRationOverOne + + diff --git a/package/RFEM/SpecialObjects/__init__.py b/package/RFEM/SpecialObjects/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/SpecialObjects/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/SpecialObjects/enlargedColumnHead.py b/package/RFEM/SpecialObjects/enlargedColumnHead.py new file mode 100644 index 00000000..e12825ca --- /dev/null +++ b/package/RFEM/SpecialObjects/enlargedColumnHead.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class EnlargedColumnHead(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Enlarged Column Head + clientObject = Model.clientModel.factory.create('ns0:enlarged_column_head') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Enlarged Column Head No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Enlarged Column Head to client model + Model.clientModel.service.set_enlarged_column_head(clientObject) diff --git a/package/RFEM/SpecialObjects/intersection.py b/package/RFEM/SpecialObjects/intersection.py new file mode 100644 index 00000000..a0ee9e8f --- /dev/null +++ b/package/RFEM/SpecialObjects/intersection.py @@ -0,0 +1,32 @@ +from RFEM.initModel import Model, clearAtributes + +class Instersection(): + def __init__(self, + no: int = 1, + surface_1: int = 1, + surface_2: int = 2, + comment: str = '', + params: dict = {}): + + # Client model | Intersection + clientObject = Model.clientModel.factory.create('ns0:intersection') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Intersection No. + clientObject.no = no + + # Assigned surfaces + clientObject.surface_a = surface_1 + clientObject.surface_b = surface_2 + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Intersection to client model + Model.clientModel.service.set_intersection(clientObject) diff --git a/package/RFEM/SpecialObjects/resultSection.py b/package/RFEM/SpecialObjects/resultSection.py new file mode 100644 index 00000000..80941e10 --- /dev/null +++ b/package/RFEM/SpecialObjects/resultSection.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class ResultSection(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Result Section + clientObject = Model.clientModel.factory.create('ns0:result_section') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Result Section No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Result Section to client model + Model.clientModel.service.set_result_section(clientObject) diff --git a/package/RFEM/SpecialObjects/rigidLink.py b/package/RFEM/SpecialObjects/rigidLink.py new file mode 100644 index 00000000..0d76d93a --- /dev/null +++ b/package/RFEM/SpecialObjects/rigidLink.py @@ -0,0 +1,150 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import * + +class RigidLink(): + def __init__(self, + no: int = 1, + line_1: int = 1, + line_2: int = 2, + ignore_relative_position: bool = True, + comment: str = '', + params: dict = {}): + + # Client model | Rigid Link + clientObject = Model.clientModel.factory.create('ns0:rigid_link') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Type + #clientObject.type = RigidLinkType.TYPE_LINE_TO_LINE.name + + # Rigid Link No. + clientObject.no = no + + # Attached lines + clientObject.line1 = line_1 + clientObject.line2 = line_2 + + # Ignore relative possition + clientObject.ignore_relative_position = ignore_relative_position + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add rigid link to client model + Model.clientModel.service.set_rigid_link(clientObject) + + def LineToLine(self, + no: int = 1, + line_1: int = 1, + line_2: int = 2, + ignore_relative_position: bool = True, + comment: str = '', + params: dict = {}): + + # Client model | Line To Line Rigid Link + clientObject = Model.clientModel.factory.create('ns0:rigid_link') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Type + clientObject.type = RigidLinkType.TYPE_LINE_TO_LINE.name + + # Rigid Link No. + clientObject.no = no + + # Attached lines + clientObject.line1 = line_1 + clientObject.line2 = line_2 + + # Ignore relative possition + clientObject.ignore_relative_position = ignore_relative_position + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add rigid link to client model + Model.clientModel.service.set_rigid_link(clientObject) + + def LineToSurface(self, + no: int = 1, + line_1: int = 1, + surface: int = 1, + ignore_relative_position: bool = True, + comment: str = '', + params: dict = {}): + + # Client model | Line To Surface Rigid Link + clientObject = Model.clientModel.factory.create('ns0:rigid_link') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Rigid Link No. + clientObject.no = no + + # Type + clientObject.type = RigidLinkType.TYPE_LINE_TO_SURFACE.name + + # Attached lines + clientObject.line1 = line_1 + + clientObject.surface = surface + + # Ignore relative possition + clientObject.ignore_relative_position = ignore_relative_position + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add rigid link to client model + Model.clientModel.service.set_rigid_link(clientObject) + + def Diapragm(self, + no: int = 1, + nodes: str = '3 4', + lines: str = '6 7', + comment: str = '', + params: dict = {}): + + # Client model | Diapragm Rigid Link + clientObject = Model.clientModel.factory.create('ns0:rigid_link') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Rigid Link No. + clientObject.no = no + + # Type + clientObject.type = RigidLinkType.TYPE_DIAPHRAGM.name + + # Attached nodes + clientObject.nodes = nodes + + # Attached lines + clientObject.lines = lines + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add rigid link to client model + Model.clientModel.service.set_rigid_link(clientObject) diff --git a/package/RFEM/SpecialObjects/structureModification.py b/package/RFEM/SpecialObjects/structureModification.py new file mode 100644 index 00000000..3166e50f --- /dev/null +++ b/package/RFEM/SpecialObjects/structureModification.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class StructureModification(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Structure Modification + clientObject = Model.clientModel.factory.create('ns0:structure_modification') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Structure Modification No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Structure Modification to client model + Model.clientModel.service.set_structure_modification(clientObject) diff --git a/package/RFEM/SpecialObjects/surfaceContact.py b/package/RFEM/SpecialObjects/surfaceContact.py new file mode 100644 index 00000000..33ef394f --- /dev/null +++ b/package/RFEM/SpecialObjects/surfaceContact.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SurfaceContact(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Surfaces Contact + clientObject = Model.clientModel.factory.create('ns0:surfaces_contact') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surfaces Contact No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surfaces Contact to client model + Model.clientModel.service.set_surfaces_contact(clientObject) diff --git a/package/RFEM/SpecialObjects/surfaceResultAdjustment.py b/package/RFEM/SpecialObjects/surfaceResultAdjustment.py new file mode 100644 index 00000000..bc486ee8 --- /dev/null +++ b/package/RFEM/SpecialObjects/surfaceResultAdjustment.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SurfaceResultsAdjustment(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Surface Result Adjustment + clientObject = Model.clientModel.factory.create('ns0:surface_results_adjustment') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Result Adjustment No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Result Adjustmentto client model + Model.clientModel.service.set_surface_results_adjustment(clientObject) diff --git a/package/RFEM/Tools/ModelCheck.py b/package/RFEM/Tools/ModelCheck.py new file mode 100644 index 00000000..d0726f60 --- /dev/null +++ b/package/RFEM/Tools/ModelCheck.py @@ -0,0 +1,108 @@ +from RFEM.initModel import Model +from RFEM.enums import ModelCheckGetOptionType, ModelCheckProcessOptionType + +class ModelCheck(): + + def __init__(self): + pass + + def GetIdenticalNodes(self, tolerance): + """ + Args: + tolerance (float): Tolerance + Returns: + Identical Nodes Object Group + """ + + operation = ModelCheckGetOptionType.IDENTICAL_NODES.name + object_groups = Model.clientModel.service.model_check__get_object_groups_operation(operation, tolerance) + + return object_groups + + def DeleteUnusedNodes(self, tolerance, object_groups): + """ + Args: + tolerance (float): Tolerance + object_groups (dict): Object Groups of Identical Nodes + """ + + process = ModelCheckProcessOptionType.DELETE_UNUSED_NODES.name + Model.clientModel.service.model_check__process_object_groups_operation(process, tolerance, object_groups) + + def UniteNodes(self, tolerance, object_groups): + """ + Args: + tolerance (float): Tolerance + object_groups (dict): Object Groups of Identical Nodes + """ + + process = ModelCheckProcessOptionType.UNITE_NODES_AND_DELETE_UNUSED_NODES.name + Model.clientModel.service.model_check__process_object_groups_operation(process, tolerance, object_groups) + + def GetNotConnectedLines(self, tolerance): + """ + Args: + tolerance (float): Tolerance + Returns: + Not Connected Lines Line Groups + """ + + operation = ModelCheckGetOptionType.CROSSING_LINES.name + line_groups = Model.clientModel.service.model_check__get_object_groups_operation(operation, tolerance) + + return line_groups + + def CrossLines(self, tolerance, line_groups): + """ + Args: + tolerance (float): Tolerance + line_groups (dict): Line Groups of Not Connected Lines + """ + + process = ModelCheckProcessOptionType.CROSS_LINES.name + Model.clientModel.service.model_check__process_object_groups_operation(process, tolerance, line_groups) + + def GetNotConnectedMembers(self, tolerance): + """ + Args: + tolerance (float): Tolerance + Returns: + Not Connected Members Member Groups + """ + + operation = ModelCheckGetOptionType.CROSSING_MEMBERS.name + member_groups = Model.clientModel.service.model_check__get_object_groups_operation(operation, tolerance) + + return member_groups + + def CrossMembers(self, tolerance, member_groups): + """ + Args: + tolerance (float): Tolerance + member_groups (dict): Member Groups of Not Connected Members + """ + + process = ModelCheckProcessOptionType.CROSS_MEMBERS.name + Model.clientModel.service.model_check__process_object_groups_operation(process, tolerance, member_groups) + + def GetOverlappingLines(self): + """ + Returns: + Overlapping Line Groups + """ + + operation = ModelCheckGetOptionType.OVERLAPPING_LINES.name + overlapping_lines = Model.clientModel.service.model_check__get_object_groups_operation(operation) + + return overlapping_lines + + def GetOverlappingMembers(self): + """ + Returns: + Overlapping Member Groups + """ + + operation = ModelCheckGetOptionType.OVERLAPPING_MEMBERS.name + overlapping_members = Model.clientModel.service.model_check__get_object_groups_operation(operation) + + return overlapping_members diff --git a/package/RFEM/Tools/PlausibilityCheck.py b/package/RFEM/Tools/PlausibilityCheck.py new file mode 100644 index 00000000..701a7da3 --- /dev/null +++ b/package/RFEM/Tools/PlausibilityCheck.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model +from RFEM.enums import PlausibilityCheckResult + +class PlausibilityCheck(): + + def __init__(self, + skip_warnings:bool = False): + + response = Model.clientModel.service.plausibility_check(skip_warnings) + + if "failed" in response: + self.checkresult = PlausibilityCheckResult.CHECK_FAILED.name + self.message = response.split("Messages received:", 1)[1] + self.errormessage = self.message.split("Result 'false'", 1)[0] + else: + self.checkresult = PlausibilityCheckResult.CHECK_IS_OK.name + self.message = 'Success' + self.errormessage = "" + + def IsModelOK(self): + + return self.checkresult == PlausibilityCheckResult.CHECK_IS_OK.name + + def GetErrorMessage(self): + + return self.errormessage diff --git a/package/RFEM/Tools/centreOfGravityAndObjectInfo.py b/package/RFEM/Tools/centreOfGravityAndObjectInfo.py new file mode 100644 index 00000000..902f167c --- /dev/null +++ b/package/RFEM/Tools/centreOfGravityAndObjectInfo.py @@ -0,0 +1,111 @@ +from RFEM.initModel import Model +from RFEM.enums import ObjectTypes, SelectedObjectInformation + +class ObjectInformation(): + # missing def __init__( with definition of self and its variables + # object_type, no, parent_no, information, row_key and result. + + def CentreOfGravity(self, + type = ObjectTypes.E_OBJECT_TYPE_MEMBER, + parent_no = 0, + no: int = 1, + coord: str = 'X'): + ''' + This function returns the centre of gravity position (X, Y or Z) for a selected object. + Args: + type (enum): Object Type + parent_no (int): Object Parent Number + Note: + (1) A geometric object has, in general, a parent_no = 0 + (2) The parent_no parameter becomes significant for example with loads + no (int): The Object Tag + coord (str): Desired global basis vector component of the Centre of Gravity (i.e. X, Y or Z) + ''' + self.object_type = type + self.no = no + self.parent_no = parent_no + result = ObjectInformation.__BuildResultsArray(self) + if coord == 'X' or coord.lstrip().rstrip().upper() == 'X': + return result['section'][0].rows[0][0].value + elif coord == 'Y' or coord.lstrip().rstrip().upper() == 'Y': + return result['section'][0].rows[0][1].value + elif coord == 'Z' or coord.lstrip().rstrip().upper() == 'Z': + return result['section'][0].rows[0][2].value + else: + raise Exception ('WARNING: The desired Coordinate input not requested. Please provide either "X", "Y" or "Z"') + + def MemberInformation(self, + no: int = 1, + information = SelectedObjectInformation.LENGTH): + ''' + This function returns further information associated with a member. + Args: + no (int): Member Tag + information (enum): Desired Information (Length / Volume / Mass) + ''' + if information.name == 'AREA': + raise Exception ('WARNING: Area information is only relevant for Surface and Volume Information.') + self.object_type = ObjectTypes.E_OBJECT_TYPE_MEMBER + self.no = no + self.parent_no = 0 + self.information = information + self.row_key = 2 + self.result = ObjectInformation.__BuildResultsArray(self) + return ObjectInformation.__AreaVolumeMassInformationLength(self) + + def SurfaceInformation(self, + no: int = 1, + information = SelectedObjectInformation.AREA): + ''' + This function returns further information associated with a surface. + Args: + no (int): Surface Tag + information (enum): Desired Information (Area / Volume / Mass) + ''' + if information.name == 'LENGTH': + raise Exception ('WARNING: Length information is only relevant for Member Information.') + self.object_type = ObjectTypes.E_OBJECT_TYPE_SURFACE + self.no = no + self.parent_no = 0 + self.information = information + self.row_key = 3 + self.result = ObjectInformation.__BuildResultsArray(self) + return ObjectInformation.__AreaVolumeMassInformationLength(self) + + def SolidInformation(self, + no: int = 1, + information = SelectedObjectInformation.AREA): + ''' + This function returns further information associated with a solid. + Args: + no (int): Solid Tag + information (enum): Desired Information (Area / Volume / Mass) + ''' + if information.name == 'LENGTH': + raise Exception ('WARNING: Length information is only relevant for Member Information.') + self.object_type = ObjectTypes.E_OBJECT_TYPE_SOLID + self.no = no + self.parent_no = 0 + self.information = information + self.row_key = 4 + self.result = ObjectInformation.__BuildResultsArray(self) + return ObjectInformation.__AreaVolumeMassInformationLength(self) + + def __BuildResultsArray(self): + elements = Model.clientModel.factory.create('ns0:array_of_get_center_of_gravity_and_objects_info_elements_type') + clientObject = Model.clientModel.factory.create('ns0:get_center_of_gravity_and_objects_info_element_type') + clientObject.parent_no = self.parent_no + clientObject.no = self.no + clientObject.type = self.object_type.name + elements.element.append(clientObject) + result = Model.clientModel.service.get_center_of_gravity_and_objects_info(elements) + result = Model.clientModel.dict(result) + return result + + def __AreaVolumeMassInformationLength(self): + if self.information.name == "LENGTH" or self.information.name == "AREA": + return self.result['section'][self.row_key].rows[0][0].value + elif self.information.name == "VOLUME": + return self.result['section'][self.row_key].rows[0][1].value + elif self.information.name == "MASS": + return self.result['section'][self.row_key].rows[0][2].value diff --git a/package/RFEM/Tools/sectionDialogue.py b/package/RFEM/Tools/sectionDialogue.py new file mode 100644 index 00000000..354806f3 --- /dev/null +++ b/package/RFEM/Tools/sectionDialogue.py @@ -0,0 +1,43 @@ +from RFEM.initModel import Model + +def CreateSectionFavoriteList(name: str = "Favorites"): + + if isinstance(name, str): + Model.clientModel.service.create_section_favorite_list(name) + else: + print("WARNING:Name of the section favorite list should be a string. Please kindly check the inputs.") + +def AddSectionToFavoriteList(list_name: str = "Favorites", + section_name: str = "IPE 300"): + + if isinstance(list_name, str) and isinstance(section_name, str): + Model.clientModel.service.add_section_to_favorite_list(list_name, section_name) + else: + print("WARNING:Name of the section favorite list and the section should be a string. Please kindly check the inputs.") + +def DeleteSectionFromFavoriteList(list_name: str = "Favorites", + section_name: str = "IPE 300"): + + if isinstance(list_name, str) and isinstance(section_name, str): + Model.clientModel.service.delete_section_from_favorite_list(list_name, section_name) + else: + print("WARNING:Name of the section favorite list and the section should be a string. Please kindly check the inputs.") + +def GetSectionFavoriteLists(): + + return Model.clientModel.service.get_section_favorite_lists() + +def DeleteSectionFavoriteList(name: str = "Favorites"): + + if isinstance(name, str): + Model.clientModel.service.delete_section_favorite_list(name) + else: + print("WARNING:Name of the section favorite list should be a string. Please kindly check the inputs.") + +def CreateSectionFromRsectionFile(no: int = 1, + file_path: str = "/rsection_file_path/"): + + if isinstance(no, int) and isinstance(file_path, str): + Model.clientModel.service.create_section_from_rsection_file(no, file_path) + else: + print("WARNING: Type of file_path argument should be string and the type of the no argument should be integer. Please kindly check the inputs.") diff --git a/package/RFEM/TypesForLines/__init__.py b/package/RFEM/TypesForLines/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesForLines/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/TypesForLines/lineHinge.py b/package/RFEM/TypesForLines/lineHinge.py new file mode 100644 index 00000000..dfa445c7 --- /dev/null +++ b/package/RFEM/TypesForLines/lineHinge.py @@ -0,0 +1,54 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.dataTypes import inf + +class LineHinge(): + # Slab Wall Connection definition + slabWallConnection = {'slab_wall_connection': True, + 'slab_wall_with_slab_edge_block': True, + 'slab_wall_connection_offset': 0.15, + 'slab_edge_block_width':0.1} + + def __init__(self, + no: int = 1, + assigned_to: str = '3/5; 2/5', + translational_release: list = [800, inf, inf], + rotational_release_phi: int = inf, + comment: str = '', + params: dict = {}): + + """ + assigned_to doesn't work. Can't figure why. + Assignment in surfaces also doesn't work (surface.has_line_hinges = True). + """ + + # Client model | Line Hinge + clientObject = Model.clientModel.factory.create('ns0:line_hinge') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Hinge No. + clientObject.no = no + + # Assigned to surface and its line (format 1/3) + clientObject.assigned_to = assigned_to + + # Translatioonal and totational release + clientObject.translational_release_u_x = translational_release[0] + clientObject.translational_release_u_y = translational_release[1] + clientObject.translational_release_u_z = translational_release[2] + clientObject.rotational_release_phi_x = rotational_release_phi + + # Slab connection + clientObject.slab_wall_connection = False + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Hinge to client model + Model.clientModel.service.set_line_hinge(clientObject) + diff --git a/package/RFEM/TypesForLines/lineMeshRefinements.py b/package/RFEM/TypesForLines/lineMeshRefinements.py new file mode 100644 index 00000000..3bad2d34 --- /dev/null +++ b/package/RFEM/TypesForLines/lineMeshRefinements.py @@ -0,0 +1,159 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import LineMeshRefinementsType + +class LineMeshRefinements(): + TypeSpecificParams = {'target_length': 0.1, #Target FE Length Type + 'elements_finite_elements': 0, # Number Finite Elements Type + 'gradual_rows': 0} # Gradually Type + def __init__(self, + no: int = 1, + lines: str = '3 4 5', + type = LineMeshRefinementsType.TYPE_LENGTH, + number_of_layers: int = 2, + comment: str = '', + params: dict = {}): + + # Client model | Line Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:line_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Mesh Refinement No. + clientObject.no = no + + # Assigned to lines + clientObject.lines = ConvertToDlString(lines) + + # Line Mesh Refinement Type + clientObject.type = type.name + + # Number of layers + clientObject.number_of_layers = number_of_layers + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Mesh Refinement to client model + Model.clientModel.service.set_line_mesh_refinement(clientObject) + + def TargetFELength(self, + no: int = 1, + lines: str = '3 4 5', + target_length: float = 0.1, + number_of_layers: int = 2, + comment: str = '', + params: dict = {}): + + # Client model | Line Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:line_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Mesh Refinement No. + clientObject.no = no + + # Assigned to lines + clientObject.lines = ConvertToDlString(lines) + + # Line Mesh Refinement Type + clientObject.type = LineMeshRefinementsType.TYPE_LENGTH.name + + # Target Length + clientObject.target_length = target_length + + # Number of layers + clientObject.number_of_layers = number_of_layers + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Mesh Refinement to client model + Model.clientModel.service.set_line_mesh_refinement(clientObject) + + def NumberFiniteElements(self, + no: int = 1, + lines: str = '3 4 5', + elements_finite_elements: int = 10, + number_of_layers: int = 2, + comment: str = '', + params: dict = {}): + + # Client model | Line Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:line_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Mesh Refinement No. + clientObject.no = no + + # Assigned to lines + clientObject.lines = ConvertToDlString(lines) + + # Line Mesh Refinement Type + clientObject.type = LineMeshRefinementsType.TYPE_ELEMENTS.name + + # Target Length + clientObject.elements_finite_elements = elements_finite_elements + + # Number of layers + clientObject.number_of_layers = number_of_layers + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Mesh Refinement to client model + Model.clientModel.service.set_line_mesh_refinement(clientObject) + + def Gradually(self, + no: int = 1, + lines: str = '3 4 5', + gradual_rows: int = 10, + number_of_layers: int = 2, + comment: str = '', + params: dict = {}): + + # Client model | Line Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:line_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Mesh Refinement No. + clientObject.no = no + + # Assigned to lines + clientObject.lines = ConvertToDlString(lines) + + # Line Mesh Refinement Type + clientObject.type = LineMeshRefinementsType.TYPE_GRADUAL.name + + # Target Length + clientObject.gradual_rows = gradual_rows + + # Number of layers + clientObject.number_of_layers = number_of_layers + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Mesh Refinement to client model + Model.clientModel.service.set_line_mesh_refinement(clientObject) diff --git a/package/RFEM/TypesForLines/lineSupport.py b/package/RFEM/TypesForLines/lineSupport.py new file mode 100644 index 00000000..504824c6 --- /dev/null +++ b/package/RFEM/TypesForLines/lineSupport.py @@ -0,0 +1,92 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.dataTypes import inf +from RFEM.enums import LineSupportType + +def setLineSupportConditions(clientObject, + C_u_X: float, + C_u_Y: float, + C_u_Z: float, + C_phi_X: float, + C_phi_Y: float, + C_phi_Z: float): + ''' + Sets line support conditions + + Params: + clientObject: Client model object | Line support + C_u_X,Y,Z: Translational support conditions in respected direction + C_phi_X,Y,Z: Rotational support conditions about respected axis + comment: Comment + + Returns: + clientObject: Initialized client model object | Line Support + ''' + + clientObject.spring_x = C_u_X + clientObject.spring_y = C_u_Y + clientObject.spring_z = C_u_Z + + clientObject.rotational_restraint_x = C_phi_X + clientObject.rotational_restraint_y = C_phi_Y + clientObject.rotational_restraint_z = C_phi_Z + + return clientObject + +class LineSupport(): + def __init__(self, + no: int = 1, + lines_no: str = '1 2', + support_type = LineSupportType.HINGED, + comment: str = '', + params: dict = {}): + + # Client model | Line Support + clientObject = Model.clientModel.factory.create('ns0:line_support') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Support No. + clientObject.no = no + + # Nodes No. (e.g. "5 6 7 12") + clientObject.lines = ConvertToDlString(lines_no) + + # Nodal Support Conditions + if support_type == LineSupportType.FIXED: + # FIXED 'xxx xxx' + clientObject = setLineSupportConditions(clientObject, inf, inf, inf, inf, inf, inf) + + elif support_type == LineSupportType.HINGED: + # HINGED 'xxx ---' + clientObject = setLineSupportConditions(clientObject, inf, inf, inf, 0.0, 0.0, 0.0) + + elif support_type == LineSupportType.SLIDING_IN_X_AND_Y: + # SLIDING_IN_X_AND_Y '--x --x' + clientObject = setLineSupportConditions(clientObject, 0.0, 0.0, inf, 0.0, 0.0, inf) + + elif support_type == LineSupportType.SLIDING_IN_X: + # SLIDING_IN_X '-xx --x' + clientObject = setLineSupportConditions(clientObject, 0.0, inf, inf, 0.0, 0.0, inf) + + elif support_type == LineSupportType.SLIDING_IN_Y: + # SLIDING_IN_Y 'x-x --x' + clientObject = setLineSupportConditions(clientObject, inf, 0.0, inf, 0.0, 0.0, inf) + + elif support_type == LineSupportType.SLIDING_IN_Z: + # SLIDING_IN_Z 'xx- --x' + clientObject = setLineSupportConditions(clientObject, inf, inf, 0.0, 0.0, 0.0, inf) + + elif support_type == LineSupportType.FREE: + # FREE '--- ---' + clientObject = setLineSupportConditions(clientObject, 10000, 0, 0, 0, 0, 0) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line Support to client model + Model.clientModel.service.set_line_support(clientObject) diff --git a/package/RFEM/TypesForLines/lineWeldedJoint.py b/package/RFEM/TypesForLines/lineWeldedJoint.py new file mode 100644 index 00000000..792ae196 --- /dev/null +++ b/package/RFEM/TypesForLines/lineWeldedJoint.py @@ -0,0 +1,62 @@ +from RFEM.initModel import Model, clearAtributes, ConvertStrToListOfInt +from RFEM.enums import LineWeldedJointType, WeldType, WeldLongitudalArrangement + +class LineWeldedJoint(): + def __init__(self, + no: int = 1, + lines: str = '5', + surfaces: str = '1 2', + joint_type = LineWeldedJointType.BUTT_JOINT, + weld_type = WeldType.WELD_SINGLE_V, + weld_size_a1: int = 0.005, + longitudinal_arrangement = WeldLongitudalArrangement.CONTINUOUS, + comment: str = '', + params: dict = {}): + + # Client model | Line Welded Joint + clientObject = Model.clientModel.factory.create('ns0:line_welded_joint') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Line Welded Joint No. + clientObject.no = no + + # Line Welded Joint Type + clientObject.joint_type = joint_type.name + + # Weld Type + clientObject.weld_type = weld_type.name + + # Weld Longitudal Arrangement + clientObject.longitudinal_arrangement = longitudinal_arrangement.name + + # Weld Size a1 + clientObject.weld_size_a1 = weld_size_a1 + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line welded joint to client model + Model.clientModel.service.set_line_welded_joint(clientObject) + + iLines = ConvertStrToListOfInt(lines) + iSurfaces = ConvertStrToListOfInt(surfaces) + + for i in iLines: + line = Model.clientModel.service.get_line(i) + line.has_line_welds = True + clientWeld = Model.clientModel.factory.create('ns0:line_line_weld_assignment') + clientWeld.no = i + clientWeld.weld = no + clientWeld.surface1 = iSurfaces[0] + clientWeld.surface2 = iSurfaces[1] + if len(iSurfaces) == 3: + clientWeld.surface3 = iSurfaces[2] + line.line_weld_assignment = Model.clientModel.factory.create('ns0:array_of_line_line_weld_assignment') + line.line_weld_assignment.line_line_weld_assignment.append(clientWeld) + Model.clientModel.service.set_line(line) diff --git a/package/RFEM/TypesForMembers/__init__.py b/package/RFEM/TypesForMembers/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesForMembers/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/TypesForMembers/memberDefinableStiffness.py b/package/RFEM/TypesForMembers/memberDefinableStiffness.py new file mode 100644 index 00000000..6f9d8fea --- /dev/null +++ b/package/RFEM/TypesForMembers/memberDefinableStiffness.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class MemberDefinableStiffness(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Member Definable Stffness + clientObject = Model.clientModel.factory.create('ns0:member_definable_stiffness') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Definable Stffness No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Definable Stffness to client model + Model.clientModel.service.set_member_definable_stiffness(clientObject) diff --git a/package/RFEM/TypesForMembers/memberEccentricity.py b/package/RFEM/TypesForMembers/memberEccentricity.py new file mode 100644 index 00000000..235d1bb5 --- /dev/null +++ b/package/RFEM/TypesForMembers/memberEccentricity.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class MemberEccentricity(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Member Eccentricity + clientObject = Model.clientModel.factory.create('ns0:member_eccentricity') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Eccentricity No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Eccentricity to client model + Model.clientModel.service.set_member_eccentricity(clientObject) diff --git a/package/RFEM/TypesForMembers/memberHinge.py b/package/RFEM/TypesForMembers/memberHinge.py new file mode 100644 index 00000000..640f3839 --- /dev/null +++ b/package/RFEM/TypesForMembers/memberHinge.py @@ -0,0 +1,55 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.dataTypes import inf + +class MemberHinge(): + def __init__(self, + no: int = 1, + coordinate_system: str = "Local", + translational_release_n: float = inf, + translational_release_vy: float = inf, + translational_release_vz: float = inf, + rotational_release_mt: float = inf, + rotational_release_my: float = 0.0, + rotational_release_mz: float = inf, + comment: str = 'Rotational Release My', + params: dict = {}): + + # Client model | Member Hinge + clientObject = Model.clientModel.factory.create('ns0:member_hinge') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Memeber Hinge No. + clientObject.no = no + + # Coordinate System + clientObject.coordinate_system = coordinate_system + + # Translational Release/Spring [kN/m] N + clientObject.axial_release_n = translational_release_n + + # Translational Release/Spring [kN/m] Vy + clientObject.axial_release_vy = translational_release_vy + + # Translational Release/Spring [kN/m] Vz + clientObject.axial_release_vz = translational_release_vz + + # Rotational Release/Spring [kNm/rad] Mt + clientObject.moment_release_mt = rotational_release_mt + + # Rotational Release/Spring [kNm/rad] My + clientObject.moment_release_my = rotational_release_my + + # Rotational Release/Spring [kNm/rad] Mz + clientObject.moment_release_mz = rotational_release_mz + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Line to client model + Model.clientModel.service.set_member_hinge(clientObject) diff --git a/package/RFEM/TypesForMembers/memberNonlinearity.py b/package/RFEM/TypesForMembers/memberNonlinearity.py new file mode 100644 index 00000000..43065248 --- /dev/null +++ b/package/RFEM/TypesForMembers/memberNonlinearity.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class MemberNonlinearity(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Member Nonlinearity + clientObject = Model.clientModel.factory.create('ns0:member_nonlinearity') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Nonlinearity No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Nonlinearity to client model + Model.clientModel.service.set_member_nonlinearity(clientObject) diff --git a/package/RFEM/TypesForMembers/memberResultIntermediatePoints.py b/package/RFEM/TypesForMembers/memberResultIntermediatePoints.py new file mode 100644 index 00000000..5e9c3159 --- /dev/null +++ b/package/RFEM/TypesForMembers/memberResultIntermediatePoints.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class MemberResultIntermediatePoint(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Member Result Intermediate Point + clientObject = Model.clientModel.factory.create('ns0:member_result_intermediate_point') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Result Intermediate Point No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Result Intermediate Point to client model + Model.clientModel.service.set_member_result_intermediate_point(clientObject) diff --git a/package/RFEM/TypesForMembers/memberStiffnessModification.py b/package/RFEM/TypesForMembers/memberStiffnessModification.py new file mode 100644 index 00000000..e4e8f7c9 --- /dev/null +++ b/package/RFEM/TypesForMembers/memberStiffnessModification.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class MemberStiffnessModification(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Member Stiffness Modification + clientObject = Model.clientModel.factory.create('ns0:smember_stiffness_modification') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Stiffness Modification No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Stiffness Modification to client model + Model.clientModel.service.set_member_stiffness_modification(clientObject) diff --git a/package/RFEM/TypesForMembers/memberSupport.py b/package/RFEM/TypesForMembers/memberSupport.py new file mode 100644 index 00000000..b05af708 --- /dev/null +++ b/package/RFEM/TypesForMembers/memberSupport.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class MemberSupport(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Member Support + clientObject = Model.clientModel.factory.create('ns0:member_support') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Member Support No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Member Support to client model + Model.clientModel.service.set_member_support(clientObject) diff --git a/package/RFEM/TypesForNodes/__init__.py b/package/RFEM/TypesForNodes/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesForNodes/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/TypesForNodes/nodalMeshRefinement.py b/package/RFEM/TypesForNodes/nodalMeshRefinement.py new file mode 100644 index 00000000..544fd8c8 --- /dev/null +++ b/package/RFEM/TypesForNodes/nodalMeshRefinement.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class NodalMeshRefinement(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Nodal Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:nodal_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Nodal Mesh Refinement No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Nodal Mesh Refinement to client model + Model.clientModel.service.set_nodal_mesh_refinement(clientObject) diff --git a/package/RFEM/TypesForNodes/nodalSupport.py b/package/RFEM/TypesForNodes/nodalSupport.py new file mode 100644 index 00000000..aab0dc95 --- /dev/null +++ b/package/RFEM/TypesForNodes/nodalSupport.py @@ -0,0 +1,92 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.dataTypes import inf +from RFEM.enums import NodalSupportType + +def setNodalSupportConditions(clientObject, + C_u_X: float, + C_u_Y: float, + C_u_Z: float, + C_phi_X: float, + C_phi_Y: float, + C_phi_Z: float): + ''' + Sets nodal support conditions + + Params: + clientObject: Client model object | Nodal support + C_u_X,Y,Z: Translational support conditions in respected direction + C_phi_X,Y,Z: Rotational support conditions about respected axis + comment: Comment + + Returns: + clientObject: Initialized client model object | Nodal Support + ''' + + clientObject.spring_x = C_u_X + clientObject.spring_y = C_u_Y + clientObject.spring_z = C_u_Z + + clientObject.rotational_restraint_x = C_phi_X + clientObject.rotational_restraint_y = C_phi_Y + clientObject.rotational_restraint_z = C_phi_Z + + return clientObject + +class NodalSupport(): + def __init__(self, + no: int = 1, + nodes_no: str = '1 2', + support_type = NodalSupportType.HINGED, + comment: str = '', + params: dict = {}): + + # Client model | Nodal Support + clientObject = Model.clientModel.factory.create('ns0:nodal_support') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Nodal Support No. + clientObject.no = no + + # Nodes No. (e.g. "5 6 7 12") + clientObject.nodes = ConvertToDlString(nodes_no) + + # Nodal Support Conditions + if support_type == NodalSupportType.FIXED: + # FIXED 'xxx xxx' + clientObject = setNodalSupportConditions(clientObject, inf, inf, inf, inf, inf, inf) + + elif support_type == NodalSupportType.HINGED: + # HINGED 'xxx --x' + clientObject = setNodalSupportConditions(clientObject, inf, inf, inf, 0.0, 0.0, inf) + + elif support_type == NodalSupportType.ROLLER: + # ROLLER '--x --x' + clientObject = setNodalSupportConditions(clientObject, 0.0, 0.0, inf, 0.0, 0.0, inf) + + elif support_type == NodalSupportType.ROLLER_IN_X: + # ROLLER_IN_X '-xx --x' + clientObject = setNodalSupportConditions(clientObject, 0.0, inf, inf, 0.0, 0.0, inf) + + elif support_type == NodalSupportType.ROLLER_IN_Y: + # ROLLER_IN_Y 'x-x --x' + clientObject = setNodalSupportConditions(clientObject, inf, 0.0, inf, 0.0, 0.0, inf) + + elif support_type == NodalSupportType.ROLLER_IN_Z: + # ROLLER_IN_Z 'xx- --x' + clientObject = setNodalSupportConditions(clientObject, inf, inf, 0.0, 0.0, 0.0, inf) + + elif support_type == NodalSupportType.FREE: + # FREE '--- ---' + clientObject = setNodalSupportConditions(clientObject, 0, 0, 0, 0, 0, 0) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Nodal Support to client model + Model.clientModel.service.set_nodal_support(clientObject) diff --git a/package/RFEM/TypesForSolids/__init__.py b/package/RFEM/TypesForSolids/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesForSolids/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/TypesForSolids/solidContact.py b/package/RFEM/TypesForSolids/solidContact.py new file mode 100644 index 00000000..c2fef676 --- /dev/null +++ b/package/RFEM/TypesForSolids/solidContact.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SolidContact(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Solid Contact + clientObject = Model.clientModel.factory.create('ns0:solid_contacts') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid Contact No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Contact to client model + Model.clientModel.service.set_solid_contacts(clientObject) diff --git a/package/RFEM/TypesForSolids/solidGas.py b/package/RFEM/TypesForSolids/solidGas.py new file mode 100644 index 00000000..54d7e6bc --- /dev/null +++ b/package/RFEM/TypesForSolids/solidGas.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SolidGas(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Solid Gas + clientObject = Model.clientModel.factory.create('ns0:solid_gas') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid Gas No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Gas to client model + Model.clientModel.service.set_solid_gas(clientObject) diff --git a/package/RFEM/TypesForSolids/solidMeshRefinement.py b/package/RFEM/TypesForSolids/solidMeshRefinement.py new file mode 100644 index 00000000..80ec791e --- /dev/null +++ b/package/RFEM/TypesForSolids/solidMeshRefinement.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SolidMeshRefinement(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Solid Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:solid_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Solid Mesh Refinement No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Solid Mesh Refinement to client model + Model.clientModel.service.set_solid_mesh_refinement(clientObject) diff --git a/package/RFEM/TypesForSpecialObjects/__init__.py b/package/RFEM/TypesForSpecialObjects/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesForSpecialObjects/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/TypesForSpecialObjects/surfaceContactType.py b/package/RFEM/TypesForSpecialObjects/surfaceContactType.py new file mode 100644 index 00000000..ad118929 --- /dev/null +++ b/package/RFEM/TypesForSpecialObjects/surfaceContactType.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SurfaceContactType(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Surface Contact Type + clientObject = Model.clientModel.factory.create('ns0:surfaces_contact_type') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Contact Type No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Contact Type to client model + Model.clientModel.service.set_surfaces_contact_type(clientObject) diff --git a/package/RFEM/TypesForSteelDesign/steelEffectiveLengths.py b/package/RFEM/TypesForSteelDesign/steelEffectiveLengths.py new file mode 100644 index 00000000..68e2c98c --- /dev/null +++ b/package/RFEM/TypesForSteelDesign/steelEffectiveLengths.py @@ -0,0 +1,196 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import * + +class SteelEffectiveLengths(): + def __init__(self, + no: int = 1, + members: str = '1', + member_sets: str = '', + flexural_buckling_about_y: bool = True, + flexural_buckling_about_z: bool = True, + torsional_buckling: bool = True, + lateral_torsional_buckling: bool = True, + principal_section_axes: bool = True, + geometric_section_axes: bool = True, + user_defined_name: list = [False], + nodal_supports: list = [ + [SteelEffectiveLengthsSupportType.SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION, True, 0.0, SteelEffectiveLengthsEccentricityType.ECCENTRICITY_TYPE_NONE, \ + 0.0, 0.0, 0.0, 0.0, SteelEffectiveLengthsSupportTypeInY.SUPPORT_STATUS_YES, SteelEffectiveLengthsRestraintTypeAboutX.SUPPORT_STATUS_YES, \ + SteelEffectiveLengthsRestraintTypeAboutZ.SUPPORT_STATUS_NO, SteelEffectiveLengthsRestraintTypeWarping.SUPPORT_STATUS_NO, "1"], + [SteelEffectiveLengthsSupportType.SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION, True, 0.0, SteelEffectiveLengthsEccentricityType.ECCENTRICITY_TYPE_NONE, \ + 0.0, 0.0, 0.0, 0.0, SteelEffectiveLengthsSupportTypeInY.SUPPORT_STATUS_YES, SteelEffectiveLengthsRestraintTypeAboutX.SUPPORT_STATUS_YES, \ + SteelEffectiveLengthsRestraintTypeAboutZ.SUPPORT_STATUS_NO, SteelEffectiveLengthsRestraintTypeWarping.SUPPORT_STATUS_NO, "2"] + ], + factors: list = [ + [1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] + ], + intermediate_nodes: bool = False, + different_properties: bool = True, + factors_definition_absolute: bool = False, + import_from_stability_analysis_enabled: bool = False, + determination_of_mcr = SteelEffectiveLengthsDeterminationMcrEurope.DETERMINATION_EUROPE_EIGENVALUE, + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Effective Length Tag + members (str): Assigned Members + member_sets (str): Assigned Member Sets + flexural_buckling_about_y (bool): Flexural Buckling About Y Option + flexural_buckling_about_z (bool): Flexural Buckling About Z Option + torsional_buckling (bool): Torsional Buckling Option + lateral_torsional_buckling (bool): Lateral Torsional Buckling Option + principal_section_axes (bool): Principal Section Axes Option + geometric_section_axes (bool): Geometric Section Axes Option + user_defined_name (lst): User Defined Effective Length Name + + for user_defined_name[0] == False: + pass + for user_defined_name == True: + user_defined_name[1] = Defined Name + + nodal_supports (lst): Nodal Support Table Definition + + nodal_supports[i][0] (enum): Support Type Enumeration Type + nodal_supports[i][1] (bool): Support in Z Option + nodal_supports[i][2] (float): Support Spring in Y Coefficient + nodal_supports[i][3] (enum): Eccentricity Type Enumeration Type + nodal_supports[i][4] (float): Eccentricity in Z Direction + nodal_supports[i][5] (float): Restraint Spring About X Coefficient + nodal_supports[i][6] (float): Restraint Spring About Z Coefficient + nodal_supports[i][7] (float): Restraint Spring Warping Coefficient + nodal_supports[i][8] (enum): Support Type in Y Enumeration Type + nodal_supports[i][9] (enum): Restraint Type in X Enumeration Type + nodal_supports[i][10] (enum): Restraint Type in Z Enumeration Type + nodal_supports[i][11] (enum): Restraint Type Warping Enumeration Type + nodal_supports[i][12] (str): Assigned Nodes + + factors (lst): Effective Length Factors + + factors[i][0] (float): Flexural Buckling in U Coefficient + factors[i][1] (float): Flexural Buckling in V Coefficient + factors[i][2] (float): Flexural Buckling in Y Coefficient + factors[i][3] (float): Flexural Buckling in Z Coefficient + factors[i][4] (float): Torsional Buckling Coefficient + factors[i][5] (float): Lateral Torsional Buckling Coefficient + factors[i][6] (float): Lateral Torsional Buckling Top Coefficient + factors[i][7] (float): Lateral Torsional Buckling Bottom Coefficient + factors[i][8] (float): Twist Restraint Coefficient + factors[i][9] (float): Lateral Torsional Restraint Coefficient + factors[i][10] (float): Critical Moment + + intermediate_nodes (bool): Intermediate Nodes Option + different_properties (bool): Different Properties Option + factors_definition_absolute (bool): Absolute Factors Definition Option + import_from_stability_analysis_enabled (bool): Import From Stability Analysis Option + determination_of_mcr (enum): Determination of MCR or CB Enumeration Item + comment (str): Comments + params (dict): Parameters + """ + + # Client Model | Types For Steel Design Effective Lengths + clientObject = Model.clientModel.factory.create('ns0:steel_effective_lengths') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Effective Lengths No. + clientObject.no = no + + # Effective Lengths Assigned Members + clientObject.members = ConvertToDlString(members) + + # Effective Lengths Assigned Member Sets + clientObject.member_sets = ConvertToDlString(member_sets) + + # Effective Lengths Flexural Buckling About Y + clientObject.flexural_buckling_about_y = flexural_buckling_about_y + + # Effective Lengths Flexural Buckling About Z + clientObject.flexural_buckling_about_z = flexural_buckling_about_z + + # Effective Lengths Torsional Buckling + clientObject.torsional_buckling = torsional_buckling + + # Effective Lengths Lateral Torsional Buckling + clientObject.lateral_torsional_buckling = lateral_torsional_buckling + + # Effective Lengths Principal Section Axes + clientObject.principal_section_axes = principal_section_axes + + # Effective Lengths Geometric Section Axes + clientObject.geometric_section_axes = geometric_section_axes + + # Effective Lengths User Defined Name + if user_defined_name[0] == False: + clientObject.user_defined_name_enabled = user_defined_name[0] + else: + clientObject.user_defined_name_enabled = user_defined_name[0] + clientObject.name = user_defined_name[1] + + # Effective Lengths Nodal Supports + clientObject.nodal_supports = Model.clientModel.factory.create('ns0:steel_effective_lengths.nodal_supports') + + for i,j in enumerate(nodal_supports): + mlvlp = Model.clientModel.factory.create('ns0:steel_effective_lengths_nodal_supports') + mlvlp.no = i + mlvlp.support_type = nodal_supports[i][0].name + mlvlp.support_in_z = nodal_supports[i][1] + mlvlp.support_spring_in_y = nodal_supports[i][2] + mlvlp.eccentricity_type = nodal_supports[i][3].name + mlvlp.eccentricity_ez = nodal_supports[i][4] + mlvlp.restraint_spring_about_x = nodal_supports[i][5] + mlvlp.restraint_spring_about_z = nodal_supports[i][6] + mlvlp.restraint_spring_warping = nodal_supports[i][7] + mlvlp.support_in_y_type = nodal_supports[i][8].name + mlvlp.restraint_about_x_type = nodal_supports[i][9].name + mlvlp.restraint_about_z_type = nodal_supports[i][10].name + mlvlp.restraint_warping_type = nodal_supports[i][11].name + mlvlp.nodes = ConvertToDlString(nodal_supports[i][12]) + + clientObject.nodal_supports.steel_effective_lengths_nodal_supports.append(mlvlp) + + # Effective Lengths Factors + clientObject.factors = Model.clientModel.factory.create('ns0:steel_effective_lengths.factors') + + for i,j in enumerate(factors): + mlvlp_f = Model.clientModel.factory.create('ns0:steel_effective_lengths_factors') + mlvlp_f.no = i + mlvlp_f.flexural_buckling_u= factors[i][0] + mlvlp_f.flexural_buckling_v= factors[i][1] + mlvlp_f.flexural_buckling_y= factors[i][2] + mlvlp_f.flexural_buckling_z= factors[i][3] + mlvlp_f.torsional_buckling= factors[i][4] + mlvlp_f.lateral_torsional_buckling= factors[i][5] + mlvlp_f.lateral_torsional_buckling_top= factors[i][6] + mlvlp_f.lateral_torsional_buckling_bottom= factors[i][7] + mlvlp_f.twist_restraint= factors[i][8] + mlvlp_f.lateral_torsional_restraint= factors[i][9] + mlvlp_f.critical_moment= factors[i][10] + + clientObject.factors.steel_effective_lengths_factors.append(mlvlp_f) + + # Effective Lengths Intermediate Points + clientObject.intermediate_nodes = intermediate_nodes + + # Effective Lengths Different Properties + clientObject.different_properties = different_properties + + # Effective Lengths Factors Definition Absolute + clientObject.factors_definition_absolute = factors_definition_absolute + + # Effective Lengths Import From Stability Analysis Enabled + clientObject.import_from_stability_analysis_enabled = import_from_stability_analysis_enabled + + # Effective Lengths Determination MCR Europe + clientObject.determination_mcr_europe = determination_of_mcr.name + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Steel Effective Lengths to client model + Model.clientModel.service.set_steel_effective_lengths(clientObject) diff --git a/package/RFEM/TypesForSurfaces/__init__.py b/package/RFEM/TypesForSurfaces/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesForSurfaces/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/TypesForSurfaces/surfaceEccentricity.py b/package/RFEM/TypesForSurfaces/surfaceEccentricity.py new file mode 100644 index 00000000..9f7b68dc --- /dev/null +++ b/package/RFEM/TypesForSurfaces/surfaceEccentricity.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SurfaceEccentricity(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Surface Eccentricity + clientObject = Model.clientModel.factory.create('ns0:surface_eccentricity') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Eccentricity No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Eccentricity to client model + Model.clientModel.service.set_surface_eccentricity(clientObject) diff --git a/package/RFEM/TypesForSurfaces/surfaceMeshRefinements.py b/package/RFEM/TypesForSurfaces/surfaceMeshRefinements.py new file mode 100644 index 00000000..d1576d5a --- /dev/null +++ b/package/RFEM/TypesForSurfaces/surfaceMeshRefinements.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SurfaceMeshRefinement(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Surface Mesh Refinement + clientObject = Model.clientModel.factory.create('ns0:surface_mesh_refinement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Mesh Refinement No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Mesh Refinement to client model + Model.clientModel.service.set_surface_mesh_refinement(clientObject) diff --git a/package/RFEM/TypesForSurfaces/surfaceStiffnessModification.py b/package/RFEM/TypesForSurfaces/surfaceStiffnessModification.py new file mode 100644 index 00000000..fd23d871 --- /dev/null +++ b/package/RFEM/TypesForSurfaces/surfaceStiffnessModification.py @@ -0,0 +1,26 @@ +from RFEM.initModel import Model, clearAtributes + +class SurfaceStiffnessModification(): + def __init__(self, + no: int = 1, + comment: str = '', + params: dict = {}): + + # Client model | Surface Stifness Modification + clientObject = Model.clientModel.factory.create('ns0:surface_stiffness_modification') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Stifness Modification No. + clientObject.no = no + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Stifness Modification to client model + Model.clientModel.service.set_surface_stiffness_modification(clientObject) diff --git a/package/RFEM/TypesForSurfaces/surfaceSupport.py b/package/RFEM/TypesForSurfaces/surfaceSupport.py new file mode 100644 index 00000000..a64462e3 --- /dev/null +++ b/package/RFEM/TypesForSurfaces/surfaceSupport.py @@ -0,0 +1,42 @@ +from RFEM.initModel import Model, ConvertToDlString, clearAtributes + +class SurfaceSupport(): + def __init__(self, + no: int = 1, + surfaces_no: str = '1', + c_1_x: float = 0.0, + c_1_y: float = 0.0, + c_1_z: float = 0.0, + c_2_x: float = 0.0, + c_2_y: float = 0.0, + comment: str = '', + params: dict = {}): + + # Client model | Surface Support + clientObject = Model.clientModel.factory.create('ns0:surface_support') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Surface Support No. + clientObject.no = no + + # Surface No. (e.g. "5 6 7 12") + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Surface Support Conditions + clientObject.translation_x = c_1_x + clientObject.translation_y = c_1_y + clientObject.translation_z = c_1_z + clientObject.shear_xz = c_2_x + clientObject.shear_yz = c_2_y + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Surface Support to client model + Model.clientModel.service.set_surface_support(clientObject) diff --git a/package/RFEM/TypesforConcreteDesign/ConcreteDurability.py b/package/RFEM/TypesforConcreteDesign/ConcreteDurability.py new file mode 100644 index 00000000..9b6037d5 --- /dev/null +++ b/package/RFEM/TypesforConcreteDesign/ConcreteDurability.py @@ -0,0 +1,173 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import DurabilityStructuralClassType, DurabilityAllowanceDeviationType + +class ConcreteDurability(): + def __init__(self, + no: int = 1, + name: str = "XC 1", + members_no: str = "1", + member_sets_no: str = "1", + surfaces_no: str = "1", + exposure_classes_reinforcement = [True, False, False, False], + exposure_classes_reinforcement_types = [], + exposure_classes_concrete = [False, False, False], + exposure_classes_concrete_types = [], + structural_class = [DurabilityStructuralClassType.STANDARD, False, False, False, False], + stainless_steel_reduction = [False], + additional_protection_reduction = [False], + allowance_deviation = [DurabilityAllowanceDeviationType.STANDARD, False], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Concrete Durability Tag + name (str): User Defined Name + members_no (str): Assigned Members + member_sets_no (str): Assigned Member Sets + surfaces_no (str): Assigned Surfaces + exposure_classes_reinforcement (list): Exposure Classes Reinforcement Parameters + exposure_classes_reinforcement_types (list): Exposure Classes Reinforcement Parameters + exposure_classes_concrete (list): Exposure Classes Concrete Parameters + exposure_classes_concrete_types (list): Exposure Classes Concrete Parameters + structural_class (list): Structural Class Parameters + stainless_steel_reduction (list): Stainless Steel Reduction Parameters + additional_protection_reduction (list): Additional Protection Reduction + allowance_deviation (list): Allowance Deviation Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = Model.clientModel.factory.create('ns0:concrete_durability') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.members = ConvertToDlString(members_no) + + # Assigned Member Sets + clientObject.member_sets = ConvertToDlString(member_sets_no) + + # Assigned Surfaces + clientObject.surfaces = ConvertToDlString(surfaces_no) + + # Exposure Classes for Reinforcement + clientObject.no_risk_of_corrosion_or_attack_enabled = exposure_classes_reinforcement[0] + clientObject.corrosion_induced_by_carbonation_enabled = exposure_classes_reinforcement[1] + clientObject.corrosion_induced_by_chlorides_enabled = exposure_classes_reinforcement[2] + clientObject.corrosion_induced_by_chlorides_from_sea_water_enabled = exposure_classes_reinforcement[3] + + if all(exposure_classes_reinforcement): + raise Exception("WARNING: At least one reinforcement exposure class must be selected.") + + for i in exposure_classes_reinforcement: + if not isinstance(i, bool): + raise Exception('WARNING: The type of parameters should be bool. Kindly check list inputs for completeness and correctness.') + + if exposure_classes_reinforcement[0]: + clientObject.no_risk_of_corrosion_or_attack = "VERY_DRY" + for i in exposure_classes_reinforcement[1:]: + if i: + raise Exception('WARNING: If No Risk of Corrosion is True, other parameters cannot be selected. Kindly check list inputs for completeness and correctness.') + + if exposure_classes_reinforcement[1] : + clientObject.corrosion_induced_by_carbonation = exposure_classes_reinforcement_types[0].name + if exposure_classes_reinforcement[2]: + clientObject.corrosion_induced_by_chlorides = exposure_classes_reinforcement_types[1].name + if exposure_classes_reinforcement[3]: + clientObject.corrosion_induced_by_chlorides_from_sea_water = exposure_classes_reinforcement_types[2].name + + # Exposure Classes for Concrete + for i in exposure_classes_concrete: + if not isinstance(i, bool): + raise Exception('WARNING: The type of parameters should be bool. Kindly check list inputs for completeness and correctness.') + + if exposure_classes_concrete[0]: + clientObject.freeze_thaw_attack_enabled = True + clientObject.freeze_thaw_attack = exposure_classes_concrete_types[0].name + if exposure_classes_concrete[1]: + clientObject.chemical_attack_enabled = True + clientObject.chemical_attack = exposure_classes_concrete_types[1].name + if exposure_classes_concrete[2]: + clientObject.concrete_corrosion_induced_by_wear_enabled = True + clientObject.concrete_corrosion_induced_by_wear = exposure_classes_concrete_types[2].name + + # Structural Class + clientObject.structural_class_type = structural_class[0].name + + if structural_class[0].name == "STANDARD": + for i in structural_class[1:]: + if not isinstance(i, bool): + raise Exception('WARNING: The type of last three parameters should be bool. Kindly check list inputs for completeness and correctness.') + + clientObject.increase_design_working_life_from_50_to_100_years_enabled = structural_class[1] + clientObject.position_of_reinforcement_not_affected_by_construction_process_enabled = structural_class[2] + clientObject.special_quality_control_of_production_enabled = structural_class[3] + clientObject.air_entrainment_of_more_than_4_percent_enabled = structural_class[4] + elif structural_class[0].name == "DEFINED": + clientObject.userdefined_structural_class = structural_class[1].name + + # Stainless Steel Concrete Cover Reduction + clientObject.stainless_steel_enabled = stainless_steel_reduction[0] + + if not isinstance(stainless_steel_reduction[0], bool): + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + if stainless_steel_reduction[0]: + clientObject.stainless_steel_type = stainless_steel_reduction[1].name + + if stainless_steel_reduction[1].name == "DEFINED": + clientObject.stainless_steel_factor = stainless_steel_reduction[2] + + # Additional Protection Concrete Cover Reduction + clientObject.additional_protection_enabled = additional_protection_reduction[0] + + if not isinstance(additional_protection_reduction[0], bool): + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + if additional_protection_reduction[0]: + clientObject.additional_protection_type = additional_protection_reduction[1].name + + if additional_protection_reduction[1].name == "DEFINED": + clientObject.additional_protection_factor = additional_protection_reduction[2] + + # Allowance for Deviation + clientObject.allowance_of_deviation_type = allowance_deviation[0].name + + if allowance_deviation[0].name == "STANDARD": + clientObject.concrete_cast_enabled = allowance_deviation[1] + + if not isinstance(allowance_deviation[1], bool): + raise Exception('WARNING: The type of the second parameter should be bool. Kindly check list inputs for completeness and correctness.') + + if allowance_deviation[1]: + clientObject.concrete_cast = allowance_deviation[2].name + + elif allowance_deviation[0].name == "DEFINED": + clientObject.userdefined_allowance_of_deviation_factor = allowance_deviation[1] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_concrete_durability(clientObject) + + + + + + + + diff --git a/package/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py b/package/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py new file mode 100644 index 00000000..70402855 --- /dev/null +++ b/package/RFEM/TypesforConcreteDesign/ConcreteEffectiveLength.py @@ -0,0 +1,124 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import * + +class ConcreteEffectiveLength(): + def __init__(self, + no: int = 1, + name: str = "EL 1", + members_no: str = "1", + member_sets_no: str = "1", + flexural_buckling_about_y = [True, ConcreteEffectiveLengthAxisY.STRUCTURE_TYPE_UNBRACED], + flexural_buckling_about_z = [True, ConcreteEffectiveLengthsAxisZ.STRUCTURE_TYPE_UNBRACED], + nodal_supports = [[EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, + True, 0, EffectiveLengthEccentricityType.ECCENTRICITY_TYPE_NONE, 0, 0, 0, 0, + SupportStatus.SUPPORT_STATUS_YES, RestraintTypeAboutX.SUPPORT_STATUS_NO, + RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "1"], + [EffectiveLengthSupportType.SUPPORT_TYPE_FIXED_ALL, + True, 0, EffectiveLengthEccentricityType.ECCENTRICITY_TYPE_NONE, 0, 0, 0, 0, + SupportStatus.SUPPORT_STATUS_YES, RestraintTypeAboutX.SUPPORT_STATUS_NO, + RestraintTypeAboutZ.SUPPORT_STATUS_NO, RestraintTypeWarping.SUPPORT_STATUS_NO, "2"]], + factors = [[1, 1]], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Effective Length Tag + name (str): User Defined Name + members_no (str): Assigned Members + member_sets_no (str): Assigned Member Sets + flexural_buckling_about_y (list): Flexural Buckling About Y Option + flexural_buckling_about_z (list): Flexural Buckling About Z Option + nodal_supports (list): Nodal Support Table + factors (list): Factors Table + comment (str, optional): Comments + params (dict, optional): Parameters + + nodal_supports = [[support_type, support_in_z, support_spring_in_y, eccentricity_type, + eccentricity_ez, restraint_spring_about_x, + restraint_spring_about_z, restraint_spring_warping, support_in_y_type, + restraint_about_x_type, restraint_about_z_type, restraint_warping_type, nodes], ...] + + factors = [[flexural_buckling_y, flexural_buckling_z]] + """ + + # Client model | Concrete Durabilities + clientObject = Model.clientModel.factory.create('ns0:concrete_effective_lengths') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Members + clientObject.members = ConvertToDlString(members_no) + + # Assigned Member Sets + clientObject.member_sets = ConvertToDlString(member_sets_no) + + # Flexural Buckling + clientObject.flexural_buckling_about_y = flexural_buckling_about_y[0] + clientObject.structure_type_about_axis_y = flexural_buckling_about_y[1] + + if not isinstance(flexural_buckling_about_y[0], bool): + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + clientObject.flexural_buckling_about_y = flexural_buckling_about_y[0] + clientObject.structure_type_about_axis_y = flexural_buckling_about_y[1].name + + if not isinstance(flexural_buckling_about_z[0], bool): + raise Exception('WARNING: The type of the first parameter should be bool. Kindly check list inputs for completeness and correctness.') + + clientObject.flexural_buckling_about_z = flexural_buckling_about_z[0] + clientObject.structure_type_about_axis_z = flexural_buckling_about_z[1].name + + # Factors + clientObject.factors = Model.clientModel.factory.create('ns0:concrete_effective_lengths.factors') + for i in range(len(factors)): + mlvlp = Model.clientModel.factory.create('ns0:concrete_effective_lengths_factors') + mlvlp.no = i+1 + mlvlp.flexural_buckling_y = factors[i][0] + mlvlp.flexural_buckling_z = factors[i][1] + clientObject.factors.concrete_effective_lengths_factors.append(mlvlp) + + # Nodal Supports + clientObject.nodal_supports = Model.clientModel.factory.create('ns0:concrete_effective_lengths.nodal_supports') + for i in range(len(nodal_supports)): + mlvlp = Model.clientModel.factory.create('ns0:concrete_effective_lengths_nodal_supports') + mlvlp.no = i+1 + mlvlp.support_type = nodal_supports[i][0].name + mlvlp.support_in_z = nodal_supports[i][1] + mlvlp.support_spring_in_y = nodal_supports[i][2] + mlvlp.eccentricity_type = nodal_supports[i][3].name + mlvlp.eccentricity_ez = nodal_supports[i][4] + mlvlp.restraint_spring_about_x = nodal_supports[i][5] + mlvlp.restraint_spring_about_z = nodal_supports[i][6] + mlvlp.restraint_warping_type = nodal_supports[i][7] + mlvlp.support_in_y_type = nodal_supports[i][8].name + mlvlp.restraint_about_x_type = nodal_supports[i][9].name + mlvlp.restraint_about_z_type = nodal_supports[i][10].name + mlvlp.restraint_warping_type = nodal_supports[i][11].name + mlvlp.nodes = nodal_supports[i][12] + clientObject.nodal_supports.concrete_effective_lengths_nodal_supports.append(mlvlp) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_concrete_effective_lengths(clientObject) + + + + + + + + diff --git a/package/RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py b/package/RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py new file mode 100644 index 00000000..ee59d1eb --- /dev/null +++ b/package/RFEM/TypesforConcreteDesign/ConcreteReinforcementDirections.py @@ -0,0 +1,64 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import ReinforcementDirectionType +from math import pi + +class ConcreteReinforcementDirection(): + def __init__(self, + no: int = 1, + name: str = "RD 1", + surfaces = "1", + reinforcement_direction_type = ReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_X, + rotation_parameters = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Reinforcement Direction Tag + name (str): User Defined Name + surfaces (str): Assigned Surfaces + reinforcement_direction_type (enum): Reinforcement Direction Enumeration + rotation_parameters (list): Rotation Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + """ + + # Client model | Concrete Durabilities + clientObject = Model.clientModel.factory.create('ns0:reinforcement_direction') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Reinforcement Direction Type + clientObject.reinforcement_direction_type = reinforcement_direction_type.name + + if reinforcement_direction_type.name == "REINFORCEMENT_DIRECTION_TYPE_ROTATED": + clientObject.first_reinforcement_angle = rotation_parameters[0] * pi/180 + clientObject.second_reinforcement_angle = rotation_parameters[1] * pi/180 + + # Assigned Surfaces + clientObject.surfaces = ConvertToDlString(surfaces) + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_reinforcement_direction(clientObject) + + + + + + + + diff --git a/package/RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py b/package/RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py new file mode 100644 index 00000000..626f7eed --- /dev/null +++ b/package/RFEM/TypesforConcreteDesign/ConcreteSurfaceReinforcements.py @@ -0,0 +1,180 @@ +from RFEM.initModel import Model, clearAtributes, ConvertToDlString +from RFEM.enums import SurfaceReinforcementLocationType, SurfaceReinforcementType, SurfaceReinforcementDirectionType, SurfaceReinforcementDesignDirection +from math import pi + +class ConcreteSurfaceReinforcements(): + def __init__(self, + no: int = 1, + name: str = "RD 1", + surfaces = "1", + material = "2", + location_type = SurfaceReinforcementLocationType.LOCATION_TYPE_ON_SURFACE, + reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_REBARS, + reinforcement_type_parameters = [0.01, 0.15, False], + cover_offset = [True, True, 0, 0], + reinforcement_direction = SurfaceReinforcementDirectionType.REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, + reinforcement_direction_parameters = [SurfaceReinforcementDesignDirection.DESIGN_REINFORCEMENT_DIRECTION_A_S_1], + reinforcement_location = [], + reinforcement_acting_region = [], + comment: str = '', + params: dict = {}): + """ + Args: + no (int): Surface Reinforcement Tag + name (str): User Defined Name + surfaces (str): Assigned Surfaces + material (str): Reinforcement Material + location_type (enum): Location Type Enumeration + reinforcement_type (enum): Reinforcement Type Enumeration + reinforcement_type_parameters (list): Reinforcement Type Parameters + cover_offset (list): Cover Offset Parameters + reinforcement_direction (enum): Reinforcement Direction Enumeration + reinforcement_direction_parameters (list): Reinforcement Direction Parameters + reinforcement_location (list): Reinforcement Location Parameters + reinforcement_acting_region (list): Reinforcement Acting Region Parameters + comment (str, optional): Comments + params (dict, optional): Parameters + + for reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_REBARS: + reinforcement_type_parameters = [rebar_diameter, rebar_spacing, additional_transverse_reinforcement_enabled] + if additional_transverse_reinforcement_enabled == True: + reinforcement_type_parameters = [rebar_diameter, rebar_spacing, additional_transverse_reinforcement_enabled, additional_rebar_diameter, additional_rebar_spacing] + for reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_STIRRUPS: + reinforcement_type_parameters = [stirrup_diameter, stirrup_spacing] + for reinforcement_type = SurfaceReinforcementType.REINFORCEMENT_TYPE_MESH: + reinforcement_type_parameters = [mesh_product_range, mesh_shape, mesh_name] + + cover_offset = [alignment_top_enabled, alignment_bottom_enabled, additional_offset_to_concrete_cover_top, additional_offset_to_concrete_cover_bottom] + """ + + # Client model | Concrete Durabilities + clientObject = Model.clientModel.factory.create('ns0:surface_reinforcement') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Concrete Durability No. + clientObject.no = no + + # User Defined Name + clientObject.user_defined_name_enabled = True + clientObject.name = name + + # Assigned Surfaces + clientObject.surfaces = ConvertToDlString(surfaces) + + # Material + clientObject.material = material + + # Location Type + clientObject.location_type = location_type.name + + # Reinforcement Type + clientObject.reinforcement_type = reinforcement_type.name + if reinforcement_type.name == "REINFORCEMENT_TYPE_REBARS": + clientObject.rebar_diameter = reinforcement_type_parameters[0] + clientObject.rebar_spacing = reinforcement_type_parameters[1] + + clientObject.additional_transverse_reinforcement_enabled = reinforcement_type_parameters[2] + if not isinstance(reinforcement_type_parameters[2], bool): + raise Exception("WARNING: Last parameter should be type bool for cover_offset. Kindly check list inputs completeness and correctness.") + + if reinforcement_type_parameters[2]: + clientObject.additional_rebar_diameter = reinforcement_type_parameters[3] + clientObject.additional_rebar_spacing = reinforcement_type_parameters[4] + elif reinforcement_type.name == "REINFORCEMENT_TYPE_STIRRUPS": + clientObject.stirrup_diameter = reinforcement_type_parameters[0] + clientObject.stirrup_spacing = reinforcement_type_parameters[1] + elif reinforcement_type.name == "REINFORCEMENT_TYPE_MESH": + clientObject.mesh_product_range = reinforcement_type_parameters[0] + clientObject.mesh_shape = reinforcement_type_parameters[1] + clientObject.mesh_name = reinforcement_type_parameters[2] + + # Concrete Cover Assignment + if not isinstance(cover_offset[0], bool) and not isinstance(cover_offset[1], bool): + raise Exception("WARNING: First two parameters should be type bool for cover_offset. Kindly check list inputs completeness and correctness.") + clientObject.alignment_top_enabled = cover_offset[0] + clientObject.alignment_bottom_enabled = cover_offset[1] + + if cover_offset[0]: + clientObject.additional_offset_to_concrete_cover_top = cover_offset[2] + if cover_offset[1]: + clientObject.additional_offset_to_concrete_cover_bottom = cover_offset[3] + + # Reinforcement Direction + if location_type.name == "LOCATION_TYPE_ON_SURFACE": + clientObject.reinforcement_direction_type = reinforcement_direction.name + if reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION": + clientObject.design_reinforcement_direction = reinforcement_direction_parameters[0].name + elif reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS": + clientObject.first_direction_point_1 = reinforcement_direction_parameters[0] + clientObject.first_direction_point_2 = reinforcement_direction_parameters[1] + clientObject.second_direction_point_1 = reinforcement_direction_parameters[2] + clientObject.second_direction_point_2 = reinforcement_direction_parameters[3] + clientObject.projection_coordinate_system = reinforcement_direction_parameters[4] + clientObject.projection_plane = reinforcement_direction_parameters[5].name + else: + clientObject.reinforcement_direction_type = reinforcement_direction.name + if reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION": + clientObject.design_reinforcement_direction = reinforcement_direction_parameters[0].name + clientObject.projection_coordinate_system = reinforcement_direction_parameters[1] + clientObject.projection_plane = reinforcement_direction_parameters[2].name + elif reinforcement_direction.name == "REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS": + clientObject.first_direction_point_1 = reinforcement_direction_parameters[0] + clientObject.first_direction_point_2 = reinforcement_direction_parameters[1] + clientObject.second_direction_point_1 = reinforcement_direction_parameters[2] + clientObject.second_direction_point_2 = reinforcement_direction_parameters[3] + clientObject.projection_coordinate_system = reinforcement_direction_parameters[4] + clientObject.projection_plane = reinforcement_direction_parameters[5].name + + # Reinforcement Location + if location_type.name == "LOCATION_TYPE_FREE_RECTANGULAR": + clientObject.location_rectangle_type = reinforcement_location[0].name + if reinforcement_location[0].name == "RECTANGLE_TYPE_CORNER_POINTS": + clientObject.location_first_x = reinforcement_location[1] + clientObject.location_first_y = reinforcement_location[2] + clientObject.location_second_x = reinforcement_location[3] + clientObject.location_second_y = reinforcement_location[4] + clientObject.location_rotation = reinforcement_location[5]* pi/180 + elif reinforcement_location[0].name == "RECTANGLE_TYPE_CENTER_AND_SIDES": + clientObject.location_center_x = reinforcement_location[1] + clientObject.location_center_y = reinforcement_location[2] + clientObject.location_center_side_a = reinforcement_location[3] + clientObject.location_center_side_b = reinforcement_location[4] + clientObject.location_rotation = reinforcement_location[5] * pi/180 + elif location_type.name == "LOCATION_TYPE_FREE_CIRCULAR": + clientObject.location_center_x = reinforcement_location[0] + clientObject.location_center_y = reinforcement_location[1] + clientObject.location_radius = reinforcement_location[2] + elif location_type.name == "LOCATION_TYPE_FREE_POLYGON": + clientObject.polygon_points = Model.clientModel.factory.create('ns0:surface_reinforcement.polygon_points') + for i in range(len(reinforcement_location)): + mlvlp = Model.clientModel.factory.create('ns0:surface_reinforcement_polygon_points') + mlvlp.no = i+1 + mlvlp.first_coordinate = reinforcement_location[i][0] + mlvlp.second_coordinate = reinforcement_location[i][1] + mlvlp.comment = reinforcement_location[i][2] + clientObject.polygon_points.surface_reinforcement_polygon_points.append(mlvlp) + + # Reinforcement Acting Region + if location_type.name != "LOCATION_TYPE_ON_SURFACE": + clientObject.acting_region_from = reinforcement_acting_region[0] + clientObject.acting_region_to = reinforcement_acting_region[1] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_surface_reinforcement(clientObject) + + + + + + + + diff --git a/package/RFEM/TypesforConcreteDesign/__init__.py b/package/RFEM/TypesforConcreteDesign/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/TypesforConcreteDesign/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/__init__.py b/package/RFEM/__init__.py new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/package/RFEM/__init__.py @@ -0,0 +1 @@ + diff --git a/package/RFEM/baseSettings.py b/package/RFEM/baseSettings.py new file mode 100644 index 00000000..fe8f9f77 --- /dev/null +++ b/package/RFEM/baseSettings.py @@ -0,0 +1,54 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import GlobalAxesOrientationType, LocalAxesOrientationType + +class BaseSettings(): + def __init__(self, + gravitational_acceleration: int = 10, + global_axes_orientation = GlobalAxesOrientationType.E_GLOBAL_AXES_ORIENTATION_ZDOWN, + local_axes_orientation = LocalAxesOrientationType.E_LOCAL_AXES_ORIENTATION_ZDOWN, + tolerances = [0.0005, 0.0005, 0.0005, 0.0005], + member_representatives: bool = False, + member_set_representatives: bool = False): + """ + Args: + gravitational_acceleration (int): Gravitational Acceleration (m/sn2) + global_axes_orientation (enum): Global Axes Orientation Enumeration + local_axes_orientation (Enum): Local Axes Orientation Enumeration + tolerances (list): Tolerances + member_representatives (bool): Member Representatives + member_set_representatives (bool): Member Set Representatives + + tolerances = [tolerance_for_nodes, tolerance_for_lines, tolerance_for_surfaces_and_planes, tolerance_for_directions] + """ + # Client model | Load Case + clientObject = Model.clientModel.factory.create('ns0:model_settings_and_options_type') + + # Clears object atributes | Sets all atributes to None + clearAtributes(clientObject) + + # Gravitational Acceleration + clientObject.gravitational_acceleration = gravitational_acceleration + + # Global Axes Orientation + clientObject.global_axes_orientation = global_axes_orientation.name + + # Local Axes Orientation + clientObject.local_axes_orientation = local_axes_orientation.name + + # Tolerances + if len(tolerances) != 4: + raise Exception("WARNING:Expected size of the array. Kindly check the list correctness.") + + clientObject.tolerance_for_nodes = tolerances[0] + clientObject.tolerance_for_lines = tolerances[1] + clientObject.tolerance_for_surfaces_and_planes = tolerances[2] + clientObject.tolerance_for_directions = tolerances[3] + + # Member Representatives + clientObject.member_representatives_active = member_representatives + + # Member Set Representatives + clientObject.member_set_representatives_active = member_set_representatives + + # Add Base Data Settings to client model + Model.clientModel.service.set_model_settings_and_options(clientObject) diff --git a/package/RFEM/dataTypes.py b/package/RFEM/dataTypes.py new file mode 100644 index 00000000..16d0074d --- /dev/null +++ b/package/RFEM/dataTypes.py @@ -0,0 +1,3 @@ +# Specific data types + +inf = float('inf') diff --git a/package/RFEM/enums.py b/package/RFEM/enums.py new file mode 100644 index 00000000..25fa3f98 --- /dev/null +++ b/package/RFEM/enums.py @@ -0,0 +1,1380 @@ +from enum import Enum + +class MemberType(Enum): + ''' + Member Type + ''' + TYPE_BEAM, TYPE_BUCKLING, TYPE_CABLE, TYPE_COMPRESSION, TYPE_COUPLING_HINGE_HINGE,\ + TYPE_COUPLING_HINGE_RIGID, TYPE_COUPLING_RIGID_HINGE, TYPE_COUPLING_RIGID_RIGID,\ + TYPE_DEFINABLE_STIFFNESS, TYPE_RIB, TYPE_RIGID, TYPE_TENSION, TYPE_TRUSS, TYPE_TRUSS_ONLY_N, TYPE_RESULT_BEAM = range(15) + +class NodalSupportType(Enum): + ''' + Nodal Support Type + ''' + FIXED, HINGED, ROLLER, ROLLER_IN_X, ROLLER_IN_Y, ROLLER_IN_Z, FREE = range(7) + +class LineSupportType(Enum): + ''' + Nodal Support Type + ''' + FIXED, HINGED, SLIDING_IN_X_AND_Y, SLIDING_IN_X, SLIDING_IN_Y, SLIDING_IN_Z, FREE = range(7) + +class LineWeldedJointType(Enum): + """ + Line Welded Joint Type | Enum + """ + BUTT_JOINT, CORNER_JOINT, LAP_JOINT, TEE_JOINT = range(4) + +class WeldType(Enum): + """ + Welded Type | Enum + """ + WELD_BEVEL_AND_FILLET, WELD_DOUBLE_BEVEL, WELD_DOUBLE_FILLET, WELD_DOUBLE_J,\ + WELD_DOUBLE_SQUARE, WELD_DOUBLE_U, WELD_DOUBLE_V, WELD_J_AND_FILLET, WELD_SINGLE_BEVEL,\ + WELD_SINGLE_FILLET, WELD_SINGLE_J, WELD_SINGLE_SQUARE, WELD_SINGLE_U, WELD_SINGLE_V, WELD_V_AND_FILLET = range(15) + +class WeldLongitudalArrangement(Enum): + """ + Weld Longitudat Arrangement Type | Enum + """ + CHAIN_INTERMITTENT, CONTINUOUS, STAGGERED_INTERMITTENT = range(3) + +class LineMeshRefinementsType(Enum): + """ + Line Mesh Refinements Type | Enum + """ + TYPE_LENGTH, TYPE_ELEMENTS, TYPE_GRADUAL = range(3) + +class StaticAnalysisType(Enum): + ''' + Static Analysis Type + ''' + GEOMETRICALLY_LINEAR, LARGE_DEFORMATIONS, LARGE_DEFORMATIONS_POSTRCRITICAL, SECOND_ORDER_P_DELTA = range(4) + +class StaticAnalysisSettingsIterativeMethodForNonlinearAnalysis(Enum): + ''' + Static Analysis Settings Iterative Method For Nonlinear Analysis | Enum + ''' + DYNAMIC_RELAXATION, NEWTON_RAPHSON, NEWTON_RAPHSON_COMBINED_WITH_PICARD, NEWTON_RAPHSON_WITH_CONSTANT_STIFFNESS,\ + NEWTON_RAPHSON_WITH_POSTCRITICAL_ANALYSIS, PICARD = range(6) + + +class StaticAnalysisSettingsMethodOfEquationSystem(Enum): + ''' + Static Analysis Settings Method of Equation System | Enum + ''' + METHOD_OF_EQUATION_SYSTEM_DIRECT, METHOD_OF_EQUATION_SYSTEM_ITERATIVE = range(2) + + +class StaticAnalysisSettingsPlateBendingTheory(Enum): + ''' + Static Analysis Settings Plate Bending Theory | Enum + ''' + PLATE_BENDING_THEORY_MINDLIN, PLATE_BENDING_THEORY_KIRCHHOFF = range(2) + +class AnalysisType(Enum): + ''' + Analysis Type + ''' + ANALYSIS_TYPE_CREEP_AND_SHRINKAGE, ANALYSIS_TYPE_CUTTING_PATTERN, ANALYSIS_TYPE_MODAL, ANALYSIS_TYPE_RESPONSE_SPECTRUM,\ + ANALYSIS_TYPE_STATIC, ANALYSIS_TYPE_TIME_DEPENDENT, ANALYSIS_TYPE_TIME_HISTORY, ANALYSIS_TYPE_WIND_SIMULATION = range(8) + +class LoadDirectionType(Enum): + ''' + Load Direction Type + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W,\ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z = range(6) + +class MemberLoadDirection(Enum): + ''' + Member Load Direction + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_PROJECTED, LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE,\ + LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE,\ + LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,\ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_PRINCIPAL_U,\ + LOAD_DIRECTION_PRINCIPAL_V = range(11) + +class MemberLoadType(Enum): + ''' + Member Load Type + ''' + E_TYPE_MASS, LOAD_TYPE_AXIAL_DISPLACEMENT, LOAD_TYPE_AXIAL_STRAIN, LOAD_TYPE_DISPLACEMENT, LOAD_TYPE_FORCE,\ + LOAD_TYPE_FORM_FINDING, LOAD_TYPE_INITIAL_PRESTRESS, LOAD_TYPE_MOMENT, LOAD_TYPE_PIPE_CONTENT_FULL,\ + LOAD_TYPE_PIPE_CONTENT_PARTIAL, LOAD_TYPE_PIPE_INTERNAL_PRESSURE, LOAD_TYPE_PRECAMBER, LOAD_TYPE_ROTARY_MOTION,\ + LOAD_TYPE_ROTATION, LOAD_TYPE_TEMPERATURE, LOAD_TYPE_TEMPERATURE_CHANGE = range(16) + +class MemberLoadDistribution(Enum): + ''' + Member Load Distribution + ''' + LOAD_DISTRIBUTION_CONCENTRATED_1, LOAD_DISTRIBUTION_CONCENTRATED_2, LOAD_DISTRIBUTION_CONCENTRATED_2x2,\ + LOAD_DISTRIBUTION_CONCENTRATED_N, LOAD_DISTRIBUTION_CONCENTRATED_VARYING, LOAD_DISTRIBUTION_PARABOLIC,\ + LOAD_DISTRIBUTION_TAPERED, LOAD_DISTRIBUTION_TRAPEZOIDAL, LOAD_DISTRIBUTION_UNIFORM, LOAD_DISTRIBUTION_UNIFORM_TOTAL,\ + LOAD_DISTRIBUTION_VARYING, LOAD_DISTRIBUTION_VARYING_IN_Z = range(12) + +class MemberHingeAxialRelease(Enum): + ''' + Member Hinge Axial Release + ''' + NONLINEARITY_TYPE_DIAGRAM, NONLINEARITY_TYPE_FAILURE_ALL_IF_NEGATIVE, NONLINEARITY_TYPE_FAILURE_ALL_IF_POSITIVE,\ + NONLINEARITY_TYPE_FAILURE_IF_NEGATIVE, NONLINEARITY_TYPE_FAILURE_IF_POSITIVE, NONLINEARITY_TYPE_FRICTION_DIRECTION_1,\ + NONLINEARITY_TYPE_FRICTION_DIRECTION_1_2, NONLINEARITY_TYPE_FRICTION_DIRECTION_1_PLUS_2, NONLINEARITY_TYPE_FRICTION_DIRECTION_2,\ + NONLINEARITY_TYPE_NONE, NONLINEARITY_TYPE_PARTIAL_ACTIVITY, NONLINEARITY_TYPE_STIFFNESS_DIAGRAM = range(12) + +class LineLoadType(Enum): + ''' + Line Load Type + ''' + E_TYPE_MASS, LOAD_TYPE_FORCE, LOAD_TYPE_MOMENT = range(3) + +class LineLoadDistribution(Enum): + ''' + Line Load Distribution + ''' + LOAD_DISTRIBUTION_CONCENTRATED_1, LOAD_DISTRIBUTION_CONCENTRATED_2, LOAD_DISTRIBUTION_CONCENTRATED_2x2,\ + LOAD_DISTRIBUTION_CONCENTRATED_N, LOAD_DISTRIBUTION_CONCENTRATED_VARYING, LOAD_DISTRIBUTION_PARABOLIC,\ + LOAD_DISTRIBUTION_TAPERED, LOAD_DISTRIBUTION_TRAPEZOIDAL, LOAD_DISTRIBUTION_UNIFORM, LOAD_DISTRIBUTION_UNIFORM_TOTAL,\ + LOAD_DISTRIBUTION_VARYING = range(11) + +class SurfaceGeometry(Enum): + ''' + Geometry Type + ''' + GEOMETRY_PLANE, GEOMETRY_QUADRANGLE, GEOMETRY_NURBS, GEOMETRY_ROTATED, GEOMETRY_PIPE = range(5) + +class SurfaceType(Enum): + ''' + Stiffness Type + ''' + TYPE_LOAD_TRANSFER, TYPE_MEMBRANE, TYPE_RIGID, TYPE_STANDARD, TYPE_WITHOUT_MEMBRANE_TENSION, TYPE_WITHOUT_THICKNESS = range(6) + +class SurfaceLoadDistribution(Enum): + ''' + Surface Load Distribution + ''' + LOAD_DISTRIBUTION_LINEAR, LOAD_DISTRIBUTION_LINEAR_IN_X, LOAD_DISTRIBUTION_LINEAR_IN_Y, LOAD_DISTRIBUTION_LINEAR_IN_Z,\ + LOAD_DISTRIBUTION_RADIAL, LOAD_DISTRIBUTION_UNIFORM, LOAD_DISTRIBUTION_VARYING_IN_Z = range(7) + +class SurfaceLoadDirection(Enum): + ''' + Surface Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_PROJECTED, LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE,\ + LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE,\ + LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,\ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z = range(9) + +class SurfaceLoadType(Enum): + ''' + Surface Load Type | Enum + ''' + LOAD_TYPE_AXIAL_STRAIN, LOAD_TYPE_FORCE, LOAD_TYPE_FORM_FINDING, LOAD_TYPE_MASS, LOAD_TYPE_PRECAMBER,\ + LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_TEMPERATURE = range(7) + +class SurfaceLoadDistributionDirection(Enum): + ''' + Surface Load Distribution Direction + ''' + LOAD_TRANSFER_DIRECTION_IN_BOTH, LOAD_TRANSFER_DIRECTION_IN_X, LOAD_TRANSFER_DIRECTION_IN_Y = range(3) + #LOAD_DISTRIBUTION_DIRECTION_IN_BOTH, LOAD_DISTRIBUTION_DIRECTION_IN_X, LOAD_DISTRIBUTION_DIRECTION_IN_Y = range(3) + +class SetType(Enum): + ''' + Line, Member, Surface, and Solid Set Type + ''' + SET_TYPE_CONTINUOUS, SET_TYPE_GROUP = range(2) + +class NodalLoadType(Enum): + ''' + Nodal Load Type + ''' + LOAD_TYPE_COMPONENTS, LOAD_TYPE_FORCE, LOAD_TYPE_MASS, LOAD_TYPE_MOMENT = range(4) + +class NodalLoadSpecificDirectionType(Enum): + ''' + Nodal Load Specific Direction Type + ''' + DIRECTION_TYPE_DIRECTED_TO_NODE, DIRECTION_TYPE_PARALLEL_TO_CS_OF_LINE, DIRECTION_TYPE_PARALLEL_TO_CS_OF_MEMBER, DIRECTION_TYPE_PARALLEL_TO_TWO_NODES, DIRECTION_TYPE_ROTATED_VIA_3_ANGLES = range(5) + +class NodalLoadAxesSequence(Enum): + ''' + Nodal Load Axes Sequence + ''' + SEQUENCE_XYZ, SEQUENCE_XZY, SEQUENCE_YXZ, SEQUENCE_YZX, SEQUENCE_ZXY, SEQUENCE_ZYX = range(6) + +class NodalLoadMassAxisRotation(Enum): + ''' + Nodal Load Mass Axis Rotation + ''' + + AXIS_OF_ROTATION_X_NEGATIVE, AXIS_OF_ROTATION_X_POSITIVE, AXIS_OF_ROTATION_Y_NEGATIVE, AXIS_OF_ROTATION_Y_POSITIVE, AXIS_OF_ROTATION_Z_NEGATIVE, AXIS_OF_ROTATION_Z_POSITIVE = range(6) + +class ThicknessType(Enum): + ''' + Thickness Type + ''' + TYPE_LAYERS, TYPE_SHAPE_ORTHOTROPY, TYPE_STIFFNESS_MATRIX, TYPE_THICKNESS_PHASE, TYPE_UNIFORM,\ + TYPE_VARIABLE_CIRCLE, TYPE_VARIABLE_FOUR_SURFACE_CORNERS, TYPE_VARIABLE_THREE_NODES, \ + TYPE_VARIABLE_TWO_NODES_AND_DIRECTION = range(9) + +class ThicknessDirection(Enum): + ''' + Thickness Direction + ''' + THICKNESS_DIRECTION_IN_SMALL_X, THICKNESS_DIRECTION_IN_SMALL_Y, THICKNESS_DIRECTION_IN_X, \ + THICKNESS_DIRECTION_IN_Y, THICKNESS_DIRECTION_IN_Z = range(5) + +class ThicknessSelfWeightDefinitionType(Enum): + SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, \ + SELF_WEIGHT_DEFINED_VIA_WEIGHT = range(3) + +class ThicknessShapeOrthotropySelfWeightDefinitionType(Enum): + ''' + Thickness Shape Orthotropy Self Weight Definition Type | Enum + ''' + SELF_WEIGHT_COMPUTED_FROM_PARAMETERS, SELF_WEIGHT_DEFINED_VIA_FICTITIOUS_THICKNESS, \ + SELF_WEIGHT_DEFINED_VIA_WEIGHT = range(3) + +class ThicknessStiffnessMatrixSelfWeightDefinitionType(Enum): + ''' + Thickness Stiffness Matrix Self Weight Definition Type | Enum + ''' + SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_BULK_DENSITY_AND_AREA_DENSITY, \ + SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_AREA_DENSITY, \ + SELF_WEIGHT_DEFINITION_TYPE_DEFINED_VIA_FICTITIOUS_THICKNESS_AND_BULK_DENSITY = range(3) + +class ThicknessOrthotropyType(Enum): + BIDIRECTIONAL_RIBBED_PLATE, COUPLING, EFFECTIVE_THICKNESS, GRILLAGE, \ + HOLLOW_CORE_SLAB, TRAPEZOIDAL_SHEET, UNIDIRECTIONAL_RIBBED_PLATE = range(7) + +class LineLoadDirection(Enum): + ''' + Line Load Direction + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_PROJECTED, LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE,\ + LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE,\ + LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,\ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z = range(9) + + +class MemberLoadEccentricityHorizontalAlignment(Enum): + ''' + Member Load Eccentricity Horizontal Alignment + ''' + + ALIGN_LEFT, ALIGN_MIDDLE, ALIGN_NONE, ALIGN_TOP = range(4) + +class MemberLoadEccentricityVerticalAlignment(Enum): + ''' + Member Load Eccentricity Vertical Alignment + ''' + + ALIGN_LEFT, ALIGN_MIDDLE, ALIGN_NONE, ALIGN_TOP = range(4) + +class MemberLoadEccentricitySectionMiddle(Enum): + ''' + Member Load Eccentricity Section Middle + ''' + + LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, LOAD_ECCENTRICITY_SECTION_MIDDLE_NONE, LOAD_ECCENTRICITY_SECTION_MIDDLE_SHEAR_CENTER = range(3) + +class MemberLoadFormFindingDefinitionType(Enum): + ''' + Member Load Form Finding Definition Type + ''' + FORM_FINDING_TYPE_FORCE, FORM_FINDING_TYPE_GEOMETRIC = range(2) + +class MemberLoadFormFindingForceDefinition(Enum): + ''' + Member Load Form Finding Force Definition + ''' + FORM_FINDING_FORCE_INPUT_PARAMETER_AVERAGE, FORM_FINDING_FORCE_INPUT_PARAMETER_DENSITY, FORM_FINDING_FORCE_INPUT_PARAMETER_HORIZONTAL_TENSION_COMPONENT, \ + FORM_FINDING_FORCE_INPUT_PARAMETER_MAXIMUM_FORCE_IN_MEMBER, FORM_FINDING_FORCE_INPUT_PARAMETER_MINIMAL_TENSION_AT_I_END, \ + FORM_FINDING_FORCE_INPUT_PARAMETER_MINIMAL_TENSION_AT_J_END, FORM_FINDING_FORCE_INPUT_PARAMETER_MINIMUM_FORCE_IN_MEMBER,\ + FORM_FINDING_FORCE_INPUT_PARAMETER_TENSION_AT_I_END, FORM_FINDING_FORCE_INPUT_PARAMETER_TENSION_AT_J_END = range(9) + +class MemberLoadFormFindingGeometryDefinition(Enum): + ''' + Member Load Form Finding Geometry Definition + ''' + FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_LENGTH, FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_LOW_POINT_VERTICAL_SAG, \ + FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_MAXIMUM_VERTICAL_SAG, FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_SAG, \ + FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_UNSTRESSED_LENGTH = range(5) + +class MemberLoadFormFindingInternalForce(Enum): + ''' + Member Load Form Finding Internal Force + ''' + FORM_FINDING_INTERNAL_FORCE_COMPRESSION, FORM_FINDING_INTERNAL_FORCE_TENSION = range(2) + +class MemberLoadDirectionOrientation(Enum): + ''' + Member Load Direction Orientation + ''' + LOAD_DIRECTION_FORWARD, LOAD_DIRECTION_REVERSED = range(2) + +class MemberLoadAxisDefinitionType(Enum): + ''' + Member Load Axis Definition + ''' + AXIS_DEFINITION_POINT_AND_AXIS, AXIS_DEFINITION_TWO_POINTS = range(2) + +class MemberLoadAxisDefinition(Enum): + ''' + Member Load Axis Definition + ''' + AXIS_X, AXIS_Y, AXIS_Z = range(3) + +class MemberLoadAxisDefinitionAxisOrientation(Enum): + ''' + Member Load Axis Definition Axis Orientation + ''' + AXIS_NEGATIVE, AXIS_POSITIVE = range(2) + +class SurfaceLoadAxisDefinitionAxis(Enum): + ''' + Surface Load Axis Definition Axis + ''' + AXIS_X, AXIS_Y, AXIS_Z = range(3) + +class SurfaceLoadAxisDirectionType(Enum): + ''' + Surface Load Axis Direction Type + ''' + AXIS_NEGATIVE, AXIS_POSITIVE = range(2) + +class SurfaceLoadAxisDefinitionType(Enum): + ''' + Surface Load Axis Definition Type + ''' + AXIS_DEFINITION_POINT_AND_AXIS, AXIS_DEFINITION_TWO_POINTS = range(2) + +class SurfaceLoadDirection(Enum): + ''' + Surface Load Load Direction + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_PROJECTED, LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE,\ + LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE, LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z = range(9) + +class SurfaceLoadType(Enum): + ''' + Surface Load Type + ''' + LOAD_TYPE_AXIAL_STRAIN, LOAD_TYPE_FORCE, LOAD_TYPE_FORM_FINDING, LOAD_TYPE_MASS, LOAD_TYPE_PRECAMBER, LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_TEMPERATURE = range(7) + +class NodeType(Enum): + ''' + Node Type | Enum + ''' + TYPE_BETWEEN_TWO_NODES, TYPE_BETWEEN_TWO_POINTS, TYPE_ON_LINE, TYPE_ON_MEMBER, TYPE_STANDARD = range (5) + +class NodeCoordinateSystemType(Enum): + ''' + Node Coordinate System Type | Enum + ''' + COORDINATE_SYSTEM_CARTESIAN, COORDINATE_SYSTEM_POLAR, COORDINATE_SYSTEM_X_CYLINDRICAL, COORDINATE_SYSTEM_Y_CYLINDRICAL, COORDINATE_SYSTEM_Z_CYLINDRICAL = range (5) + +class NodeReferenceType(Enum): + ''' + Node Reference Type| Enum + ''' + REFERENCE_TYPE_L, REFERENCE_TYPE_XY, REFERENCE_TYPE_XZ, REFERENCE_TYPE_YZ = range (4) + +class LineArcAlphaAdjustmentTarget(Enum): + ''' + Line Arc Alpha Adjustment Target | Enum + ''' + ALPHA_ADJUSTMENT_TARGET_ARC_CONTROL_POINT, ALPHA_ADJUSTMENT_TARGET_BEGINNING_OF_ARC, \ + ALPHA_ADJUSTMENT_TARGET_END_OF_ARC = range(3) +class MemberSetLoadType(Enum): + ''' + Member Set Load Load Type + ''' + E_TYPE_MASS, LOAD_TYPE_AXIAL_DISPLACEMENT, LOAD_TYPE_AXIAL_STRAIN, LOAD_TYPE_DISPLACEMENT, \ + LOAD_TYPE_FORCE, LOAD_TYPE_FORM_FINDING, LOAD_TYPE_INITIAL_PRESTRESS, LOAD_TYPE_MOMENT, \ + LOAD_TYPE_PIPE_CONTENT_FULL, LOAD_TYPE_PIPE_CONTENT_PARTIAL, LOAD_TYPE_PIPE_INTERNAL_PRESSURE, \ + LOAD_TYPE_PRECAMBER, LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_ROTATION, LOAD_TYPE_TEMPERATURE, LOAD_TYPE_TEMPERATURE_CHANGE = range(16) + +class MemberSetLoadDistribution(Enum): + ''' + Member Set Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_CONCENTRATED_1, LOAD_DISTRIBUTION_CONCENTRATED_2, LOAD_DISTRIBUTION_CONCENTRATED_2x2,\ + LOAD_DISTRIBUTION_CONCENTRATED_N, LOAD_DISTRIBUTION_CONCENTRATED_VARYING, LOAD_DISTRIBUTION_PARABOLIC,\ + LOAD_DISTRIBUTION_TAPERED, LOAD_DISTRIBUTION_TRAPEZOIDAL, LOAD_DISTRIBUTION_UNIFORM, LOAD_DISTRIBUTION_UNIFORM_TOTAL,\ + LOAD_DISTRIBUTION_VARYING, LOAD_DISTRIBUTION_VARYING_IN_Z = range(12) + +class MemberSetLoadDirection(Enum): + ''' + Member Set Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_PROJECTED, LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE,\ + LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE,\ + LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,\ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_PRINCIPAL_U,\ + LOAD_DIRECTION_PRINCIPAL_V = range(11) + +class MemberSetLoadDirectionOrientation(Enum): + ''' + Member Set Load Direction Orientation + ''' + LOAD_DIRECTION_FORWARD, LOAD_DIRECTION_REVERSED = range(2) + +class MemberSetLoadFormFindingDefinitionType(Enum): + ''' + Member Set Load Form Finding Definition Type + ''' + FORM_FINDING_TYPE_FORCE, FORM_FINDING_TYPE_GEOMETRIC = range(2) + +class MemberSetLoadAxisDefinitionType(Enum): + ''' + Member Set Load Axis Definition + ''' + AXIS_DEFINITION_POINT_AND_AXIS, AXIS_DEFINITION_TWO_POINTS = range(2) + +class MemberSetLoadAxisDefinition(Enum): + ''' + Member Set Load Axis Definition + ''' + AXIS_X, AXIS_Y, AXIS_Z = range(3) + +class MemberSetLoadAxisDefinitionAxisOrientation(Enum): + ''' + Member Set Load Axis Definition Axis Orientation + ''' + AXIS_NEGATIVE, AXIS_POSITIVE = range(2) + +class MemberSetLoadEccentricityHorizontalAlignment(Enum): + ''' + Member Set Load Eccentricity Horizontal Alignment + ''' + ALIGN_LEFT, ALIGN_MIDDLE, ALIGN_NONE, ALIGN_RIGHT = range(4) + +class MemberSetLoadEccentricityVerticalAlignment(Enum): + ''' + Member Set Load Eccentricity Vertical Alignment + ''' + ALIGN_LEFT, ALIGN_MIDDLE, ALIGN_NONE, ALIGN_TOP = range(4) + +class MemberSetLoadEccentricitySectionMiddle(Enum): + ''' + Member Set Load Eccentricity Section Middle + ''' + LOAD_ECCENTRICITY_SECTION_MIDDLE_CENTER_OF_GRAVITY, LOAD_ECCENTRICITY_SECTION_MIDDLE_NONE, LOAD_ECCENTRICITY_SECTION_MIDDLE_SHEAR_CENTER = range(3) + +class MemberSetLoadFormFindingInternalForce(Enum): + ''' + Member Set Load Form Finding Internal Force + ''' + FORM_FINDING_INTERNAL_FORCE_COMPRESSION, FORM_FINDING_INTERNAL_FORCE_TENSION = range(2) + +class MemberSetLoadFormFindingGeometryDefinition(Enum): + ''' + Member Set Load Form Finding Geometry Definition + ''' + FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_LENGTH, FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_LOW_POINT_VERTICAL_SAG, FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_MAXIMUM_VERTICAL_SAG, \ + FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_SAG, FORM_FINDING_GEOMETRIC_INPUT_PARAMETER_UNSTRESSED_LENGTH = range(5) + +class MemberSetLoadFormFindingForceDefinition(Enum): + ''' + Member Set Load Form Finding Force Definition + ''' + FORM_FINDING_FORCE_INPUT_PARAMETER_AVERAGE, FORM_FINDING_FORCE_INPUT_PARAMETER_DENSITY, FORM_FINDING_FORCE_INPUT_PARAMETER_HORIZONTAL_TENSION_COMPONENT, \ + FORM_FINDING_FORCE_INPUT_PARAMETER_MAXIMUM_FORCE_IN_MEMBER, FORM_FINDING_FORCE_INPUT_PARAMETER_MINIMAL_TENSION_AT_I_END, FORM_FINDING_FORCE_INPUT_PARAMETER_MINIMAL_TENSION_AT_J_END, \ + FORM_FINDING_FORCE_INPUT_PARAMETER_MINIMUM_FORCE_IN_MEMBER, FORM_FINDING_FORCE_INPUT_PARAMETER_TENSION_AT_I_END, FORM_FINDING_FORCE_INPUT_PARAMETER_TENSION_AT_J_END = range(9) + +class SurfaceSetLoadType(Enum): + ''' + Surface Set Load Load Type + ''' + LOAD_TYPE_AXIAL_STRAIN, LOAD_TYPE_FORCE, LOAD_TYPE_FORM_FINDING, LOAD_TYPE_MASS, LOAD_TYPE_PRECAMBER,\ + LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_TEMPERATURE = range(7) + +class SurfaceSetLoadDistribution(Enum): + ''' + Surface Set Load Load Distribution + ''' + LOAD_DISTRIBUTION_LINEAR, LOAD_DISTRIBUTION_LINEAR_IN_X, LOAD_DISTRIBUTION_LINEAR_IN_Y, LOAD_DISTRIBUTION_LINEAR_IN_Z,\ + LOAD_DISTRIBUTION_RADIAL, LOAD_DISTRIBUTION_UNIFORM, LOAD_DISTRIBUTION_VARYING_IN_Z = range(7) + +class SurfaceSetLoadDirection(Enum): + ''' + Surface Set Load Direction + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_PROJECTED, LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE,\ + LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE,\ + LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE,\ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z = range(9) + +class SurfaceSetLoadAxisDefinitionType(Enum): + ''' + Surface Set Load Axis Definiton Type + ''' + AXIS_DEFINITION_POINT_AND_AXIS, AXIS_DEFINITION_TWO_POINTS = range(2) + +class SurfaceSetLoadAxisDefinitionAxis(Enum): + ''' + Surface Set Load Axis Definition Axis + ''' + AXIS_X, AXIS_Y, AXIS_Z = range(3) + +class SurfaceSetLoadAxisDefinitionAxisOrientation(Enum): + ''' + Surface Set Load Axis Definition Axis Orientation + ''' + AXIS_NEGATIVE, AXIS_POSITIVE = range(2) + +class SurfaceSetLoadFormFindingDefinition(Enum): + ''' + Surface Set Load Form Finding Definition + ''' + FORM_FINDING_DEFINITION_FORCE, FORM_FINDING_DEFINITION_STRESS = range(2) + +class SurfaceSetLoadFormFindingCalculationMethod(Enum): + ''' + Surface Set Load Form Finding Calculation Method + ''' + FORM_FINDING_CALCULATION_METHOD_PROJECTION, FORM_FINDING_CALCULATION_METHOD_STANDARD = range(2) + +class GlobalParameterUnitGroup(Enum): + ''' + Global Parameter Unit Group | Enum + ''' + ANGLE, AREA, DENSITY, DIMENSIONLESS, DYNAMIC_INCREASE_FACTOR, EG_MODULE, FRICTION_COEFFICIENT, \ + GEOGRAPHIC_COORDINATES, GRAVITATIONAL_ACCELERATION, LENGTH, LOADS_ANGULAR_ACCELERATION, LOADS_ANGULAR_VELOCITY, \ + LOADS_AREA_MASS, LOADS_AXIAL_STRAIN, LOADS_DENSITY, LOADS_DISPLACEMENT, LOADS_DISPLACEMENT_PER_UNIT_LENGTH, \ + LOADS_FORCE, LOADS_FORCE_PER_UNIT_LENGTH, LOADS_IMPOSED_DISPLACEMENT, LOADS_IMPOSED_ROTATION, LOADS_KINEMATIC_VISCOSITY, \ + LOADS_KINETIC_ENERGY, LOADS_LENGTH, LOADS_MASS, LOADS_MOMENT, LOADS_MOMENT_PER_UNIT_LENGTH, LOADS_PRECAMBER, \ + LOADS_PRESSURE, LOADS_RELATIVE_LENGTH, LOADS_ROTATION, LOADS_ROTATION_PER_UNIT_LENGTH, LOADS_SOLID_TYPE_LOAD, \ + LOADS_SPECIFIC_ENERGY, LOADS_SURFACE_TYPE_LOAD, LOADS_TEMPERATURE, LOADS_TEMPERATURE_CHANGE, LOADS_VELOCITY, \ + MASS, MASS_MOMENT_PER_UNIT_AREA, MATERIAL_ANGLE, MATERIAL_DEFORMATION, MATERIAL_FACTOR, MATERIAL_QUANTITY_INTEGER, \ + MATERIAL_SPECIFIC_WEIGHT, MATERIAL_THICKNESS, PARTIAL_FACTOR, POISSONS_RATIO, PRECISION_FACTOR, QUANTITY, QUANTITY_INTEGER ,\ + RATIO, RELATIVE_LENGTH, SECTION_ANGLE, SECTION_AREA, SECTION_BIMOMENT, SECTION_COMPLIANCE, SECTION_DIMENSION, \ + SECTION_EFFECTIVE_SECOND_MOMENT_OF_AREA, SECTION_FORCE, SECTION_MOMENT, SECTION_MOMENT_OF_INERTIA, \ + SECTION_NORMALIZED_WARPING_CONSTANT, SECTION_PERIMETER, SECTION_QUANTITY, SECTION_SECTION_FACTOR, SECTION_SECTION_MODULUS, \ + SECTION_STATICAL_MOMENT_OF_AREA, SECTION_TENSION_FIELD_COEFFICIENT_1, SECTION_TENSION_FIELD_COEFFICIENT_2, \ + SECTION_UNIT_STRESSES, SECTION_UNIT_WARPING_FUNCTION, SECTION_WARPING_CONSTANT, SECTION_WARPING_STATICAL_MOMENT, \ + SELF_WEIGHT_FACTOR, STIFFNESS_MULTIPLICATION_FACTOR, STRAIN, STRAIN_RATE, STRESSES, THERMAL_EXPANSION_COEFFICIENT, \ + THICKNESS, TIME, VOLUME, WEIGHT_AND_KNOT = range(84) + +class GlobalParameterDefinitionType(Enum): + ''' + Global Parameter Definition Type + ''' + DEFINITION_TYPE_FORMULA, DEFINITION_TYPE_OPTIMIZATION, DEFINITION_TYPE_OPTIMIZATION_ASCENDING, \ + DEFINITION_TYPE_OPTIMIZATION_DESCENDING, DEFINITION_TYPE_VALUE = range(5) + +class FreeConcentratedLoadLoadDirection(Enum): + ''' + Load Concentrated Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X, LOAD_DIRECTION_GLOBAL_Y, LOAD_DIRECTION_GLOBAL_Z, LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, \ + LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_USER_DEFINED_U, LOAD_DIRECTION_USER_DEFINED_V, LOAD_DIRECTION_USER_DEFINED_W = range(9) + +class FreeLoadLoadProjection(Enum): + ''' + Free Load Load Projection | Enum + ''' + LOAD_PROJECTION_XY_OR_UV, LOAD_PROJECTION_XZ_OR_UW, LOAD_PROJECTION_YZ_OR_VW = range(3) + +class FreeConcentratedLoadLoadType(Enum): + ''' + Free Concentrated Load Load Type | Enum + ''' + LOAD_TYPE_FORCE, LOAD_TYPE_MOMENT = range(2) + +class FreeLineLoadLoadDirection(Enum): + ''' + Free Line Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_PROJECTED, LOAD_DIRECTION_GLOBAL_X_TRUE, LOAD_DIRECTION_GLOBAL_Y_PROJECTED, \ + LOAD_DIRECTION_GLOBAL_Y_TRUE, LOAD_DIRECTION_GLOBAL_Z_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_TRUE, \ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_USER_DEFINED_U_PROJECTED, \ + LOAD_DIRECTION_USER_DEFINED_U_TRUE, LOAD_DIRECTION_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_USER_DEFINED_V_TRUE, \ + LOAD_DIRECTION_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_USER_DEFINED_W_TRUE = range(15) + +class FreeLineLoadLoadDistribution(Enum): + ''' + Free Line Load Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_LINEAR, LOAD_DISTRIBUTION_UNIFORM = range(2) + +class FreeRectangularLoadLoadDirection(Enum): + ''' + Free Rectangular Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_PROJECTED, LOAD_DIRECTION_GLOBAL_X_TRUE, LOAD_DIRECTION_GLOBAL_Y_PROJECTED, \ + LOAD_DIRECTION_GLOBAL_Y_TRUE, LOAD_DIRECTION_GLOBAL_Z_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_TRUE, \ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_USER_DEFINED_U_PROJECTED, \ + LOAD_DIRECTION_USER_DEFINED_U_TRUE, LOAD_DIRECTION_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_USER_DEFINED_V_TRUE, \ + LOAD_DIRECTION_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_USER_DEFINED_W_TRUE = range(15) + +class FreeRectangularLoadLoadDistribution(Enum): + ''' + Free Rectangular Load Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_LINEAR_FIRST, LOAD_DISTRIBUTION_LINEAR_SECOND, LOAD_DISTRIBUTION_UNIFORM, \ + LOAD_DISTRIBUTION_VARYING_ALONG_PERIMETER, LOAD_DISTRIBUTION_VARYING_IN_Z, \ + LOAD_DISTRIBUTION_VARYING_IN_Z_AND_ALONG_PERIMETER = range(6) + +class FreeRectangularLoadLoadLocationRectangle(Enum): + ''' + Free Rectangular Load Load Location Rectangle | Enum + ''' + LOAD_LOCATION_RECTANGLE_CENTER_AND_SIDES, LOAD_LOCATION_RECTANGLE_CORNER_POINTS = range(2) + +class FreeCircularLoadLoadDirection(Enum): + ''' + Free Circular Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_PROJECTED, LOAD_DIRECTION_GLOBAL_X_TRUE, LOAD_DIRECTION_GLOBAL_Y_PROJECTED, \ + LOAD_DIRECTION_GLOBAL_Y_TRUE, LOAD_DIRECTION_GLOBAL_Z_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_TRUE, \ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_USER_DEFINED_U_PROJECTED, \ + LOAD_DIRECTION_USER_DEFINED_U_TRUE, LOAD_DIRECTION_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_USER_DEFINED_V_TRUE, \ + LOAD_DIRECTION_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_USER_DEFINED_W_TRUE = range(15) + +class FreeCircularLoadLoadDistribution(Enum): + ''' + Free Circular Load Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_LINEAR, LOAD_DISTRIBUTION_UNIFORM = range(2) + +class FreePolygonLoadLoadDirection(Enum): + ''' + Free Polygon Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_PROJECTED, LOAD_DIRECTION_GLOBAL_X_TRUE, LOAD_DIRECTION_GLOBAL_Y_PROJECTED, \ + LOAD_DIRECTION_GLOBAL_Y_TRUE, LOAD_DIRECTION_GLOBAL_Z_PROJECTED, LOAD_DIRECTION_GLOBAL_Z_TRUE, \ + LOAD_DIRECTION_LOCAL_X, LOAD_DIRECTION_LOCAL_Y, LOAD_DIRECTION_LOCAL_Z, LOAD_DIRECTION_USER_DEFINED_U_PROJECTED, \ + LOAD_DIRECTION_USER_DEFINED_U_TRUE, LOAD_DIRECTION_USER_DEFINED_V_PROJECTED, LOAD_DIRECTION_USER_DEFINED_V_TRUE, \ + LOAD_DIRECTION_USER_DEFINED_W_PROJECTED, LOAD_DIRECTION_USER_DEFINED_W_TRUE = range(15) + +class FreePolygonLoadLoadDistribution(Enum): + ''' + Free Polygon Load Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_LINEAR, LOAD_DISTRIBUTION_LINEAR_FIRST, LOAD_DISTRIBUTION_LINEAR_SECOND, LOAD_DISTRIBUTION_UNIFORM = range(4) + +class RigidLinkType(Enum): + ''' + Rigid Link Type | Enum + ''' + TYPE_LINE_TO_LINE, TYPE_LINE_TO_SURFACE, TYPE_DIAPHRAGM = range(3) + +class SolidType(Enum): + ''' + Solid Type | Enum + ''' + TYPE_STANDARD, TYPE_GAS, TYPE_CONTACT, TYPE_HOLE, TYPE_SOIL = range(5) + +class SolidLoadType(Enum): + ''' + Solid Load Load Type | Enum + ''' + LOAD_TYPE_BUOYANCY, LOAD_TYPE_FORCE, LOAD_TYPE_GAS, LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_STRAIN, LOAD_TYPE_TEMPERATURE = range(6) + +class SolidLoadDistribution(Enum): + ''' + Solid Load Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_LINEAR_IN_X, LOAD_DISTRIBUTION_LINEAR_IN_Y, LOAD_DISTRIBUTION_LINEAR_IN_Z, LOAD_DISTRIBUTION_UNIFORM = range(4) + +class SolidLoadDirection(Enum): + ''' + Solid Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE = range(3) +class SolidSetLoadType(Enum): + ''' + Solidset Load Load Type | Enum + ''' + LOAD_TYPE_BUOYANCY, LOAD_TYPE_FORCE, LOAD_TYPE_GAS, LOAD_TYPE_ROTARY_MOTION, LOAD_TYPE_STRAIN, LOAD_TYPE_TEMPERATURE = range(6) + +class SolidSetLoadDistribution(Enum): + ''' + Solidset Load Load Distribution | Enum + ''' + LOAD_DISTRIBUTION_LINEAR_IN_X, LOAD_DISTRIBUTION_LINEAR_IN_Y, LOAD_DISTRIBUTION_LINEAR_IN_Z, LOAD_DISTRIBUTION_UNIFORM = range(4) + +class SolidSetLoadDirection(Enum): + ''' + Solidset Load Load Direction | Enum + ''' + LOAD_DIRECTION_GLOBAL_X_OR_USER_DEFINED_U_TRUE, LOAD_DIRECTION_GLOBAL_Y_OR_USER_DEFINED_V_TRUE, LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE = range(3) + + +class StabilityAnalysisSettingsAnalysisType(Enum): + ''' + Stability Analysis Settings Analysis Type | Enum + ''' + EIGENVALUE_METHOD, INCREMENTALY_METHOD_WITHOUT_EIGENVALUE, \ + INCREMENTALY_METHOD_WITH_EIGENVALUE = range(3) + +class StabilityAnalysisSettingsEigenvalueMethod(Enum): + ''' + Stability Analysis Settings Eigenvalue Method | Enum + ''' + EIGENVALUE_METHOD_ICG_ITERATION, EIGENVALUE_METHOD_LANCZOS, \ + EIGENVALUE_METHOD_ROOTS_OF_CHARACTERISTIC_POLYNOMIAL, \ + EIGENVALUE_METHOD_SUBSPACE_ITERATION, E_EIGENVALUE_METHOD_SHIFTED_INVERSE_POWER_METHOD = range(5) + +class StabilityAnalysisSettingsMatrixType(Enum): + ''' + Stability Analysis Settings Matrix Type | Enum + ''' + MATRIX_TYPE_STANDARD, MATRIX_TYPE_UNIT = range(2) + +class StabilityAnalysisSettingsStoppingOfLoadIncreasingResult(Enum): + ''' + Stability Analysis Settings Stopping Of Load Increasing Result | Enum + ''' + RESULT_TYPE_DISPLACEMENT_U, RESULT_TYPE_DISPLACEMENT_U_X, RESULT_TYPE_DISPLACEMENT_U_Y, \ + RESULT_TYPE_DISPLACEMENT_U_Z, RESULT_TYPE_ROTATION_PHI, RESULT_TYPE_ROTATION_PHI_X, \ + RESULT_TYPE_ROTATION_PHI_Y, RESULT_TYPE_ROTATION_PHI_Z = range(8) +class LineType(Enum): + ''' + Line Type + ''' + TYPE_ARC, TYPE_CIRCLE, TYPE_CUT_VIA_SECTION, TYPE_CUT_VIA_TWO_LINES, TYPE_ELLIPTICAL_ARC, TYPE_ELLIPSE, TYPE_NURBS, TYPE_PARABOLA, TYPE_POLYLINE, TYPE_SPLINE = range(10) + +class ObjectTypes(Enum): + ''' + Object Types + ''' + E_OBJECT_TYPE_ACTION, E_OBJECT_TYPE_ACTION_COMBINATION, E_OBJECT_TYPE_BUILDING_STORY, E_OBJECT_TYPE_CLIPPING_BOX, E_OBJECT_TYPE_CLIPPING_PLANE, E_OBJECT_TYPE_COMBINATION_WIZARD, E_OBJECT_TYPE_COORDINATE_SYSTEM,\ + E_OBJECT_TYPE_CUTTING_LINE_SETTING, E_OBJECT_TYPE_CUTTING_PATTERN, E_OBJECT_TYPE_DESIGN_SITUATION, E_OBJECT_TYPE_DESIGN_SUPPORT, E_OBJECT_TYPE_DIMENSION, E_OBJECT_TYPE_FREE_CIRCULAR_LOAD, E_OBJECT_TYPE_FREE_CONCENTRATED_LOAD,\ + E_OBJECT_TYPE_FREE_LINE_LOAD, E_OBJECT_TYPE_FREE_POLYGON_LOAD, E_OBJECT_TYPE_FREE_RECTANGULAR_LOAD, E_OBJECT_TYPE_IMPERFECTION_CASE, E_OBJECT_TYPE_IMPOSED_LINE_DEFORMATION, E_OBJECT_TYPE_IMPOSED_NODAL_DEFORMATION,\ + E_OBJECT_TYPE_INTERSECTION, E_OBJECT_TYPE_LINE, E_OBJECT_TYPE_LINE_GRID, E_OBJECT_TYPE_LINE_HINGE, E_OBJECT_TYPE_LINE_LOAD, E_OBJECT_TYPE_LINE_MESH_REFINEMENT, E_OBJECT_TYPE_LINE_SET, E_OBJECT_TYPE_LINE_SET_LOAD,\ + E_OBJECT_TYPE_LINE_SUPPORT, E_OBJECT_TYPE_LINE_WELDED_JOINT, E_OBJECT_TYPE_LOAD_CASE, E_OBJECT_TYPE_LOAD_COMBINATION, E_OBJECT_TYPE_MATERIAL, E_OBJECT_TYPE_MEMBER, E_OBJECT_TYPE_MEMBER_DEFINABLE_STIFFNESS,\ + E_OBJECT_TYPE_MEMBER_ECCENTRICITY, E_OBJECT_TYPE_MEMBER_HINGE, E_OBJECT_TYPE_MEMBER_IMPERFECTION, E_OBJECT_TYPE_MEMBER_LOAD, E_OBJECT_TYPE_MEMBER_NONLINEARITY, E_OBJECT_TYPE_MEMBER_REPRESENTATIVE,\ + E_OBJECT_TYPE_MEMBER_RESULT_INTERMEDIATE_POINT, E_OBJECT_TYPE_MEMBER_SET, E_OBJECT_TYPE_MEMBER_SET_IMPERFECTION, E_OBJECT_TYPE_MEMBER_SET_LOAD, E_OBJECT_TYPE_MEMBER_SET_REPRESENTATIVE, E_OBJECT_TYPE_MEMBER_STIFFNESS_MODIFICATION,\ + E_OBJECT_TYPE_MEMBER_SUPPORT, E_OBJECT_TYPE_MEMBER_TRANSVERSE_STIFFENER, E_OBJECT_TYPE_NODAL_LOAD, E_OBJECT_TYPE_NODAL_MESH_REFINEMENT, E_OBJECT_TYPE_NODAL_SUPPORT, E_OBJECT_TYPE_NODE, E_OBJECT_TYPE_NOTE, E_OBJECT_TYPE_OBJECT_SNAP,\ + E_OBJECT_TYPE_OPENING, E_OBJECT_TYPE_OPENING_LOAD, E_OBJECT_TYPE_RESULT_COMBINATION, E_OBJECT_TYPE_RESULT_SECTION, E_OBJECT_TYPE_RIGID_LINK, E_OBJECT_TYPE_SECTION, E_OBJECT_TYPE_SOIL_SAMPLE, E_OBJECT_TYPE_SOLID,\ + E_OBJECT_TYPE_SOLID_CONTACTS, E_OBJECT_TYPE_SOLID_GAS, E_OBJECT_TYPE_SOLID_LOAD, E_OBJECT_TYPE_SOLID_MESH_REFINEMENT, E_OBJECT_TYPE_SOLID_SET, E_OBJECT_TYPE_SOLID_SET_LOAD, E_OBJECT_TYPE_STATIC_ANALYSIS_SETTINGS,\ + E_OBJECT_TYPE_STRUCTURE_MODIFICATION, E_OBJECT_TYPE_SURFACE, E_OBJECT_TYPE_SURFACES_CONTACT, E_OBJECT_TYPE_SURFACES_CONTACT_TYPE, E_OBJECT_TYPE_SURFACE_ECCENTRICITY, E_OBJECT_TYPE_SURFACE_IMPERFECTION,\ + E_OBJECT_TYPE_SURFACE_LOAD, E_OBJECT_TYPE_SURFACE_MESH_REFINEMENT, E_OBJECT_TYPE_SURFACE_RESULTS_ADJUSTMENT, E_OBJECT_TYPE_SURFACE_SET, E_OBJECT_TYPE_SURFACE_SET_IMPERFECTION, E_OBJECT_TYPE_SURFACE_SET_LOAD,\ + E_OBJECT_TYPE_SURFACE_STIFFNESS_MODIFICATION, E_OBJECT_TYPE_SURFACE_SUPPORT, E_OBJECT_TYPE_THICKNESS, E_OBJECT_TYPE_VISUAL_OBJECT = range(86) + +class export_to_ifc_axis_rotation_sequence_type(Enum): + ''' + Export to IFC Axis Rotation Sequence Type + ''' + XYZ, XZY, YXZ, YZX, ZXY, ZYX = range(6) + +class export_to_ifc_axis_type(Enum): + ''' + Export to IFC Axis Type + ''' + X,Y,Z = range(3) + +class export_to_ifc_export_type(Enum): + ''' + Export to IFC Export Type + ''' + E_EXPORT_IFC4_REFERENCE_VIEW, E_EXPORT_IFC4_STRUCTURAL_ANALYSIS_VIEW = range(2) + +class MemberSectionDistributionType(Enum): + ''' + Member Section Distribution Type + ''' + SECTION_DISTRIBUTION_TYPE_LINEAR, SECTION_DISTRIBUTION_TYPE_OFFSET_AT_BOTH_SIDES, SECTION_DISTRIBUTION_TYPE_OFFSET_AT_END_OF_MEMBER, \ + SECTION_DISTRIBUTION_TYPE_OFFSET_AT_START_OF_MEMBER, SECTION_DISTRIBUTION_TYPE_SADDLE, SECTION_DISTRIBUTION_TYPE_TAPERED_AT_BOTH_SIDES, \ + SECTION_DISTRIBUTION_TYPE_TAPERED_AT_END_OF_MEMBER, SECTION_DISTRIBUTION_TYPE_TAPERED_AT_START_OF_MEMBER, SECTION_DISTRIBUTION_TYPE_UNIFORM = range(9) + +class MemberReferenceType(Enum): + ''' + Member Reference Type + ''' + REFERENCE_TYPE_L, REFERENCE_TYPE_XY, REFERENCE_TYPE_XZ, REFERENCE_TYPE_YZ = range(4) + +class MemberTypeRibAlignment(Enum): + ''' + Member Type Rib Alignment + ''' + ALIGNMENT_CENTRIC, ALIGNMENT_ON_Z_SIDE_NEGATIVE, ALIGNMENT_ON_Z_SIDE_POSITIVE, ALIGNMENT_USER_DEFINED_VIA_MEMBER_ECCENTRICITY = range(4) + +class MemberReferenceLengthType(Enum): + ''' + Member Reference Length Definition Type + ''' + REFERENCE_LENGTH_TYPE_MEMBER_LENGTH, REFERENCE_LENGTH_TYPE_SEGMENT_LENGTH, REFERENCE_LENGTH_TYPE_USER_DEFINED = range(3) + +class MemberReferenceLengthWidthType(Enum): + ''' + Member Reference Length Width Type + ''' + REFERENCE_LENGTH_WIDTH_EC2, REFERENCE_LENGTH_WIDTH_EIGHTH, REFERENCE_LENGTH_WIDTH_NONE, REFERENCE_LENGTH_WIDTH_SIXTH = range(4) + +class MemberResultBeamIntegration(Enum): + ''' + Member Result Beam Integrate Stresses and Forces + ''' + INTEGRATE_FROM_LISTED_OBJECT, INTEGRATE_WITHIN_CUBOID_GENERAL, INTEGRATE_WITHIN_CUBOID_QUADRATIC, INTEGRATE_WITHIN_CYLINDER = range(4) + +class MemberSectionAlignment(Enum): + ''' + Member Section Alignment + ''' + SECTION_ALIGNMENT_BOTTOM, SECTION_ALIGNMENT_CENTRIC, SECTION_ALIGNMENT_TOP = range(3) + +class MemberCurvedCantileversType(Enum): + ''' + Member Curved Member Cantilevers Type + ''' + CANTILEVERS_TYPE_HORIZONTAL, CANTILEVERS_TYPE_OFFSET, CANTILEVERS_TYPE_PARALLEL, CANTILEVERS_TYPE_TAPER = range(4) + +class MemberRotationSpecificationType(Enum): + '''' + Member Rotation Specification Type + ''' + COORDINATE_SYSTEM_ROTATION_VIA_ANGLE, COORDINATE_SYSTEM_ROTATION_VIA_HELP_NODE, COORDINATE_SYSTEM_ROTATION_VIA_INSIDE_NODE, COORDINATE_SYSTEM_ROTATION_VIA_SURFACE = range(4) + +class MemberRotationPlaneType(Enum): + ''' + Member Rotation Plane Type + ''' + ROTATION_PLANE_XY, ROTATION_PLANE_XZ = range(2) + +class StirrupType(Enum): + ''' + Stirrup Type + ''' + STIRRUP_TYPE_FOUR_LEGGED_CLOSED_HOOK_135, STIRRUP_TYPE_FOUR_LEGGED_CLOSED_HOOK_90, STIRRUP_TYPE_FOUR_LEGGED_OVERLAP_HOOK_180, \ + STIRRUP_TYPE_THREE_LEGGED_CLOSED_HOOK_135, STIRRUP_TYPE_THREE_LEGGED_CLOSED_HOOK_90, STIRRUP_TYPE_THREE_LEGGED_OVERLAP_HOOK_180, \ + STIRRUP_TYPE_TWO_LEGGED_CLOSED_HOOK_135, STIRRUP_TYPE_TWO_LEGGED_CLOSED_HOOK_90, STIRRUP_TYPE_TWO_LEGGED_OPEN, \ + STIRRUP_TYPE_TWO_LEGGED_OVERLAP_HOOK_180 = range(10) + +class SpanPositionReferenceType(Enum): + ''' + Span Position Reference Type + ''' + SHEAR_REINFORCEMENT_SPAN_INTERNAL_NODE, SHEAR_REINFORCEMENT_SPAN_REFERENCE_END, SHEAR_REINFORCEMENT_SPAN_REFERENCE_START = range(3) + +class SpanPositionDefinitionFormatType(Enum): + ''' + Span Position Definition Format Type + ''' + SHEAR_REINFORCEMENT_SPAN_DEFINITION_FORMAT_ABSOLUTE, SHEAR_REINFORCEMENT_SPAN_DEFINITION_FORMAT_RELATIVE = range(2) + +class StirrupLayoutRuleType(Enum): + ''' + Stirrup Layout Rule Type + ''' + SHEAR_REINFORCEMENT_STIRRUP_LAYOUT_RULE_END_DEFINED, SHEAR_REINFORCEMENT_STIRRUP_LAYOUT_RULE_END_EQUALS_REST_LENGTH_TO_STIRRUP_DISTANCED,\ + SHEAR_REINFORCEMENT_STIRRUP_LAYOUT_RULE_START_DEFINED, SHEAR_REINFORCEMENT_STIRRUP_LAYOUT_RULE_START_EQUALS_END, \ + SHEAR_REINFORCEMENT_STIRRUP_LAYOUT_RULE_START_EQUALS_REST_LENGTH_TO_STIRRUP_DISTANCED = range(5) + +class RebarType(Enum): + ''' + Rebar Type + ''' + REBAR_TYPE_LINE, REBAR_TYPE_SINGLE, REBAR_TYPE_SYMMETRICAL, REBAR_TYPE_UNIFORMLY_SURROUNDING, REBAR_TYPE_UNSYMMETRICAL = range(5) + +class AdditionalOffsetType(Enum): + ''' + Additional Offset Type + ''' + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_FROM_CONCRETE_COVER, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_FROM_SECTION_SURFACE, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_FROM_STIRRUP, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_NONE = range(4) + +class AdditionalOffsetSingleLineType(Enum): + ''' + Additional Offset Single Line Type + ''' + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_FROM_CONCRETE_COVER, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_FROM_SECTION_SURFACE, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_FROM_STIRRUP, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_TYPE_NONE = range(4) + +class AdditionalOffsetReferenceType(Enum): + ''' + Additional Offset Reference Type + ''' + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_BOTTOM, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_CENTER, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_TOP, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_BOTTOM, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_CENTER, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_TOP, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_BOTTOM, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_CENTER, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_TOP = range(9) + +class AdditionalOffsetReferenceStartType(Enum): + ''' + Additional Offset Reference Type at Start Type + ''' + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_BOTTOM, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_CENTER, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_TOP, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_BOTTOM, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_CENTER, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_TOP, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_BOTTOM, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_CENTER, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_TOP = range(9) + +class AdditionalOffsetReferenceEndType(Enum): + ''' + Additional Offset Reference Type at End Type + ''' + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_BOTTOM, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_CENTER, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_CENTER_TOP, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_BOTTOM, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_CENTER, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_LEFT_TOP, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_BOTTOM, LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_CENTER, \ + LONGITUDINAL_REINFORCEMENT_ADDITIONAL_OFFSET_REFERENCE_TYPE_RIGHT_TOP = range(9) + +class AnchorageStartAnchorType(Enum): + ''' + Anchorage Start Anchor Type + ''' + ANCHORAGE_TYPE_BEND, ANCHORAGE_TYPE_HOOK, ANCHORAGE_TYPE_HOOK_WITH_TRANSVERSE_BAR, ANCHORAGE_TYPE_NONE,\ + ANCHORAGE_TYPE_STRAIGHT, ANCHORAGE_TYPE_STRAIGHT_WITH_TRANSVERSE_BAR, ANCHORAGE_TYPE_STRAIGHT_WITH_TWO_TRANSVERSE_BARS = range(7) + +class AnchorageEndAnchorType(Enum): + ''' + Anchorage End Anchor Type + ''' + ANCHORAGE_TYPE_BEND, ANCHORAGE_TYPE_HOOK, ANCHORAGE_TYPE_HOOK_WITH_TRANSVERSE_BAR, ANCHORAGE_TYPE_NONE,\ + ANCHORAGE_TYPE_STRAIGHT, ANCHORAGE_TYPE_STRAIGHT_WITH_TRANSVERSE_BAR, ANCHORAGE_TYPE_STRAIGHT_WITH_TWO_TRANSVERSE_BARS = range(7) + +class SelectedObjectInformation(Enum): + ''' + Information About Members | Enum + ''' + LENGTH, VOLUME, MASS, AREA = range(4) +class GlobalAxesOrientationType(Enum): + ''' + Model Settings and Options Global Axes Orientation Type + ''' + E_GLOBAL_AXES_ORIENTATION_ZDOWN, E_GLOBAL_AXES_ORIENTATION_ZUP = range(2) + +class LocalAxesOrientationType(Enum): + ''' + Model Settings and Local Axes Orientation Type + ''' + E_LOCAL_AXES_ORIENTATION_YUPX, E_LOCAL_AXES_ORIENTATION_YUPZ, E_LOCAL_AXES_ORIENTATION_ZDOWN, E_LOCAL_AXES_ORIENTATION_ZUP = range(4) + +class ModelType(Enum): + ''' + Model Type | Enum + ''' + E_MODEL_TYPE_1D_X_3D, E_MODEL_TYPE_1D_X_AXIAL, E_MODEL_TYPE_2D_XY_3D, \ + E_MODEL_TYPE_2D_XY_PLATE, E_MODEL_TYPE_2D_XZ_3D, E_MODEL_TYPE_2D_XZ_PLANE_STRAIN, \ + E_MODEL_TYPE_2D_XZ_PLANE_STRESS, E_MODEL_TYPE_3D = range(8) +class ModalSolutionMethod(Enum): + ''' + Modal Analysis Settings Solution Method + ''' + METHOD_ICG_ITERATION, METHOD_LANCZOS, METHOD_ROOT_OF_CHARACTERISTIC_POLYNOMIAL, METHOD_SUBSPACE_ITERATION, SOLUTION_METHOD_SHIFTED_INVERSE_POWER_METHOD = range(5) + +class ModalMassConversionType(Enum): + ''' + Modal Analysis Settings Mass Conversion Type + ''' + MASS_CONVERSION_TYPE_FULL_LOADS_AS_MASS, MASS_CONVERSION_TYPE_Z_COMPONENTS_OF_LOADS, MASS_CONVERSION_TYPE_Z_COMPONENTS_OF_LOADS_IN_DIRECTION_OF_GRAVITY = range(3) + +class ModalMassMatrixType(Enum): + ''' + Modal Analysis Settings Mass Matrix Type + ''' + MASS_MATRIX_TYPE_CONSISTENT, MASS_MATRIX_TYPE_DIAGONAL, MASS_MATRIX_TYPE_DIAGONAL_WITH_TORSIONAL_ELEMENTS, MASS_MATRIX_TYPE_UNIT = range(4) + +class ModalModeNumberMethod(Enum): + ''' + Modal Analysis Settings Number of Modes Method + ''' + NUMBER_OF_MODES_METHOD_EFFECTIVE_MASS_FACTORS, NUMBER_OF_MODES_METHOD_MAXIMUM_FREQUENCY, NUMBER_OF_MODES_METHOD_USER_DEFINED = range(3) + +class ModalNeglectMasses(Enum): + ''' + Modal Analysis Settings Neglect Masses + ''' + E_NEGLECT_MASSES_IN_ALL_FIXED_SUPPORTS, E_NEGLECT_MASSES_NO_NEGLECTION, E_NEGLECT_MASSES_USER_DEFINED = range(3) +class PeriodicResponseCombinationRule(Enum): + ''' + Spectral Analysis Settings Combination Rule For Periodic Responses + ''' + ABSOLUTE_SUM, CQC, SRSS = range(3) + +class DirectionalComponentCombinationRule(Enum): + ''' + Spectral Analysis Settings Combination Rule For Directional Components + ''' + ABSOLUTE_SUM, SCALED_SUM, SRSS = range(3) + +class CqsDampingRule(Enum): + ''' + Spectal Analysis Settings Damping for CQC Rule + ''' + CONSTANT_FOR_EACH_MODE, DIFFERENT_FOR_EACH_MODE = range(2) + +class DurabilityCorrosionCarbonation(Enum): + ''' + Concrete Durability Corrosion Induced by Carbonation + ''' + CORROSION_INDUCED_BY_CARBONATION_TYPE_CYCLIC_WET_AND_DRY, CORROSION_INDUCED_BY_CARBONATION_TYPE_DRY_OR_PERMANENTLY_WET,\ + CORROSION_INDUCED_BY_CARBONATION_TYPE_MODERATE_HUMIDITY, CORROSION_INDUCED_BY_CARBONATION_TYPE_WET_RARELY_DRY = range(4) + +class DurabilityCorrosionChlorides(Enum): + ''' + Concrete Durability Corrosion Induced by Chlorides + ''' + CORROSION_INDUCED_BY_CHLORIDES_TYPE_CYCLIC_WET_AND_DRY, CORROSION_INDUCED_BY_CHLORIDES_TYPE_MODERATE_HUMIDITY, CORROSION_INDUCED_BY_CHLORIDES_TYPE_WET_RARELY_DRY = range(3) + +class DurabilityCorrosionSeaWater(Enum): + ''' + Concrete Durability Corrosion Induced by Chlorised From Sea Water + ''' + CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_AIRBORNE_SALT, CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_PERMANENTLY_SUBMERGED,\ + CORROSION_INDUCED_BY_CHLORIDES_FROM_SEA_WATER_TYPE_SPLASH_AND_SPRAY_ZONES = range(3) + +class DurabilityFreezeThawAttack(Enum): + ''' + Concrete Durability Freeze Thaw Attack + ''' + FREEZE_THAW_ATTACK_TYPE_HIGH_SATURATION_DEICING, FREEZE_THAW_ATTACK_TYPE_HIGH_SATURATION_NO_DEICING,\ + FREEZE_THAW_ATTACK_TYPE_MODERATE_SATURATION_DEICING, FREEZE_THAW_ATTACK_TYPE_MODERATE_SATURATION_NO_DEICING = range(4) + +class DurabilityChemicalAttack(Enum): + ''' + Concrete Durability Chemical Attack + ''' + CHEMICAL_ATTACK_TYPE_HIGHLY_AGGRESSIVE, CHEMICAL_ATTACK_TYPE_MODERATELY_AGGRESSIVE, CHEMICAL_ATTACK_TYPE_SLIGHTLY_AGGRESSIVE = range(3) + +class DurabilityCorrosionWear(Enum): + ''' + Concrete Durability Concrete Corrosion Induced by the Wear + ''' + CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_HIGH, CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_MODERATE, CONCRETE_CORROSION_INDUCED_BY_WEAR_TYPE_VERY_HIGH = range(3) + +class DurabilityStructuralClassType(Enum): + ''' + Concrete Durability Structural Class Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityStructuralClass(Enum): + ''' + Concrete Durability User Defined Structural Class + ''' + S1, S2, S3, S4, S5, S6 = range(6) + +class DurabilityMaxWaterToCementRatio(Enum): + ''' + Concrete Durability Maximum Equivalent Water To Cement Ratio + ''' + ZERO_POINT_FIVE, ZERO_POINT_FIVE_FIVE, ZERO_POINT_FOUR, ZERO_POINT_FOUR_FIVE, ZERO_POINT_NINE, ZERO_POINT_SIX, ZERO_POINT_THREE_FIVE = range(7) + +class DurabilityConcreteCoverType(Enum): + ''' + Concrete Durability Increase of Minimum Concrete Cover Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityStainlessSteelType(Enum): + ''' + Concrete Durability Additional Protection Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityAdditionalProtectionType(Enum): + ''' + Concrete Durability Additional Protection Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityAllowanceDeviationType(Enum): + ''' + Concrete Durability Allowance of Deviation Type + ''' + DEFINED, STANDARD = range(2) + +class DurabilityConcreteCast(Enum): + ''' + Concrete Durability Concrete Cast + ''' + AGAINST_PREPARED_GROUND, DIRECTLY_AGAINST_SOIL = range(2) + +class ConcreteEffectiveLengthsAxisZ(Enum): + ''' + Concrete Effective Lengths Structure Type About Axis Z + ''' + STRUCTURE_TYPE_BRACED, STRUCTURE_TYPE_UNBRACED = range(2) + +class ConcreteEffectiveLengthAxisY(Enum): + ''' + Concrete Effective Lengths Structure Type About Axis Y + ''' + STRUCTURE_TYPE_BRACED, STRUCTURE_TYPE_UNBRACED = range(2) + +class EffectiveLengthSupportType(Enum): + ''' + Effective Length Nodal Support Type + ''' + SUPPORT_TYPE_FIXED_ALL, SUPPORT_TYPE_FIXED_IN_Y, SUPPORT_TYPE_FIXED_IN_Z, SUPPORT_TYPE_FIXED_IN_Z_AND_TORSION,\ + SUPPORT_TYPE_FIXED_IN_Z_AND_TORSION_AND_WARPING, SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION, SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION_AND_WARPING,\ + SUPPORT_TYPE_INDIVIDUALLY, SUPPORT_TYPE_NONE, SUPPORT_TYPE_RESTRAINT_ABOUT_X = range(10) + +class EffectiveLengthEccentricityType(Enum): + ''' + Effective Length Eccentricity Type + ''' + ECCENTRICITY_TYPE_AT_LOWER_FLANGE, ECCENTRICITY_TYPE_AT_UPPER_FLANGE, ECCENTRICITY_TYPE_NONE, ECCENTRICITY_TYPE_USER_VALUE = range(4) + +class SupportStatus(Enum): + ''' + Support Status + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class RestraintTypeAboutX(Enum): + ''' + Restraint About X Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class RestraintTypeAboutZ(Enum): + ''' + Restraint About X Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class RestraintTypeWarping(Enum): + ''' + Restraint About Warping + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class ReinforcementDirectionType(Enum): + ''' + Reinforcement Direction Type + ''' + REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_X, REINFORCEMENT_DIRECTION_TYPE_FIRST_REINFORCEMENT_IN_Y, REINFORCEMENT_DIRECTION_TYPE_ROTATED = range(3) + +class SurfaceReinforcementLocationType(Enum): + ''' + Surface Reinforcement Location Type + ''' + LOCATION_TYPE_FREE_CIRCULAR, LOCATION_TYPE_FREE_POLYGON, LOCATION_TYPE_FREE_RECTANGULAR, LOCATION_TYPE_ON_SURFACE = range(4) + +class SurfaceReinforcementType(Enum): + ''' + Surface Reinforcement Type + ''' + REINFORCEMENT_TYPE_MESH, REINFORCEMENT_TYPE_REBARS, REINFORCEMENT_TYPE_STIRRUPS = range(3) + +class SurfaceReinforcementDirectionType(Enum): + ''' + Surface Reinforcement Direction Type + ''' + REINFORCEMENT_DIRECTION_TYPE_IN_DESIGN_REINFORCEMENT_DIRECTION, REINFORCEMENT_DIRECTION_TYPE_PARALLEL_TO_TWO_POINTS = range(2) + +class SurfaceReinforcementDesignDirection(Enum): + ''' + Surface Design Reinforcement Direction + ''' + DESIGN_REINFORCEMENT_DIRECTION_A_S_1, DESIGN_REINFORCEMENT_DIRECTION_A_S_2 = range(2) + +class SurfaceReinforcementProjectionPlane(Enum): + ''' + Surface Reinforcement Projection Plane + ''' + + PROJECTION_PLANE_XY_OR_UV, PROJECTION_PLANE_XZ_OR_UW, PROJECTION_PLANE_YZ_OR_VW = range(3) + +class SurfaceReinforcementLocationRectangleType(Enum): + ''' + Surface Reinforcement Location Type + ''' + RECTANGLE_TYPE_CENTER_AND_SIDES, RECTANGLE_TYPE_CORNER_POINTS = range(2) + +class AmplitudeFunctionType(Enum): + ''' + Amplitude Function Type + ''' + CONSTANT, LINEAR, QUADRATIC = range(3) + +class PlausibilityCheckResult(Enum): + ''' + Plausibility Check Result + ''' + CHECK_IS_OK, CHECK_FAILED = range(2) + +class ModelCheckGetOptionType(Enum): + ''' + Model Check Get Object Groups Option Type + ''' + CROSSING_LINES, CROSSING_MEMBERS, IDENTICAL_NODES, OVERLAPPING_LINES, OVERLAPPING_MEMBERS = range(5) + +class ModelCheckProcessOptionType(Enum): + ''' + Model Check Process Object Groups Option Type + ''' + CROSS_LINES, CROSS_MEMBERS, DELETE_UNUSED_NODES, UNITE_NODES_AND_DELETE_UNUSED_NODES = range(4) +class OptimizeOnType(Enum): + ''' + Optimization Settings Optimize On Type + ''' + E_OPTIMIZE_ON_TYPE_MIN_WHOLE_WEIGHT, E_OPTIMIZE_ON_TYPE_MIN_VECTORIAL_DISPLACEMENT, E_OPTIMIZE_ON_TYPE_MIN_MEMBER_DEFORMATION, \ + E_OPTIMIZE_ON_TYPE_MIN_SURFACE_DEFORMATION, E_OPTIMIZE_ON_TYPE_MIN_COST, E_OPTIMIZE_ON_TYPE_MIN_CO2_EMISSIONS = range(6) + +class Optimizer(Enum): + ''' + Optimization Settings Optimizer + ''' + E_OPTIMIZER_TYPE_ALL_MUTATIONS, E_OPTIMIZER_TYPE_PERCENTS_OF_RANDOM_MUTATIONS, E_OPTIMIZER_TYPE_PARTICLE_SWARM = range(3) + +class SurfacesShapeOfFiniteElements(Enum): + ''' + Surfaces Shape of Finite Elements + ''' + E_SHAPE_OF_FINITE_ELEMENTS_FOR_SURFACES__TRIANGLES_AND_QUADRANGLES, E_SHAPE_OF_FINITE_ELEMENTS_FOR_SURFACES__QUADRANGLES_ONLY, \ + E_SHAPE_OF_FINITE_ELEMENTS_FOR_SURFACES__TRIANGLES_ONLY = range(3) + +class AddOn(Enum): + ''' + AddOn types + ''' + stress_analysis_active, concrete_design_active, steel_design_active, timber_design_active, aluminum_design_active, \ + steel_joints_active, timber_joints_active, craneway_design_active, masonry_design_active, multilayer_surfaces_design_active, \ + material_nonlinear_analysis_active, structure_stability_active, construction_stages_active, time_dependent_active, \ + form_finding_active, cutting_patterns_active, torsional_warping_active, cost_estimation_active, modal_active, spectral_active, \ + time_history_active, pushover_active, harmonic_response_active, building_model_active, wind_simulation_active, \ + geotechnical_analysis_active = range(26) + +class SteelEffectiveLengthsBucklingFactorValueType(Enum): + ''' + Steel Effective Lengths Buckling Factor Value Type + ''' + BUCKLING_FACTOR_VALUE_TYPE_RECOMMENDED, BUCKLING_FACTOR_VALUE_TYPE_THEORETICAL = range(2) + +class SteelEffectiveLengthsSupportType(Enum): + ''' + Steel Effective Lengths Support Type + ''' + SUPPORT_TYPE_FIXED_ALL, SUPPORT_TYPE_FIXED_IN_Y, SUPPORT_TYPE_FIXED_IN_Z, SUPPORT_TYPE_FIXED_IN_Z_AND_TORSION, \ + SUPPORT_TYPE_FIXED_IN_Z_AND_TORSION_AND_WARPING, SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION, SUPPORT_TYPE_FIXED_IN_Z_Y_AND_TORSION_AND_WARPING, \ + SUPPORT_TYPE_INDIVIDUALLY, SUPPORT_TYPE_NONE, SUPPORT_TYPE_RESTRAINT_ABOUT_X = range(10) + +class SteelEffectiveLengthsEccentricityType(Enum): + ''' + Steel Effective Lengths Eccentricity Type + ''' + ECCENTRICITY_TYPE_AT_LOWER_FLANGE, ECCENTRICITY_TYPE_AT_UPPER_FLANGE, ECCENTRICITY_TYPE_NONE, ECCENTRICITY_TYPE_USER_VALUE = range(4) + +class SteelEffectiveLengthsSupportTypeInY(Enum): + ''' + Steel Effective Lengths Support in Y Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class SteelEffectiveLengthsRestraintTypeAboutX(Enum): + ''' + Steel Effective Lengths Restraint About X Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class SteelEffectiveLengthsRestraintTypeAboutZ(Enum): + ''' + Steel Effective Lengths Restraint About Z Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + +class SteelEffectiveLengthsRestraintTypeWarping(Enum): + ''' + Steel Effective Lengths Restraint Warping Type + ''' + SUPPORT_STATUS_NO, SUPPORT_STATUS_SPRING, SUPPORT_STATUS_YES = range(3) + + +class SteelEffectiveLengthsDeterminationMcrEurope(Enum): + ''' + Steel Effective Lengths Determination MCR Europe + ''' + DETERMINATION_EUROPE_EIGENVALUE, DETERMINATION_EUROPE_USER_DEFINED = range(2) + +class SteelEffectiveLengthsDeterminationMcrIs800(Enum): + ''' + Steel Effective Lengths Determination MCR IS 800 + ''' + DETERMINATION_IS800_EIGENVALUE, DETERMINATION_IS800_USER_DEFINED = range(2) + +class SteelEffectiveLengthsDeterminationMcrAisc(Enum): + ''' + Steel Effective Lengths Determination MCR AISC + ''' + DETERMINATION_AISC_ACC_TO_CHAPTER_F, DETERMINATION_AISC_EIGENVALUE, DETERMINATION_AISC_USER_DEFINED = range(3) + +class SteelEffectiveLengthsDeterminationMcrGb50(Enum): + ''' + Steel Effective Lengths Determination MCR GB 50 + ''' + DETERMINATION_GB50_EIGENVALUE, DETERMINATION_GB50_NOT_USED, DETERMINATION_GB50_USER_DEFINED = range(3) + +class SteelEffectiveLengthsDeterminationCbAisc(Enum): + ''' + Steel Effective Lengths Determination CB AISC + ''' + DETERMINATION_CB_ACC_TO_CHAPTER_F, DETERMINATION_CB_BASIC_VALUE, DETERMINATION_CB_USER_DEFINED = range(3) + +class SteelEffectiveLengthsDeterminationMcrCsa(Enum): + ''' + Steel Effective Lengths Determination MCR CSA + ''' + DETERMINATION_CSA_ACC_TO_CHAPTER_13_6, DETERMINATION_CSA_EIGENVALUE, DETERMINATION_CSA_USER_DEFINED = range(3) + +class SteelEffectiveLengthsDeterminationCbCsa(Enum): + ''' + Steel Effective Lengths Determination CB CSA + ''' + DETERMINATION_CB_ACC_TO_CHAPTER_13_6, DETERMINATION_CB_BASIC_VALUE, DETERMINATION_CB_USER_DEFINED = range(3) + +class SteelEffectiveLengthsDeterminationMcrBs5(Enum): + ''' + Steel Effective Lengths Determination MCR BS5 + ''' + DETERMINATION_BS5_ACC_TO_CHAPTER_F, DETERMINATION_BS5_EIGENVALUE, DETERMINATION_BS5_USER_DEFINED = range(3) + +class SteelEffectiveLengthsDeterminationCbNbr(Enum): + ''' + Steel Effective Lengths Determination CB NBR + ''' + DETERMINATION_CB_ACC_TO_5423, DETERMINATION_CB_BASIC_VALUE, DETERMINATION_CB_USER_DEFINED = range(3) + +class SteelEffectiveLengthsMomentModificationRestrainedSegments(Enum): + ''' + Steel Effective Lengths Moment Modification Restrained Segments + ''' + MOMENT_ALPHA_ACC_TO_5611_II, MOMENT_ALPHA_ACC_TO_5611_III, MOMENT_ALPHA_BASIC_VALUE, \ + MOMENT_ALPHA_EIGENVALUE_METHOD, MOMENT_ALPHA_USER_DEFINED = range(5) + +class SteelEffectiveLengthsMomentModificationUnrestrainedSegments(Enum): + ''' + Steel Effective Lengths Moment Modification Unrestrained Segments + ''' + MOMENT_ALPHA_ACC_TO_5611_II, MOMENT_ALPHA_BASIC_VALUE, MOMENT_ALPHA_USER_DEFINED = range(3) + +class SteelEffectiveLengthsSlendernessReductionRestrainedSegments(Enum): + ''' + Steel Effective Lengths Slenderness Reduction Restrained Segments + ''' + SLENDERNESS_ALPHA_ACC_TO_5611, SLENDERNESS_ALPHA_EIGENVALUE_METHOD = range(2) + +class SteelEffectiveLengthsSlendernessReductionUnrestrainedSegments(Enum): + ''' + Steel Effective Lengths Slenderness Reduction Unrestrained Segments + ''' + SLENDERNESS_ALPHA_ACC_TO_5611, SLENDERNESS_ALPHA_EIGENVALUE_METHOD = range(2) + +class SteelEffectiveLengthsMemberType(Enum): + ''' + Steel Effective Lengths Member Type + ''' + MEMBER_TYPE_BEAM, MEMBER_TYPE_CANTILEVER = range(2) + +class SteelEffectiveLengthsMemberTypeYY(Enum): + ''' + Steel Effective Lengths Member Type YY + ''' + MEMBER_TYPE_BEAM, MEMBER_TYPE_CANTILEVER = range(2) + +class SteelEffectiveLengthsMemberTypeZZ(Enum): + ''' + Steel Effective Lengths Member Type ZZ + ''' + MEMBER_TYPE_BEAM, MEMBER_TYPE_CANTILEVER = range(2) + diff --git a/package/RFEM/globalParameter.py b/package/RFEM/globalParameter.py new file mode 100644 index 00000000..6a12f26c --- /dev/null +++ b/package/RFEM/globalParameter.py @@ -0,0 +1,79 @@ +from RFEM.initModel import Model, clearAtributes +from RFEM.enums import GlobalParameterUnitGroup, GlobalParameterDefinitionType + +class GlobalParameter(): + + def AddParameter(self, + no: int = 1, + name: str = '', + symbol: str = '', + unit_group = GlobalParameterUnitGroup.LENGTH, + definition_type = GlobalParameterDefinitionType.DEFINITION_TYPE_VALUE, + definition_parameter = [], + comment: str = '', + params: dict = {}): + ''' + for definition_type = GlobalParameterDefinitionType.DEFINITION_TYPE_FORMULA: + definition_parameter = [formula] + + for definition_type = GlobalParameterDefinitionType.DEFINITION_TYPE_OPTIMIZATION: + definition_parameter = [min, max, increment, steps] + + for definition_type = GlobalParameterDefinitionType.DEFINITION_TYPE_OPTIMIZATION_ASCENDING: + definition_parameter = [min, max, increment, steps] + + for definition_type = GlobalParameterDefinitionType.DEFINITION_TYPE_OPTIMIZATION_DESCENDING: + definition_parameter = [value, min, max, steps] + + for definition_type = GlobalParameterDefinitionType.DEFINITION_TYPE_VALUE: + definition_parameter = [value] + ''' + + # Client model | Global Parameter + clientObject = Model.clientModel.factory.create('ns0:global_parameter') + + # Clears object attributes | Sets all attributes to None + clearAtributes(clientObject) + + # Global Parameter No. + clientObject.no = no + + # Global Parameter Name + clientObject.name = name + + # Symbol (HTML) + clientObject.symbol = symbol + + # Unit Group + clientObject.unit_group = unit_group.name + + # Definition Type + clientObject.definition_type = definition_type.name + + if definition_type.name == 'DEFINITION_TYPE_FORMULA': + if len(definition_parameter) != 1: + raise Exception('WARNING: The definition parameter needs to be of length 1. Kindly check list inputs for completeness and correctness.') + clientObject.formula = definition_parameter[0] + + elif definition_type.name == 'DEFINITION_TYPE_OPTIMIZATION' or definition_type.name == 'DEFINITION_TYPE_OPTIMIZATION_ASCENDING' or definition_type.name == 'DEFINITION_TYPE_OPTIMIZATION_DESCENDING': + if len(definition_parameter) != 4: + raise Exception('WARNING: The definition parameter needs to be of length 4. Kindly check list inputs for completeness and correctness.') + clientObject.value = definition_parameter[0] + clientObject.min = definition_parameter[1] + clientObject.max = definition_parameter[2] + clientObject.steps = definition_parameter[3] + + elif definition_type.name == 'DEFINITION_TYPE_VALUE': + if len(definition_parameter) != 1: + raise Exception('WARNING: The definition parameter needs to be of length 1. Kindly check list inputs for completeness and correctness.') + clientObject.value = definition_parameter[0] + + # Comment + clientObject.comment = comment + + # Adding optional parameters via dictionary + for key in params: + clientObject[key] = params[key] + + # Add Global Parameter to client model + Model.clientModel.service.set_global_parameter(clientObject) diff --git a/package/RFEM/initModel.py b/package/RFEM/initModel.py new file mode 100644 index 00000000..6b34c81d --- /dev/null +++ b/package/RFEM/initModel.py @@ -0,0 +1,501 @@ +import sys +import csv +from RFEM.enums import ObjectTypes, ModelType, AddOn + +# Import SUDS module +try: + sys.version_info[0] == 3 +except: + print('Must be using Python 3!') + input('Press Enter to exit...') + sys.exit() + +try: + from suds.client import Client +except: + print('SUDS library is not installed in your Python env.') + instSUDS = input('Do you want to install it (y/n)? ') + instSUDS = instSUDS.lower() + if instSUDS == 'y': + # Subprocess will be opened in cmd and closed automaticaly after installation. + # Prevents invoking pip by an old script wrapper (https://github.com/pypa/pip/issues/5599) + import subprocess + try: + subprocess.call('python -m pip install --upgrade pip') + subprocess.call('python -m pip install suds-py3 --user') + from suds.client import Client + except: + print('WARNING: Installation of SUDS library failed!') + print('Please use command "pip install suds-py3 --user" in your Command Prompt.') + input('Press Enter to exit...') + sys.exit() + else: + input('Press Enter to exit...') + sys.exit() + +try: + import requests +except: + print('requests library is not installed in your Python env.') + instSUDS = input('Do you want to install it (y/n)? ') + instSUDS = instSUDS.lower() + if instSUDS == 'y': + # Subprocess will be opened in cmd and closed automaticaly after installation. + # Prevents invoking pip by an old script wrapper (https://github.com/pypa/pip/issues/5599) + import subprocess + try: + subprocess.call('python -m pip install requests --user') + import requests + except: + print('WARNING: Installation of requests library failed!') + print('Please use command "pip install requests --user" in your Command Prompt.') + input('Press Enter to exit...') + sys.exit() + else: + input('Press Enter to exit...') + sys.exit() + +try: + import suds_requests +except: + print('suds_requests library is not installed in your Python env.') + instSUDS = input('Do you want to install it (y/n)? ') + instSUDS = instSUDS.lower() + if instSUDS == 'y': + # Subprocess will be opened in cmd and closed automaticaly after installation. + # Prevents invoking pip by an old script wrapper (https://github.com/pypa/pip/issues/5599) + import subprocess + try: + subprocess.call('python -m pip install suds_requests --user') + import suds_requests + except: + print('WARNING: Installation of suds_requests library failed!') + print('Please use command "pip install suds_requests --user" in your Command Prompt.') + input('Press Enter to exit...') + sys.exit() + else: + input('Press Enter to exit...') + sys.exit() + +try: + import xmltodict +except: + print('xmltodict library is not installed in your Python env.') + instXML = input('Do you want to install it (y/n)? ') + instXML = instXML.lower() + if instXML == 'y': + # Subprocess will be opened in cmd and closed automaticaly after installation. + # Prevents invoking pip by an old script wrapper (https://github.com/pypa/pip/issues/5599) + import subprocess + try: + subprocess.call('python -m pip install xmltodict --user') + import xmltodict + except: + print('WARNING: Installation of xmltodict library failed!') + print('Please use command "pip install xmltodict --user" in your Command Prompt.') + input('Press Enter to exit...') + sys.exit() + else: + input('Press Enter to exit...') + sys.exit() + +# Connect to server +# Check server port range set in "Program Options & Settings" +# By default range is set between 8081 ... 8089 +print('Connecting to server...') +try: + client = Client('http://localhost:8081/wsdl') +except: + print('Error: Connection to server failed!') + print('Please check:') + print('- If you have started RFEM application') + print('- If all RFEM dialogs are closed') + print('- If server port range is set correctly') + print('- Check Program Options & Settings > Web Services') + sys.exit() + +try: + modelLst = client.service.get_model_list() +except: + print('Error: Please check if all RFEM dialogs are closed.') + input('Press Enter to exit...') + sys.exit() + +# Persistent connection +# Without next 4 lines the connection lasts only 1 request, +# the message: 'Application is locked by external connection' +# is blinking whole time and the execution is unnecessarily long. +# This solution works with unit-tests. +session = requests.Session() +adapter = requests.adapters.HTTPAdapter(pool_connections=1, pool_maxsize=1) +session.mount('http://', adapter) +trans = suds_requests.RequestsTransport(session) + +class Model(): + clientModel = None + def __init__(self, + new_model: bool=True, + model_name: str="TestModel", + delete: bool=False, + delete_all: bool=False): + + cModel = None + modelLs = client.service.get_model_list() + + if new_model: + if modelLs and model_name in modelLs.name: + new = client.service.open_model(model_name) + 'wsdl' + cModel = Client(new, transport=trans) + cModel.service.delete_all_results() + cModel.service.delete_all() + else: + new = client.service.new_model(model_name) + 'wsdl' + cModel = Client(new, transport=trans) + else: + modelIndex = 0 + for i,j in enumerate(modelLs): + if modelLs[i] == model_name: + modelIndex = i + new = client.service.get_model(modelIndex) + 'wsdl' + cModel = Client(new, transport=trans) + if delete: + print('Deleting results...') + cModel.service.delete_all_results() + if delete_all: + print('Delete all...') + cModel.service.delete_all() + + Model.clientModel = cModel + +def clearAtributes(obj): + ''' + Clears object atributes. + Sets all atributes to None. + + Params: + obj: object to clear + ''' + + # iterator + it = iter(obj) + for i in it: + obj[i[0]] = None + return obj + +def insertSpaces(lst: list): + ''' + Add spaces between list of numbers. + Returns list of values. + ''' + strLst = '' + for i in lst: + strLst += str(i) + ' ' + # remove trailing space + return strLst[:-1] + +def Calculate_all(generateXmlSolverInput: bool = False): + ''' + Calculates model. + CAUTION: Don't use it in unit tests! + It works when executing tests individualy but when running all of them + it causes RFEM to stuck and generates failures, which are hard to investigate. + + Params: + - generateXmlSolverInput: generate XML solver input + ''' + Model.clientModel.service.calculate_all(generateXmlSolverInput) + +def ConvertToDlString(s): + ''' + The function converts strings commonly used in RSTAB / RFEM so that they + can be used In WebServices. It solved issue #4. + Examples: + '1,3' -> '1 3' + '1, 3' -> '1 3' + '1-3' -> '1 2 3' + '1,3,5-9' -> '1 3 5 6 7 8 9' + + Params: + RSTAB / RFEM common string + + Returns a WS conform string. + ''' + + # Parameter is not of required type. + assert isinstance(s, (list, str)) + + if isinstance(s, list): + return ' '.join(map(str, s)) + + s = s.strip() + s = s.replace(',', ' ') + s = s.replace(' ', ' ') + lst = s.split(' ') + new_lst = [] + for element in lst: + if '-' in element: + inLst = element.split('-') + start = int(inLst[0]) + end = int(inLst[1]) + inLst = [] + for i in range(start, end + 1): + inLst.append(str(i)) + + inS = ' '.join(inLst) + new_lst.append(inS) + else: + new_lst.append(element) + + s = ' '.join(new_lst) + return s + +def ConvertStrToListOfInt(st): + """ + This function coverts string to list of integers. + """ + st = ConvertToDlString(st) + lstInt = [] + while st: + intNumber = 0 + if ' ' in st: + idx = st.index(' ') + intNumber = int(st[:idx]) + st = st[idx+1:] + else: + intNumber = int(st) + st = '' + lstInt.append(intNumber) + return lstInt + +def CheckIfMethodOrTypeExists(modelClient, method_or_type, unitTestMode=False): + """ + Check if SOAP method or type is present in your version of RFEM/RSTAB. + Use it only in your examples. + Unit tests except msg from SUDS where this is checked already. + + Args: + modelClient (Model.clientModel) + method_or_type (string): method or type of SOAP client + + Returns: + bool: Status of method or type. + + Note: + To get list of methods invoke: + list_of_methods = [method for method in Model.clientModel.wsdl.services[0].ports[0]] + """ + assert modelClient is not None, "WARNING: modelClient is not initialized." + + if method_or_type not in str(modelClient): + if unitTestMode: + return True + else: + assert False, "WARNING: Used method/type: %s is not implemented in Web Services yet." % (method_or_type) + + return not unitTestMode + + +def GetAddonStatus(modelClient, addOn = AddOn.stress_analysis_active): + """ + Check if Add-on is reachable and active. + For some types of objects, specific Add-ons need to be ennabled. + + Args: + modelClient (Model.clientModel) + method_or_type (string): method or type of SOAP client + + Returns: + (bool): Status of Add-on + """ + if modelClient is None: + print("WARNING: modelClient is not initialized.") + return False + + addons = modelClient.service.get_addon_statuses() + dct = {} + for lstType in addons: + if not isinstance(lstType[1], bool) and len(lstType[1]) > 1: + addon = [lst for lst in lstType[1]] + for item in addon: + dct[str(item[0])] = bool(item[1]) + elif isinstance(lstType[1], bool): + dct[str(lstType[0])] = bool(lstType[1]) + else: + assert False + + # sanity check + assert addOn.name in dct, f"WARNING: {addOn.name} Add-on can not be reached." + + return dct[addOn.name] + +def SetAddonStatus(modelClient, addOn = AddOn.stress_analysis_active, status = True): + """ + Activate or deactivate Add-on. + For some types of objects, specific Add-ons need to be ennabled. + + Analysis addOns list: + material_nonlinear_analysis_active + structure_stability_active + construction_stages_active + time_dependent_active + form_finding_active + cutting_patterns_active + torsional_warping_active + cost_estimation_active + + Design addOns list: + stress_analysis_active + concrete_design_active + steel_design_active + timber_design_active + aluminum_design_active + steel_joints_active + timber_joints_active + craneway_design_active + + Dynamic addOns list: + modal_active + spectral_active + time_history_active + pushover_active + harmonic_response_active + + Special aadOns list: + building_model_active + wind_simulation_active + geotechnical_analysis_active + + Args: + modelClient (Model.clientModel) + method_or_type (string): method or type of SOAP client + status (bool): in/active + """ + + # this will also provide sanity check + currentStatus = GetAddonStatus(modelClient, addOn) + if currentStatus != status: + addonLst = modelClient.service.get_addon_statuses() + if addOn.name in addonLst['__keylist__']: + addonLst[addOn.name] = status + else: + for listType in addonLst['__keylist__']: + if not isinstance(addonLst[listType], bool) and addOn.name in addonLst[listType]: + addonLst[listType][addOn.name] = status + + modelClient.service.set_addon_statuses(addonLst) + +def CalculateSelectedCases(loadCases: list = None, designSituations: list = None, loadCombinations: list = None): + ''' + This method calculate just selected objects - load cases, desingSituations, loadCombinations + Args: + loadCases (list, optional): [description]. Defaults to None. + designSituations (list, optional): [description]. Defaults to None. + loadCombinations (list, optional): [description]. Defaults to None. + ''' + specificObjectsToCalculate = Model.clientModel.factory.create('ns0:array_of_calculate_specific_objects_elements') + if loadCases is not None: + for loadCase in loadCases: + specificObjectsToCalculateLC = Model.clientModel.factory.create('ns0:array_of_calculate_specific_objects_elements.element') + specificObjectsToCalculateLC.no = loadCase + specificObjectsToCalculateLC.parent_no = 0 + specificObjectsToCalculateLC.type = ObjectTypes.E_OBJECT_TYPE_LOAD_CASE.name + specificObjectsToCalculate.element.append(specificObjectsToCalculateLC) + + if designSituations is not None: + for designSituation in designSituations: + specificObjectsToCalculateDS = Model.clientModel.factory.create('ns0:array_of_calculate_specific_objects_elements.element') + specificObjectsToCalculateDS.no = designSituation + specificObjectsToCalculateDS.parent_no = 0 + specificObjectsToCalculateDS.type = ObjectTypes.E_OBJECT_TYPE_DESIGN_SITUATION.name + specificObjectsToCalculate.element.append(specificObjectsToCalculateDS) + + if loadCombinations is not None: + for loadCombination in loadCombinations: + specificObjectsToCalculateLC = Model.clientModel.factory.create('ns0:array_of_calculate_specific_objects_elements.element') + specificObjectsToCalculateLC.no = loadCombination + specificObjectsToCalculateLC.parent_no = 0 + specificObjectsToCalculateLC.type = ObjectTypes.E_OBJECT_TYPE_LOAD_CASE.name + specificObjectsToCalculate.element.append(specificObjectsToCalculateLC) + + Model.clientModel.service.calculate_specific_objects(specificObjectsToCalculate) + +def ExportResultTablesToCsv(TargetDirectoryPath: str): + + Model.clientModel.service.export_result_tables_to_csv(TargetDirectoryPath) + +def ExportResultTablesToXML(TargetFilePath: str): + + Model.clientModel.service.export_result_tables_to_xml(TargetFilePath) + +def ExportResultTablesWithDetailedMembersResultsToCsv(TargetDirectoryPath: str): + + Model.clientModel.service.export_result_tables_with_detailed_members_results_to_csv(TargetDirectoryPath) + +def ExportResultTablesWithDetailedMembersResultsToXML(TargetFilePath: str): + + Model.clientModel.service.export_result_tables_with_detailed_members_results_to_xml(TargetFilePath) + +def ParseCSVResultsFromSelectedFileToDict(filePath: str): + + # Using encoding parameter ensures proper data translation, leaving out BOM etc. + # TODO: fix the value assigment; it only works with simple one-line header + # consider all corner cases + with open(filePath, mode='r', encoding='utf-8-sig') as f: + reader = csv.DictReader(f,delimiter=';') + my_dictionary = [] + for line in reader: + my_dictionary.append(line) + return my_dictionary + +def ParseXMLResultsFromSelectedFileToDict(filePath: str): + + with open(filePath, "rb") as f: + my_dictionary = xmltodict.parse(f, xml_attribs=True) + return my_dictionary + +def GenerateMesh(): + + Model.clientModel.service.generate_mesh() + +def GetMeshStatistics(): + + mesh_stats = Model.clientModel.service.get_mesh_statistics() + return Model.clientModel.dict(mesh_stats) + +def FirstFreeIdNumber(memType = ObjectTypes.E_OBJECT_TYPE_MEMBER, parent_no: int = 0): + ''' + This method returns the next available Id Number for the selected object type + Args: + type (enum): Object Type + parent_no (int): Object Parent Number + Note: + (1) A geometric object has, in general, a parent_no = 0 + (2) The parent_no parameter becomes significant for example with loads + ''' + return Model.clientModel.service.get_first_free_number(memType.name, parent_no) + +def SetModelType(model_type = ModelType.E_MODEL_TYPE_3D): + ''' + This method sets the model type. The model type is E_MODEL_TYPE_3D by default. + + Args: + model_type (enum): The available model types are listed below. + ModelType.E_MODEL_TYPE_1D_X_3D + ModelType.E_MODEL_TYPE_1D_X_AXIAL + ModelType.E_MODEL_TYPE_2D_XY_3D + ModelType.E_MODEL_TYPE_2D_XY_PLATE + ModelType.E_MODEL_TYPE_2D_XZ_3D + ModelType.E_MODEL_TYPE_2D_XZ_PLANE_STRAIN + ModelType.E_MODEL_TYPE_2D_XZ_PLANE_STRESS + ModelType.E_MODEL_TYPE_3D + ''' + + Model.clientModel.service.set_model_type(model_type.name) + +def GetModelType(): + + ''' + The method returns a string of the current model type. + ''' + + return Model.clientModel.service.get_model_type() diff --git a/package/RFEM/window.py b/package/RFEM/window.py new file mode 100644 index 00000000..9c801b95 --- /dev/null +++ b/package/RFEM/window.py @@ -0,0 +1,163 @@ +from tkinter import Tk +from tkinter import ttk, Entry, Label, Button, Radiobutton, Checkbutton, CENTER, VERTICAL, INSERT, NORMAL, DISABLED, LEFT, W, IntVar, StringVar + +def window(mainFunc, lstOfModels): + color = '#F2F3F4' + # Creating tkinter window + win = Tk() + win.resizable(False, False) + win.title('Power of automation with RFEM6') + win.geometry("550x280") + + win.configure(bg=color) + win.grid_columnconfigure(index=0, minsize=140) + win.grid_columnconfigure(index=1, minsize=80) + win.grid_columnconfigure(index=2, minsize=80) + win.grid_columnconfigure(index=3, minsize=70) + win.grid_columnconfigure(index=4, minsize=120) + + # Separators + y = 3 + rh = 120 #0.76 + ttk.Separator(win, orient=VERTICAL).place(x=140, y=y, height=rh) + ttk.Separator(win, orient=VERTICAL).place(x=260, y=y, height=rh) + ttk.Separator(win, orient=VERTICAL).place(x=350, y=y, height=rh) + ttk.Separator(win, orient=VERTICAL).place(x=430, y=y, height=rh) + + Label(text="Params Type", justify=CENTER, font="Segoe 9 bold", bg=color).grid(row=0, column=0) + Label(text="Data Type", justify=CENTER, font="Segoe 9 bold", bg=color).grid(row=0, column=1) + Label(text="Symbol", justify=CENTER, font="Segoe 9 bold", bg=color).grid(row=0, column=2) + Label(text="Units", justify=CENTER, font="Segoe 9 bold", bg=color).grid(row=0, column=3) + Label(text="Magnitude", justify=CENTER, font="Segoe 9 bold", bg=color).grid(row=0, column=4) + + Label(text="hall width", bg=color).grid(row=1, column=0) + Label(text="hall height", bg=color).grid(row=2, column=0) + Label(text="hall height", bg=color).grid(row=3, column=0) + Label(text="frame spacing", bg=color).grid(row=4, column=0) + Label(text="number of frames", bg=color).grid(row=5, column=0) + Label(text="Options", justify=CENTER, font="Segoe 9 bold", bg=color).grid(row=6, column=0) + + Label(text="float", bg=color).grid(row=1, column=1) + Label(text="float", bg=color).grid(row=2, column=1) + Label(text="float", bg=color).grid(row=3, column=1) + Label(text="float", bg=color).grid(row=4, column=1) + Label(text="integer", bg=color).grid(row=5, column=1) + + Label(text="L", bg=color).grid(row=1, column=2) + Label(text="h_o", bg=color).grid(row=2, column=2) + Label(text="h_m", bg=color).grid(row=3, column=2) + Label(text="f_s", bg=color).grid(row=4, column=2) + Label(text="n", bg=color).grid(row=5, column=2) + + Label(text="meters", bg=color).grid(row=1, column=3) + Label(text="meters", bg=color).grid(row=2, column=3) + Label(text="meters", bg=color).grid(row=3, column=3) + Label(text="meters", bg=color).grid(row=4, column=3) + Label(text="-", bg=color).grid(row=5, column=3) + + def validateAll(val): # 1 mandatory argument, not used + try: + float(e1.get()) + float(e2.get()) + float(e3.get()) + float(e4.get()) + int(e5.get()) + button1['state']="normal" + return 1 + except: + button1['state']="disabled" + print("disabled") + return 0 + + # Setting entry points + e1 = Entry(justify=CENTER, width=15) # (relief=FLAT, justify=CENTER, bg=color) + e1.grid(row=1, column=4) + e1.insert(INSERT, 20.0) + e2 = Entry(justify=CENTER, width=15) + e2.grid(row=2, column=4) + e2.insert(INSERT, 5.2) + e3 = Entry(justify=CENTER, width=15) + e3.grid(row=3, column=4) + e3.insert(INSERT, 7.3) + e4 = Entry(justify=CENTER, width=15) + e4.grid(row=4, column=4) + e4.insert(INSERT, 6.0) + e5 = Entry(justify=CENTER, width=15) + e5.grid(row=5, column=4) + e5.insert(INSERT, 6) + + + def start(val): + # hall_width_L, hall_height_h_o, hall_height_h_m, number_frames, frame_spacing, new_model, model_name, delete, delete_all + model_name = e6.get() if var1.get() else modeCombo.get() + mainFunc(float(e1.get()),float(e2.get()),float(e3.get()),int(e5.get()),float(e4.get()),var1.get(),model_name,int(var2.get()),int(var3.get())) + def close_window(val): + win.destroy() + + # substitute for validatecommand and validation options of Entry (e1-e5) + e1.bind('', validateAll) + e1.bind('', validateAll) + e2.bind('', validateAll) + e2.bind('', validateAll) + e3.bind('', validateAll) + e3.bind('', validateAll) + e4.bind('', validateAll) + e4.bind('', validateAll) + e5.bind('', validateAll) + e5.bind('', validateAll) + + def selectRadioButton(): + if var1.get()==1: + c2.config(state=DISABLED) + c3.config(state=DISABLED) + modeCombo.config(state=DISABLED) + e6.config(state=NORMAL) + else: + e6.config(state=DISABLED) + c2.config(state=NORMAL) + c3.config(state=NORMAL) + modeCombo.config(state=NORMAL) + + # Radiobuttons + var1 = IntVar() + c1 = Radiobutton(win, text='create new model', variable=var1, value=1, command=selectRadioButton) + c1.grid(row=7, column=0, sticky=W) + c1.select() + c1 = Radiobutton(win, text='use existing model', variable=var1, value=0, command=selectRadioButton) + c1.grid(row=8, column=0, sticky=W) + c1.config(state=DISABLED) + + # Textbox + e6 = Entry(justify=LEFT, width=19) + e6.grid(row=7, column=1) + e6.insert(INSERT, 'new_Model') + + # Combobox + n = StringVar() + lst = [] + modeCombo = ttk.Combobox(win, text='model', width=16, textvariable=n) + if lstOfModels: + c1.config(state=NORMAL) + for i in lstOfModels.name: + lst.append(i) + modeCombo['values'] = lst + modeCombo.current(0) + modeCombo.grid(row=8, column=1, sticky=W) + + # Checkboxes + var2 = IntVar() + c2 = Checkbutton(win, text='delete results', state=DISABLED, variable=var2, onvalue=1, offvalue=0) + c2.grid(row=9, column=0, sticky=W) + var3 = IntVar() + c3 = Checkbutton(win, text='delete_all model', state=DISABLED, variable=var3, onvalue=1, offvalue=0) + c3.grid(row=10, column=0, sticky=W) + + button1=Button(text='Run', anchor=CENTER, width=12, height=1, bg=color, state="normal") # width=16 + button1.grid(row=11, column=4) + button1.bind('', start) + + button2=Button(text='Close', anchor=CENTER, width=12, height=1, bg=color, state="normal") + button2.grid(row=11, column=3) + button2.bind('', close_window) + + win.mainloop() diff --git a/package/setup.py b/package/setup.py new file mode 100644 index 00000000..7642a58e --- /dev/null +++ b/package/setup.py @@ -0,0 +1,27 @@ +from setuptools import find_packages +from setuptools import setup +import pathlib + +here = pathlib.Path(__file__).parent +readme = (here/"README.md").read_text() + +setup( + name='RFEM', + version='1.4.0', + description='Web Service&API project for RFEM', + long_description=readme, + long_description_content_type = "text/markdown", + url="https://github.com/Dlubal-Software/RFEM_Python_Client", + author="Dlubal Software", + author_email="info@dlubal.com", + license="MIT", + classifiers=[ + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9" + ], + packages=find_packages(), + include_package_data=True, + install_requires=["suds", "requests", "suds_requests", "xmltodict", "setuptools==58.0.0"], + zip_safe = False +)