def __deepcopy__(self, memo):
system = copy.copy(self)
mesh = self.plotter.mesh
system.plotter = None
system.post_processor = None
system.plot_values = None
system.__dict__ = copy.deepcopy(system.__dict__)
system.plotter = plotter.Plotter(system, mesh)
system.post_processor = post_sl(system)
system.plot_values = plotter.PlottingValues
return system
def __init__(self, figsize=(12, 8), EA=15e3, EI=5e3, load_factor=1, mesh=50):
"""
* E = Young's modulus
* A = Area
* I = Moment of Inertia
:param figsize: (tpl) Set the standard plotting size.
:param EA: (flt) Standard E * A. Set the standard values of EA if none provided when generating an element.
:param EI: (flt) Standard E * I. Set the standard values of EA if none provided when generating an element.
:param load_factor: (flt) Multiply all loads with this factor.
:param mesh: (int) Plotting mesh. Has no influence on the calculation.
"""
# init object
self.post_processor = post_sl(self)
self.plotter = plotter.Plotter(self, mesh)
self.plot_values = plotter.PlottingValues(self, mesh)
# standard values if none provided
self.EA = EA
self.EI = EI
self.figsize = figsize
self.orientation_cs = -1 # needed for the loads directions
# structure system
self.element_map = {} # maps element ids to the Element objects.
self.node_map = {} # maps node ids to the Node objects.
self.node_element_map = {} # maps node ids to Element objects
# keys matrix index (for both row and columns), values K, are processed assemble_system_matrix
self.system_spring_map = {}
# list of indexes that remain after conditions are applied
self._remainder_indexes = []
# keep track of the node_id of the supports
self.supports_fixed = []
self.supports_hinged = []
self.supports_roll = []
self.supports_spring_x = []
self.supports_spring_z = []
self.supports_spring_y = []
self.supports_roll_direction = []
self.inclined_roll = (
{}
) # map node ids to inclination angle relative to global x-axis.
# save tuples of the arguments for copying purposes.
self.supports_spring_args = []
# keep track of the loads
self.loads_point = {} # node ids with a point loads
self.loads_q = {} # element ids with a q-load
self.loads_moment = {}
self.loads_dead_load = set() # element ids with q-load due to dead load
# results
self.reaction_forces = {} # node objects
self.non_linear = False
self.non_linear_elements = (
{}
) # keys are element ids, values are dicts: {node_index: max moment capacity}
self.buckling_factor = None
# previous point of element
self._previous_point = Vertex(0, 0)
self.load_factor = load_factor
# Objects state
self.count = 0
self.system_matrix_locations = []
self.system_matrix = None
self.system_force_vector = None
self.system_displacement_vector = None
self.shape_system_matrix = None
self.reduced_force_vector = None
self.reduced_system_matrix = None
self._vertices = {} # maps vertices to node ids