bb_dx = bbmax[0] - bbmin[0]
bb_dy = bbmax[1] - bbmin[1]
bb_dz = bbmax[2] - bbmin[2]
# Align shape to the center of axis system
shape.SetPos(
chrono.ChVectorD(-bb_dx / 2. - bbmin[0], -bb_dy / 2. - bbmin[1],
-bb_dz / 2. - bbmin[2]))
mysystem.Add(shape)
# Inferred mesh
inf_mesh_init = fea.ChMesh()
inf_mesh = fea.ChMesh()
inf_mesh_big = fea.ChMesh()
# Chrono visualization
viz_inf_mesh_init = fea.ChVisualizationFEAmesh(inf_mesh_init)
viz_inf_mesh_init.SetWireframe(True)
viz_inf_mesh_init.SetFEMglyphType(
fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
viz_inf_mesh_init.SetSymbolsThickness(1. * UNIT_FACTOR)
inf_mesh_init.AddAsset(viz_inf_mesh_init)
mysystem.AddMesh(inf_mesh_init)
viz_inf_mesh = fea.ChVisualizationFEAmesh(inf_mesh)
viz_inf_mesh.SetWireframe(True)
viz_inf_mesh.SetFEMglyphType(fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
viz_inf_mesh.SetSymbolsThickness(0.5 * UNIT_FACTOR)
inf_mesh.AddAsset(viz_inf_mesh)
mysystem.AddMesh(inf_mesh)
viz_inf_mesh_big = fea.ChVisualizationFEAmesh(inf_mesh_big)
element.SetStockAlpha(stock_alpha_EAS[0], stock_alpha_EAS[1],
stock_alpha_EAS[2], stock_alpha_EAS[3],
stock_alpha_EAS[4], stock_alpha_EAS[5],
stock_alpha_EAS[6], stock_alpha_EAS[7],
stock_alpha_EAS[8])
my_mesh.AddElement(element)
elemcount += 1
# Deactivate automatic gravity in mesh
my_mesh.SetAutomaticGravity(False)
my_system.Set_G_acc(chrono.ChVectorD(0, 0, -9.81))
# Remember to add the mesh to the system!
my_system.Add(my_mesh)
# Options for visualization in irrlicht
mvisualizemesh = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizemesh.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_NODE_P)
mvisualizemesh.SetShrinkElements(True, 0.85)
mvisualizemesh.SetSmoothFaces(False)
my_mesh.AddAsset(mvisualizemesh)
mvisualizemeshref = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizemeshref.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_SURFACE)
mvisualizemeshref.SetWireframe(True)
mvisualizemeshref.SetDrawInUndeformedReference(True)
my_mesh.AddAsset(mvisualizemeshref)
mvisualizemeshC = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizemeshC.SetFEMglyphType(
fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
mvisualizemeshC.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_SURFACE)
elif (x > T1 and x <= T2):
return A1 * w
elif (x > T2 and x <= T3):
return A1 * w + (A2 - A1) * w * (1.0 - m.cos(CH_C_PI * (x - T2) /
(T3 - T2))) / 2.0
else:
return A2 * w
f_ramp = ChFunction_myf()
#f_ramp = chrono.ChFunction_Sine(0,0.2,40)
rotmotor1.SetMotorFunction(f_ramp)
# Attach a visualization of the FEM mesh.
mvisualizebeamA = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizebeamA.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_SURFACE)
mvisualizebeamA.SetSmoothFaces(True)
my_mesh.AddAsset(mvisualizebeamA)
mvisualizebeamC = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizebeamC.SetFEMglyphType(fea.ChVisualizationFEAmesh.E_GLYPH_NODE_CSYS)
mvisualizebeamC.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_NONE)
mvisualizebeamC.SetSymbolsThickness(0.006)
mvisualizebeamC.SetSymbolsScale(0.01)
mvisualizebeamC.SetZbufferHide(False)
my_mesh.AddAsset(mvisualizebeamC)
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
# Set other element properties
element.SetAlphaDamp(0.0) # Structural damping for this element
element.SetGravityOn(
False) # turn internal gravitational force calculation off
# Add element to mesh
my_mesh.AddElement(element)
# Add the mesh to the system
my_system.Add(my_mesh)
# -------------------------------------
# Options for visualization in irrlicht
# -------------------------------------
visualizemeshA = fea.ChVisualizationFEAmesh(my_mesh)
visualizemeshA.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_NODE_SPEED_NORM)
visualizemeshA.SetColorscaleMinMax(0.0, 5.50)
visualizemeshA.SetShrinkElements(True, 0.85)
visualizemeshA.SetSmoothFaces(True)
my_mesh.AddAsset(visualizemeshA)
visualizemeshB = fea.ChVisualizationFEAmesh(my_mesh)
visualizemeshB.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_SURFACE)
visualizemeshB.SetWireframe(True)
visualizemeshB.SetDrawInUndeformedReference(True)
my_mesh.AddAsset(visualizemeshB)
visualizemeshC = fea.ChVisualizationFEAmesh(my_mesh)
visualizemeshC.SetFEMglyphType(fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
else:
elem.SetNodes(
fea_nodes[j + 1 + (i + 1) * na], # top right
fea_nodes[j + 1 + i * na], # top left
fea_nodes[j + i * na], # bottom left
fea_nodes[j + (i + 1) * na] # bottom right
)
elem.AddLayer(SHAPE_THICKNESS, 0 * chrono.CH_C_DEG_TO_RAD, material)
elem.SetAlphaDamp(alphadamp)
elem.SetAsNeutral()
mesh.AddElement(elem)
elements.append(elem)
viz = fea.ChVisualizationFEAmesh(mesh)
viz.SetWireframe(True)
viz.SetFEMglyphType(fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
viz.SetShellResolution(2)
viz.SetSymbolsThickness(0.02)
mesh.AddAsset(viz)
mvisualizebeamA = fea.ChVisualizationFEAmesh(mesh)
mvisualizebeamA.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_ELEM_BEAM_MZ)
mvisualizebeamA.SetColorscaleMinMax(-0.4, 0.4)
mvisualizebeamA.SetSmoothFaces(True)
mvisualizebeamA.SetWireframe(False)
mesh.AddAsset(mvisualizebeamA)
mysystem.AddMesh(mesh)
ref_X.AddPoint(0.60, 1 - 1.44)
ref_X.AddPoint(0.70, 1 - 1.52)
ref_X.AddPoint(0.80, 1 - 1.60)
ref_X.AddPoint(0.90, 1 - 1.66)
ref_X.AddPoint(1.00, 1 - 1.71)
# ==Asset== attach a visualization of the FEM mesh.
# This will automatically update a triangle mesh (a ChTriangleMeshShape
# asset that is internally managed) by setting proper
# coordinates and vertex colors as in the FEM elements.
# Such triangle mesh can be rendered by Irrlicht or POVray or whatever
# postprocessor that can handle a colored ChTriangleMeshShape).
# Do not forget AddAsset() at the end!
mvisualizeshellA = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizeshellA.SetSmoothFaces(True)
mvisualizeshellA.SetWireframe(True)
my_mesh.AddAsset(mvisualizeshellA)
mvisualizeshellC = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizeshellC.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_NONE)
mvisualizeshellC.SetFEMglyphType(fea.ChVisualizationFEAmesh.E_GLYPH_NODE_CSYS)
mvisualizeshellC.SetSymbolsThickness(0.05)
mvisualizeshellC.SetZbufferHide(False)
my_mesh.AddAsset(mvisualizeshellC)
# ==IMPORTANT!== Use this function for adding a ChIrrNodeAsset to all items
# in the system. These ChIrrNodeAsset assets are 'proxies' to the Irrlicht meshes.
# If you need a finer control on which item really needs a visualization proxy in
# Irrlicht, just use application.AssetBind(myitem) on a per-item basis.
def __init__(self,
sys,
gravity,
material,
width,
height,
position_base,
position_tip,
damping,
elements,
torque=10,
origin=True,
stator_constraint=None):
self.mesh = fea.ChMesh()
self.mesh.SetAutomaticGravity(gravity)
self.section = fea.ChBeamSectionAdvanced()
self.section.SetAsRectangularSection(width, height)
self.section.SetYoungModulus(material.modulus)
self.section.SetGshearModulus(material.shear)
self.section.SetDensity(material.density)
self.section.SetBeamRaleyghDamping(damping)
self.position_base = chrono.ChVectorD(*position_base)
self.position_tip = chrono.ChVectorD(*position_tip)
self.builder = fea.ChBuilderBeamEuler(
) #Use the beam builder assembly method to assembly each beam
self.builder.BuildBeam(
self.mesh,
self.section,
elements,
self.position_base,
self.position_tip,
chrono.ChVectorD(0, 1, 0),
)
self.stator = chrono.ChBodyEasyCylinder(0.01, 0.01, 1000)
self.stator.SetPos(self.position_base)
self.stator.SetBodyFixed(origin)
self.frame = chrono.ChFrameD(self.stator)
sys.Add(self.stator)
if (origin == False) and (
stator_constraint is not None
): #If the beam is not located at the origin, it must need to be constrained to another beam
self.constraint = chrono.ChLinkMateGeneric()
self.constraint.Initialize(self.stator, stator_constraint, False,
chrono.ChFrameD(self.stator),
chrono.ChFrameD(stator_constraint))
self.constraint.SetConstrainedCoords(True, True, True, True, True,
True)
sys.Add(self.constraint)
self.frame = chrono.ChFrameD(self.stator)
self.rotor = chrono.ChBodyEasyCylinder(0.011, 0.011, 1000)
self.rotor.SetPos(self.position_base)
sys.Add(self.rotor)
self.frame.SetRot(
chrono.Q_from_AngAxis(chrono.CH_C_PI_2, chrono.VECT_X)
) #Rotate the direction of rotation to be planar (x-z plane)
self.motor = chrono.ChLinkMotorRotationTorque()
self.motor.Initialize(self.rotor, self.stator, self.frame)
sys.Add(self.motor)
self.motor.SetTorqueFunction(chrono.ChFunction_Const(torque))
self.arm_base = (self.builder.GetLastBeamNodes().front())
self.arm_tip = (self.builder.GetLastBeamNodes().back())
self.mate = chrono.ChLinkMateGeneric()
self.mate.Initialize(self.builder.GetLastBeamNodes().front(),
self.rotor,
chrono.ChFrameD(self.builder.GetLastBeamNodes(
).front().GetPos())) #constrain beam to rotor
self.mate.SetConstrainedCoords(
True, True, True, True, True, True
) #constraints must be in format: (True,True,True,True,True,True) to constrain x,y,z,rotx,roty,rotz coordinates
sys.Add(self.mate)
self.visual = fea.ChVisualizationFEAmesh(self.mesh)
self.visual.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_ELEM_BEAM_MZ)
self.visual.SetColorscaleMinMax(-1.4, 1.4)
self.visual.SetSmoothFaces(True)
self.visual.SetWireframe(False)
self.mesh.AddAsset(self.visual)
sys.Add(self.mesh)
# TODO check for a generic way of computing the expanding force
sleeve.expand(1 / (NNODES_ANGLE * NNODES_LENGTH) * 7000000. * UNIT_FACTOR *
bb_dx)
# ---------------------------------------------------------------------
# OPTIMISATION SETUP
# Prepare the visualization of the optimisation algorithm
# Mesh computed by the physical simulation
target_mesh = fea.ChMesh()
# The mesh that will approximate the target mesh
inf_mesh = fea.ChMesh()
# # ---------------------------------------------------------------------
# # VISUALIZATION
mvisualizeClothcoll = fea.ChVisualizationFEAmesh(cloth_mesh)
mvisualizeClothcoll.SetWireframe(True)
mvisualizeClothcoll.SetFEMglyphType(
fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
mvisualizeClothcoll.SetSymbolsThickness(1. * UNIT_FACTOR)
#cloth_mesh.AddAsset(mvisualizeClothcoll)
viz_cloth = fea.ChVisualizationFEAmesh(inf_mesh)
viz_cloth.SetWireframe(True)
viz_cloth.SetFEMglyphType(fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
viz_cloth.SetFEMdataType(fea.ChVisualizationFEAmesh.E_PLOT_NONE)
viz_cloth.SetSymbolsThickness(0.005)
# viz_cloth.SetDefaultSymbolsColor(chrono.ChColor(0.2,0.3,0.2)) # TODO bug lib
# viz_cloth.SetDefaultMeshColor(chrono.ChColor(0.2,0.3,0.2)) # TODO bug lib
inf_mesh.AddAsset(viz_cloth)
def set_visualization(
self,
original_wireframe: bool = False,
display_nodes: bool = False,
node_thikness: float = 0.015,
display_surf: bool = False,
smooth_surf: bool = True,
display_contact: bool = False,
) -> None:
"""
Set how the mesh will be displayed in the simulation.
Multiple calls to this methods does not overwrite the previous visualization,
but displays all the visualizations set
Based on demo_FEA_brick.py by Simone Benatti
Args:
original_wireframe: display the original structure as wireframe
display_nodes: display a cube on each node
node_thikness: size of the (visual) node
display_surf: display the surface of the mesh
smooth_surf: use smooth shading for the surface
display_contact: display the contact mesh
Returns:
None
"""
# TODO show the wireframe alone
# Original ref
if original_wireframe:
visualization = fea.ChVisualizationFEAmesh(self._mesh)
visualization.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_SURFACE)
visualization.SetWireframe(True)
visualization.SetDrawInUndeformedReference(True)
self._mesh.AddAsset(visualization)
# Node Position
if display_nodes:
visualization = fea.ChVisualizationFEAmesh(self._mesh)
visualization.SetFEMglyphType(
fea.ChVisualizationFEAmesh.E_GLYPH_NODE_DOT_POS)
visualization.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_SURFACE)
visualization.SetSymbolsThickness(node_thikness)
self._mesh.AddAsset(visualization)
# Surface
if display_surf:
visualization = fea.ChVisualizationFEAmesh(self._mesh)
visualization.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_NODE_P)
visualization.SetSmoothFaces(smooth_surf)
self._mesh.AddAsset(visualization)
# Contact
if display_contact:
visualization = fea.ChVisualizationFEAmesh(self._mesh)
visualization.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_CONTACTSURFACES)
visualization.SetWireframe(True)
visualization.SetDefaultMeshColor(chrono.ChColor(1, 0.5, 0))
self._mesh.AddAsset(visualization)
# Remember to add the mesh to the system!
my_system.Add(my_mesh_beams)
#
# Optional... visualization
#
# ==Asset== attach a visualization of the FEM mesh.
# This will automatically update a triangle mesh (a ChTriangleMeshShape
# asset that is internally managed) by setting proper
# coordinates and vertex colors as in the FEM elements.
# Such triangle mesh can be rendered by Irrlicht or POVray or whatever
# postprocessor that can handle a colored ChTriangleMeshShape).
# Do not forget AddAsset() at the end!
mvisualizemesh = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizemesh.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_NODE_SPEED_NORM)
mvisualizemesh.SetColorscaleMinMax(0.0, 5.50)
mvisualizemesh.SetSmoothFaces(True)
my_mesh.AddAsset(mvisualizemesh)
mvisualizemeshcoll = fea.ChVisualizationFEAmesh(my_mesh)
mvisualizemeshcoll.SetFEMdataType(
fea.ChVisualizationFEAmesh.E_PLOT_CONTACTSURFACES)
mvisualizemeshcoll.SetWireframe(True)
mvisualizemeshcoll.SetDefaultMeshColor(chrono.ChColor(1, 0.5, 0))
my_mesh.AddAsset(mvisualizemeshcoll)
mvisualizemeshbeam = fea.ChVisualizationFEAmesh(my_mesh_beams)
mvisualizemeshbeam.SetFEMdataType(
