def createApplication(self):
# Create an Irrlicht application to visualize the system
self.myapplication = chronoirr.ChIrrApp(
self.mysystem, 'PyChrono example',
chronoirr.dimension2du(1024, 768))
self.myapplication.AddTypicalSky()
self.myapplication.AddTypicalLogo()
self.myapplication.AddTypicalCamera(chronoirr.vector3df(0.6, 0.6, 0.8))
self.myapplication.AddLightWithShadow(
chronoirr.vector3df(2, 4, 2), # point
chronoirr.vector3df(0, 0, 0), # aimpoint
9, # radius (power)
1,
9, # near, far
30) # angle of FOV
# ==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.
self.myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
# that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
self.myapplication.AssetUpdateAll()
self.myapplication.AddShadowAll()
self.myapplication.SetShowInfos(True)
def render(self):
if not self.render_setup :
self.myapplication = chronoirr.ChIrrApp(self.ant_sys)
self.myapplication.AddShadowAll()
self.myapplication.SetTimestep(self.timestep)
self.myapplication.AddTypicalSky(chrono.GetChronoDataPath() + '/skybox/')
self.myapplication.AddTypicalCamera(chronoirr.vector3df(0,1.5,0))
self.myapplication.AddLightWithShadow(chronoirr.vector3df(4,4,0), # point
chronoirr.vector3df(0,0,0), # aimpoint
20, # radius (power)
1,9, # near, far
90) # angle of FOV
self.myapplication.AssetBindAll()
self.myapplication.AssetUpdateAll()
self.render_setup = True
self.myapplication.GetDevice().run()
self.myapplication.BeginScene()
self.myapplication.DrawAll()
#self.myapplication.DoStep()
self.myapplication.EndScene()
def run_visible(self):
visible_sim = chronoirr.ChIrrApp(self.system, 'Falling',
chronoirr.dimension2du(1024, 768))
# visible_sim.AddTypicalSky()
# visible_sim.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
visible_sim.AddTypicalCamera(chronoirr.vector3df(0, 14, -20))
visible_sim.AddTypicalLights()
visible_sim.AssetBindAll()
visible_sim.AssetUpdateAll()
visible_sim.SetTimestep(0.02)
visible_sim.SetTryRealtime(True)
start_t = time.time()
while visible_sim.GetDevice().run():
visible_sim.BeginScene()
visible_sim.DrawAll()
visible_sim.DoStep()
visible_sim.EndScene()
# break if velocity and rotational velocity is below threshold
if self.is_settled():
break
end_t = time.time()
duration = end_t - start_t
self.post_run(duration, silent=False)
def render(self):
if not self.animate:
print(
'It seems that for efficiency reasons visualization has been turned OFF. To render the simulation set self.animate = True in ChronoHexapod.py'
)
sys.exit(1)
if not self.render_setup:
self.myapplication = chronoirr.ChIrrApp(
self.hexapod_sys, 'Test', chronoirr.dimension2du(1280, 720))
self.myapplication.AddShadowAll()
self.myapplication.SetStepManage(True)
self.myapplication.SetTimestep(self.timestep)
self.myapplication.AddTypicalSky(chrono.GetChronoDataPath() +
'/skybox/')
self.myapplication.AddTypicalLogo(chrono.GetChronoDataPath() +
'/logo_pychrono_alpha.png')
self.myapplication.AddTypicalCamera(
chronoirr.vector3df(1, 1, 1),
chronoirr.vector3df(0.0, 0.0, 0.0))
self.myapplication.AddTypicalLights(
) # angle of FOV # angle of FOV
self.myapplication.AssetBindAll()
self.myapplication.AssetUpdateAll()
self.render_setup = True
#self.myapplication.GetSceneManager().getActiveCamera().setPosition(chronoirr.vector3df(self.centralbody.GetPos().x - 0.75 , 0.4, self.centralbody.GetPos().z + 0.25))
#self.myapplication.GetSceneManager().getActiveCamera().setTarget(chronoirr.vector3df(self.centralbody.GetPos().x , 0.25, self.centralbody.GetPos().z))
self.myapplication.GetDevice().run()
self.myapplication.BeginScene()
self.myapplication.DrawAll()
self.myapplication.EndScene()
def SetupSystem():
ChSystem = chrono.ChSystemNSC()
ChSimulation = chronoirr.ChIrrApp(ChSystem, 'MiroSimulation', chronoirr.dimension2du(1720, 920))
# Set the default outward/inward shape margins for collision detection,
# this is epecially important for very large or very small objects.
chrono.ChCollisionModel.SetDefaultSuggestedEnvelope(0.0000001)
chrono.ChCollisionModel.SetDefaultSuggestedMargin(0.0001)
# Maybe you want to change some settings for the solver. For example you
# might want to use SetSolverMaxIterations to set the number of iterations
# per timestep, etc.
#MiroSystem.ChSystem.SetSolverType(chrono.ChSolver.Type_BARZILAIBORWEIN) # precise, more slow
ChSystem.SetSolverMaxIterations(70)
return [ChSystem, ChSimulation]
def main():
mysystem = chrono.ChSystemNSC()
model.make_model(mysystem)
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(mysystem, 'Oswald',
chronoirr.dimension2du(1024, 768))
# myapplication.AddTypicalSky()
# myapplication.AddShadowAll()
myapplication.AddTypicalLogo()
myapplication.AddTypicalCamera(chronoirr.vector3df(0.6, 0.6, 0.8))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
# that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
myapplication.AssetUpdateAll()
# ---------------------------------------------------------------------
#
# Run the simulation
#
myapplication.SetTimestep(0.005)
# myapplication.SetTryRealtime(True)
while myapplication.GetDevice().run():
myapplication.BeginScene()
myapplication.DrawAll()
myapplication.DoStep()
myapplication.EndScene()
def window(self,
arm1,
arm2,
print_time=False,
timestep=0.005,
headless=True):
if not headless:
self.window = chronoirr.ChIrrApp(
self.system, self.name,
chronoirr.dimension2du(1920,
1080)) #Create window for visualization
self.window.AddTypicalCamera(chronoirr.vector3df(1, 1, 2))
self.window.AddTypicalLights()
self.window.AddTypicalSky()
self.window.AssetBindAll()
self.window.AssetUpdateAll()
self.window.SetTimestep(timestep)
self.window.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
while (self.window.GetDevice().run()
): #create a window and display simulation
s = time.perf_counter()
self.window.BeginScene()
self.window.DrawAll()
motor_torque(arm1)
motor_torque(arm2)
self.window.DoStep()
print(arm1.arm_tip.GetPos())
self.window.EndScene()
if print_time == True:
print(time.perf_counter() - s)
else:
while (self.system.GetChTime() <
10): #Run simulation without viewing
motor_torque(arm1)
motor_torque(arm2)
self.system.DoStepDynamics(timestep)
print(arm1.arm_tip.GetPos())
if print_time == True:
print(time.perf_counter() - s)
def animateSystem(system, am=animationModifiers()):
"""
animate the system using the chrono
"""
# -------------------------------------------------------------------------
# Create an Irrlicht application to visualize the system
# -------------------------------------------------------------------------
myapplication = chronoirr.ChIrrApp(system, 'PyChrono example',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalSky()
myapplication.AddTypicalLogo()
myapplication.AddTypicalCamera(chronoirr.vector3df(0.6, 0.6, 0.8))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
# that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
myapplication.AssetUpdateAll()
# -------------------------------------------------------------------------
# Run the simulation
# -------------------------------------------------------------------------
myapplication.SetTimestep(0.005)
while (myapplication.GetDevice().run()):
myapplication.BeginScene()
myapplication.DrawAll()
am.draw(myapplication)
myapplication.DoStep()
myapplication.EndScene()
def window(
self,
arm1,
arm2,
timestep,
print_time=False,
headless=True,
):
if not headless:
self.window = chronoirr.ChIrrApp(
self.system, self.name,
chronoirr.dimension2du(1920,
1080)) #Create window for visualization
self.window.AddTypicalCamera(chronoirr.vector3df(1, 1, 2))
self.window.AddTypicalLights()
self.window.AddTypicalSky()
self.window.AssetBindAll()
self.window.AssetUpdateAll()
self.window.SetTimestep(timestep)
self.window.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
def render(self):
if not self.render_setup:
self.myapplication = chronoirr.ChIrrApp(
self.robosystem, 'Test', chronoirr.dimension2du(1280, 720))
self.myapplication.AddShadowAll()
self.myapplication.SetStepManage(True)
self.myapplication.SetTimestep(self.timestep)
self.myapplication.AddTypicalSky(chrono.GetChronoDataPath() +
'/skybox/')
self.myapplication.AddTypicalLogo(chrono.GetChronoDataPath() +
'/logo_pychrono_alpha.png')
self.myapplication.AddTypicalCamera(
chronoirr.vector3df(1, 1, 1),
chronoirr.vector3df(0.0, 0.0, 0.0))
self.myapplication.AddTypicalLights() # angle of FOV
self.myapplication.AssetBindAll()
self.myapplication.AssetUpdateAll()
self.render_setup = True
self.myapplication.GetDevice().run()
self.myapplication.BeginScene()
self.myapplication.DrawAll()
self.myapplication.EndScene()
# Create a large cube as a floor.
my_floor = chrono.ChBodyEasyBox(1, 0.2, 1, 1000, True)
my_floor.SetPos(chrono.ChVectorD(0, -0.3, 0))
my_floor.SetBodyFixed(True)
mysystem.Add(my_floor)
my_color = chrono.ChColorAsset(0.2, 0.2, 0.5)
my_floor.AddAsset(my_color)
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(mysystem, 'Use OpenCascade shapes',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalSky(chrono.GetChronoDataPath() + 'skybox/')
myapplication.AddTypicalLogo(chrono.GetChronoDataPath() +
'logo_pychrono_alpha.png')
myapplication.AddTypicalCamera(chronoirr.vector3df(0.2, 0.2, -0.2))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
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)
# ---------------------------------------------------------------------
# IRRLICHT
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(mysystem, 'Cloth Simulation',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalSky()
# myapplication.AddTypicalLogo(chrono.GetChronoDataPath() + 'logo_pychrono_alpha.png')
myapplication.AddTypicalCamera(chronoirr.vector3df(0.3, 0., 0.3))
myapplication.AddTypicalLights()
myapplication.SetShowInfos(False)
# myapplication.SetContactsDrawMode(chronoirr.IrrlichtDevice.)
# ==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.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
#import pychrono.mkl as mkl
import pychrono.irrlicht as chronoirr
from cables import Model1, Model2, Model3
# Select solver type (SPARSE_QR, SPARSE_LU, or MINRES).
#ChSolver::Type solver_type = ChSolver::Type::SPARSE_QR
solver = chrono.ChSolverSparseQR()
print("Copyright (c) 2017 projectchrono.org\nChrono version: ")
# Create a Chrono::Engine physical system
my_system = chrono.ChSystemSMC()
# Create the Irrlicht visualization (open the Irrlicht device,
# bind a simple user interface, etc. etc.)
application = chronoirr.ChIrrApp(my_system, "Cables FEM",
chronoirr.dimension2du(800, 600), False, True)
# Easy shortcuts to add camera, lights, logo and sky in Irrlicht scene:
application.AddTypicalLogo()
application.AddTypicalSky()
application.AddTypicalLights()
application.AddTypicalCamera(chronoirr.vector3df(0., 0.6, -1))
# Create a mesh, that is a container for groups of elements and
# their referenced nodes.
my_mesh = fea.ChMesh()
# Create one of the available models (defined in FEAcables.h)
##model = Model1(my_system, my_mesh)
##model = Model2(my_system, my_mesh)
model = Model3(my_system, my_mesh)
vshape_s.GetSphereGeometry().Pos = ball.GetPos()
ball.AddAsset(vshape_s)
ball.AddAsset(
chrono.ChTexture(chrono.GetChronoDataFile("textures/bluewhite.png")))
# Create a custom collision detection callback object and register it with the system
my_collision = MyCustomCollisionDetection(ball, ground, ball_mat, obst_mat,
ball_radius, obstacle)
sys.RegisterCustomCollisionCallback(my_collision)
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(sys, 'PyChrono example: Custom contact',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalSky()
myapplication.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
myapplication.AddTypicalCamera(chronoirr.vector3df(8, 8, -6))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
dist_crank_slider = chrono.ChLinkDistance()
dist_crank_slider.SetName("dist_crank_slider")
dist_crank_slider.Initialize(crank, slider, False, chrono.ChVectorD(-2, 0, 0),
chrono.ChVectorD(2, 0, 0))
system.AddLink(dist_crank_slider)
## 4. Write the system hierarchy to the console (default log output destination)
system.ShowHierarchy(chrono.GetLog())
## 5. Prepare visualization with Irrlicht
## Note that Irrlicht uses left-handed frames with Y up.
## Create the Irrlicht application and set-up the camera.
application = chronoirr.ChIrrApp(
system, ## pointer to the mechanical system
"Slider-Crank Demo 0", ## title of the Irrlicht window
chronoirr.dimension2du(800, 600), ## window dimension (width x height)
False, ## use full screen?
True) ## enable shadows?
application.AddTypicalLogo()
application.AddTypicalSky()
application.AddTypicalLights()
application.AddTypicalCamera(
chronoirr.vector3df(2, 5, -3), ## camera location
chronoirr.vector3df(2, 0, 0)) ## "look at" location
## Let the Irrlicht application convert the visualization assets.
application.AssetBindAll()
application.AssetUpdateAll()
## 6. Perform the simulation.
## Specify the step-size.
application.SetTimestep(0.01)
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
#
# Create the Irrlicht visualization (open the Irrlicht device,
# bind a simple user interface, etc. etc.)
myapplication = chronoirr.ChIrrApp(
my_system, 'Test FEA: the Jeffcott rotor with IGA beams',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
myapplication.AddTypicalSky()
myapplication.AddTypicalCamera(chronoirr.vector3df(0, 1, 4),
chronoirr.vector3df(beam_L / 2, 0, 0))
myapplication.AddTypicalLights()
# This is needed if you want to see things in Irrlicht 3D view.
myapplication.AssetBindAll()
myapplication.AssetUpdateAll()
# ---------------------------------------------------------------------
#
mbodyR.SetMaterialSurface(brick_material)
mysystem.Add(mbodyR)
if not (fixed_L):
mbodyG = chrono.ChBodyEasyBox(1, 0.5, thick * 2.2, 1000, True, True)
mbodyG.SetPos(chrono.ChVectorD(-1, L2.y - 0.5 / 2, 0))
mbodyG.SetBodyFixed(True)
mbodyG.SetMaterialSurface(brick_material)
mysystem.Add(mbodyG)
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(mysystem, 'Test',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
myapplication.AddTypicalSky()
myapplication.AddTypicalCamera(chronoirr.vector3df(0.6, 0.6, 0.8))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
def __init__(self,
configuration,
visualization: bool = False,
output: Optional = None) -> None:
# TODO a copy of the configuration is better
self._conf = configuration
self._visualization = visualization
self._output = output
self._app = None
# TODO not sure about the meaning of theese two parameters, take them from the configuation
chrono.ChCollisionInfo.SetDefaultEffectiveCurvatureRadius(1)
chrono.ChCollisionModel.SetDefaultSuggestedMargin(0.006)
# TODO look into the parameters of the system
# e.g. MinBounceSpeed, Gravity
self._system = chrono.ChSystemSMC()
if self._visualization:
# TODO take the data path, the title, the dimension and do_[something] from the configuration
chrono.SetChronoDataPath(
"/home/gianluca/anaconda3/envs/chrono/share/chrono/data/")
self._app = irr.ChIrrApp(
self._system,
"Artificial Skin",
irr.dimension2du(1024, 768),
do_fullscreen=False,
do_shadows=True,
do_antialias=True,
)
self._app.AddTypicalSky()
self._app.AddTypicalLights()
# TODO take the info for the came and lighs from the configuation
self._app.AddTypicalCamera(irr.vector3df(-1, -1, 0),
irr.vector3df(0, 0, 0))
# TODO this has too many parameters and it is not that important
self._app.AddLightWithShadow(
irr.vector3df(1.5, 5.5, -2.5),
irr.vector3df(0, 0, 0),
3,
2.2,
7.2,
40,
512,
irr.SColorf(1, 1, 1),
)
self._app.AddShadowAll()
self._app.SetTimestep(0.004)
self._make_sheets()
self._make_sensors()
# TODO make the load class -> it takes a node / pair of indexes and time and return the force
self._add_forces()
# TODO look at all the parameters of the solver and the stepper
# TODO consider also mkl.ChSolverMKL
# TODO take the parameters from the configuration
self._solver = chrono.ChSolverMINRES()
self._system.SetSolver(self._solver)
self._solver.SetMaxIterations(1000)
self._solver.SetTolerance(1e-12)
self._solver.EnableDiagonalPreconditioner(True)
self._solver.SetVerbose(
False) # don't take this from the configuration
# HHT implicit integrator for II order systems, adaptive
# TODO take the parameters from the configuaration
self._stepper = chrono.ChTimestepperHHT(self._system)
self._system.SetTimestepper(self._stepper)
self._stepper.SetAlpha(-0.2)
self._stepper.SetMaxiters(100)
self._stepper.SetAbsTolerances(1e-5)
self._stepper.SetMode(chrono.ChTimestepperHHT.POSITION)
self._stepper.SetScaling(True)
# TODO from configuarion
# length of the simulation
self._life = 5 # seconds
robot.SetDriver(driver)
# -------------------------------
# Cast rays into collision models
# -------------------------------
caster = RayCaster(
my_sys,
chrono.ChFrameD(chrono.ChVectorD(0, -2, -1),
chrono.Q_from_AngX(-chrono.CH_C_PI_2)), [2.5, 2.5], 0.02)
# -------------------------------
# Create the visualization window
# -------------------------------
application = chronoirr.ChIrrApp(my_sys, "RoboSimian - Rigid terrain",
chronoirr.dimension2du(800, 600))
application.AddTypicalLogo(chrono.GetChronoDataPath() +
'logo_pychrono_alpha.png')
application.AddTypicalSky()
application.AddTypicalCamera(chronoirr.vector3df(1, -2.75, 0.2),
chronoirr.vector3df(1, 0, 0))
application.AddTypicalLights(chronoirr.vector3df(100, 100, 100),
chronoirr.vector3df(100, -100, 80))
application.AddLightWithShadow(chronoirr.vector3df(10, -6, 3),
chronoirr.vector3df(0, 0, 0), 3, -10, 10, 40,
512)
application.AssetBindAll()
application.AssetUpdateAll()
# -----------------------------
# Print exported items
for my_item in exported_items:
print(my_item.GetName())
# Add items to the physical system
for my_item in exported_items:
my_system.Add(my_item)
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
print(chrono.GetChronoDataFile("skybox/"))
myapplication = chronoirr.ChIrrApp(
my_system, 'Test: using data exported by Chrono::Solidworks',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalSky()
myapplication.AddTypicalLogo(chrono.GetChronoDataPath() +
'logo_pychrono_alpha.png')
myapplication.AddTypicalCamera(chronoirr.vector3df(0.3, 0.3, 0.4))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
# =============================================================================
import math as m
import pychrono as chrono
import pychrono.fea as fea
import pychrono.mkl as mkl
import pychrono.irrlicht as chronoirr
import numpy as np
print("Copyright (c) 2017 projectchrono.org")
my_system = chrono.ChSystemSMC()
# Create the Irrlicht visualization (open the Irrlicht device,
# bind a simple user interface, etc. etc.)
application = chronoirr.ChIrrApp(my_system, "Brick Elements",
chronoirr.dimension2du(800, 600), False, True)
# Easy shortcuts to add camera, lights, logo and sky in Irrlicht scene:
application.AddTypicalLogo()
application.AddTypicalSky()
application.AddTypicalLights()
application.AddTypicalCamera(
chronoirr.vector3df(1.2, 0.6, 0.3), # camera location
chronoirr.vector3df(0.2, -0.2, 0.)) # "look at" location
print("-----------------------------------------------------------")
print("-----------------------------------------------------------")
print(" Brick Elements demo with implicit integration ")
print("-----------------------------------------------------------")
# geometries (which would be inefficient)
#
# =============================================================================
import pychrono as chrono
import pychrono.irrlicht as chronoirr
import math as m
print("Copyright (c) 2017 projectchrono.org")
# Create a Chrono::Engine physical system
mphysicalSystem = chrono.ChSystemNSC()
# Create the Irrlicht visualization (open the Irrlicht device,
# bind a simple user interface, etc, etc.)
application = chronoirr.ChIrrApp(mphysicalSystem, "Gears annd pulleys",
chronoirr.dimension2du(800, 600), False)
# Easy shortcuts to add camera, lights, logo, and sky in Irrlicht scene:
application.AddTypicalLogo()
application.AddTypicalSky()
application.AddTypicalLights()
application.AddTypicalCamera(chronoirr.vector3df(12, 15, -20))
# Contact material shared among all bodies
mat = chrono.ChMaterialSurfaceNSC()
# Create all rigid bodies.
radA = 2
radB = 4
ampl = 4
omg = 2 * chrono.CH_C_PI * freq
mod = chrono.ChFunction_Sine(0, freq, ampl)
# Actuate first slider using a link force
prismatic1.GetForce_Z().SetActive(True)
prismatic1.GetForce_Z().SetF(1)
prismatic1.GetForce_Z().SetModulationF(mod)
# Actuate second slider using a body force
frc2 = chrono.ChForce()
frc2.SetF_x(mod)
slider2.AddForce(frc2)
# Create the Irrlicht application
application = irr.ChIrrApp(system, "Actuated prismatic joint",
irr.dimension2du(800, 600), False, True)
application.AddTypicalLogo()
application.AddTypicalSky()
application.AddTypicalLights()
application.AddTypicalCamera(irr.vector3df(-1, 1.5, -6))
application.AssetBindAll()
application.AssetUpdateAll()
application.SetTimestep(1e-3)
x0 = slider1.GetPos().x
while application.GetDevice().run():
time = system.GetChTime()
0, # Mohr cohesive limit (Pa)
30, # Mohr friction limit (degrees)
0.01, # Janosi shear coefficient (m)
4e7, # Elastic stiffness (Pa/m), before plastic yield, must be > Kphi
3e4 # Damping (Pa s/m), proportional to negative vertical speed (optional)
)
# Set terrain visualization mode
terrain.SetPlotType(veh.SCMDeformableTerrain.PLOT_PRESSURE, 0, 30000.2)
# ------------------------------------------
# Create the Irrlicht run-time visualization
# ------------------------------------------
myapplication = chronoirr.ChIrrApp(mysystem, 'Deformable soil',
chronoirr.dimension2du(1280, 720), False,
True)
myapplication.AddTypicalSky()
myapplication.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
myapplication.AddTypicalCamera(chronoirr.vector3df(2.0, 1.4, 0.0),
chronoirr.vector3df(0, tire_rad, 0))
myapplication.AddTypicalLights()
myapplication.AddLightWithShadow(
chronoirr.vector3df(1.5, 5.5, -2.5), # point
chronoirr.vector3df(0, 0, 0), # aim point
3, # radius (power)
2.2,
7.2, # near, far
40, # angle of FOV
512, # resoluition
def __init__(self, render):
self.animate = render
self.observation_space = np.empty([30,])
self.action_space = np.zeros([8,])
self.info = {}
# ---------------------------------------------------------------------
#
# Create the simulation system and add items
#
self.Xtarg = 1000.0
self.Ytarg = 0.0
self.d_old = np.linalg.norm(self.Xtarg + self.Ytarg)
self.ant_sys = chrono.ChSystemNSC()
# Set the default outward/inward shape margins for collision detection,
# this is epecially important for very large or very small objects.
chrono.ChCollisionModel.SetDefaultSuggestedEnvelope(0.001)
chrono.ChCollisionModel.SetDefaultSuggestedMargin(0.001)
#ant_sys.SetSolverType(chrono.ChSolver.Type_BARZILAIBORWEIN) # precise, more slow
self.ant_sys.SetSolverMaxIterations(70)
self.ant_material = chrono.ChMaterialSurfaceNSC()
self.ant_material.SetFriction(0.5)
self.ant_material.SetDampingF(0.2)
self.ant_material.SetCompliance (0.0005)
self.ant_material.SetComplianceT(0.0005)
self.timestep = 0.01
self.abdomen_x = 0.25
self.abdomen_y = 0.25
self.abdomen_z = 0.25
self.leg_density = 250 # kg/m^3
self.abdomen_density = 100
self.abdomen_y0 = 0.4
self.leg_length = 0.3
self.leg_radius = 0.04
self.ankle_angle = 60*(math.pi/180)
self.ankle_length = 0.4
self.ankle_radius = 0.04
self.gain = 30
self.abdomen_mass = self.abdomen_density * ((4/3)*chrono.CH_C_PI*self.abdomen_x*self.abdomen_y*self.abdomen_z)
self.abdomen_inertia = chrono.ChVectorD((1/5)*self.abdomen_mass*(pow(self.abdomen_y,2)+pow(self.abdomen_z,2)),(1/5)*self.abdomen_mass*(pow(self.abdomen_x,2)+pow(self.abdomen_z,2)),(1/5)*self.abdomen_mass*(pow(self.abdomen_y,2)+pow(self.abdomen_x,2)))
self.leg_mass = self.leg_density * self.leg_length * math.pi* pow (self.leg_radius,2)
self.leg_inertia = chrono.ChVectorD(0.5*self.leg_mass*pow(self.leg_radius,2), (self.leg_mass/12)*(3*pow(self.leg_radius,2)+pow(self.leg_length,2)),(self.leg_mass/12)*(3*pow(self.leg_radius,2)+pow(self.leg_length,2)))
self.ankle_mass = self.leg_density * self.ankle_length * math.pi* pow (self.ankle_radius,2)
self.ankle_inertia = chrono.ChVectorD(0.5*self.ankle_mass*pow(self.ankle_radius,2), (self.ankle_mass/12)*(3*pow(self.ankle_radius,2)+pow(self.ankle_length,2)),(self.ankle_mass/12)*(3*pow(self.ankle_radius,2)+pow(self.ankle_length,2)))
self.leg_limit = chrono.ChLinkLimit()
self.ankle_limit = chrono.ChLinkLimit()
self.leg_limit.SetRmax(math.pi/9)
self.leg_limit.SetRmin(-math.pi/9)
self.ankle_limit.SetRmax(math.pi/9)
self.ankle_limit.SetRmin(-math.pi/9)
if (self.animate) :
self.myapplication = chronoirr.ChIrrApp(self.ant_sys)
self.myapplication.AddShadowAll()
self.myapplication.SetStepManage(True)
self.myapplication.SetTimestep(self.timestep)
self. myapplication.SetTryRealtime(True)
self.myapplication.AddTypicalSky()
self.myapplication.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
self.myapplication.AddTypicalCamera(chronoirr.vector3df(0,1.5,0))
self.myapplication.AddLightWithShadow(chronoirr.vector3df(4,4,0), # point
chronoirr.vector3df(0,0,0), # aimpoint
20, # radius (power)
1,9, # near, far
90) # angle of FOV
def CastNode(nb):
feaNB = fea.CastToChNodeFEAbase(nb)
nodeFead = fea.CastToChNodeFEAxyzD(feaNB)
return nodeFead
chrono.SetChronoDataPath("../../../data/")
time_step = 1e-3
my_system = chrono.ChSystemSMC()
my_system.Set_G_acc(chrono.ChVectorD(0, 0, -9.8))
# Create the Irrlicht visualization (open the Irrlicht device, bind a simple user interface, etc.)
application = chronoirr.ChIrrApp(my_system, "ANCF Shells",
chronoirr.dimension2du(800, 600), False, True)
# Easy shortcuts to add camera, lights, logo and sky in Irrlicht scene:
application.AddTypicalLogo()
application.AddTypicalSky()
application.AddTypicalLights()
application.AddTypicalCamera(
chronoirr.vector3df(-0.4, -0.3, 0.0), # camera location
chronoirr.vector3df(0.0, 0.5, -0.1)) # "look at" location
print("-----------------------------------------------------------\n")
print("------------------------------------------------------------\n")
print(" ANCF Shell Elements demo with implicit integration \n")
print("-----------------------------------------------------------\n")
# Create a mesh, that is a container for groups of elements and their referenced nodes.
# f.write("grad_min:" + ','.join([f"{g:.6f}" for g in retlist[2]]) + '\n')
f.write("fopt:" + ','.join([f"{fopt:.6f}" for fopt in fopts]) + '\n')
f.write("iterations:" + ','.join([f"{ite}" for ite in iterations]) + '\n')
f.write("message:" + ','.join([f"{m}" for m in messages]) + '\n')
f.write("success:" + ','.join([f"{s}" for s in successes]) + '\n')
# with open(f"./../data/reconstruction/{filename}_real.txt", 'w') as f:
# offset = bb_dz / 2.3
# H = eval('_'.split(filename)[-1]) / math.tan(math.pi / 180.)
# f.write("nodes_mm:" + ','.join([f"{n:.6f}" for n in nodes_inf_final]) + '\n')
# ---------------------------------------------------------------------
# IRRLICHT
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(mysystem, 'Reconstruction shape',
chronoirr.dimension2du(720, 540))
myapplication.AddTypicalSky(chrono.GetChronoDataPath() + 'skybox2/')
myapplication.AddTypicalCamera(chronoirr.vector3df(1.3 * bb_dz, 0., 0.))
myapplication.AddTypicalLights()
myapplication.SetShowInfos(False)
# ==IMPORTANT!== for Irrlicht to work
myapplication.AssetBindAll()
myapplication.AssetUpdateAll()
mysystem.SetupInitial()
# ---------------------------------------------------------------------
# SIMULATION
# Run the simulation
# Change the solver form the default SOR to the MKL Pardiso, more precise for fea.
# by the pov .ini script in POV-Ray (do this at each simulation timestep)
pov_exporter.ExportData()
nstep = nstep + 1
print("\n\nOk, Simulation done!")
time.sleep(2)
if m_visualization == "irrlicht":
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(my_system, 'Test',
chronoirr.dimension2du(1280, 720))
myapplication.AddTypicalSky(chrono.GetChronoDataPath() + 'skybox/')
myapplication.AddTypicalLogo(chrono.GetChronoDataPath() +
'logo_pychrono_alpha.png')
myapplication.AddTypicalCamera(chronoirr.vector3df(0.5, 0.5, 0.5),
chronoirr.vector3df(0.0, 0.0, 0.0))
myapplication.AddTypicalLights()
#myapplication.AddLightWithShadow(chronoirr.vector3df(10,20,10),chronoirr.vector3df(0,2.6,0), 10 ,10,40, 60, 512);
# ==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.
myapplication.AssetBindAll()
# The joint is located at the global origin. Its kinematic constraints will
# enforce orthogonality of the associated cross.
ujoint = chrono.ChLinkUniversal()
mysystem.AddLink(ujoint)
ujoint.Initialize(shaft_1, shaft_2,
chrono.ChFrameD(chrono.ChVectorD(0, 0, 0), rot))
# ---------------------------------------------------------------------
#
# Create an Irrlicht application to visualize the system
#
myapplication = chronoirr.ChIrrApp(mysystem,
'PyChrono example: universal joint',
chronoirr.dimension2du(1024, 768))
myapplication.AddTypicalSky()
myapplication.AddTypicalLogo(
chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
myapplication.AddTypicalCamera(chronoirr.vector3df(3, 1, -1.5))
myapplication.AddTypicalLights()
# ==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.
myapplication.AssetBindAll()
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
#
# Create the Irrlicht visualization (open the Irrlicht device,
# bind a simple user interface, etc. etc.)
myapplication = chronoirr.ChIrrApp(my_system, 'Test FEA beams', chronoirr.dimension2du(1024,768))
#application.AddTypicalLogo()
myapplication.AddTypicalSky()
myapplication.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png'))
myapplication.AddTypicalCamera(chronoirr.vector3df(0.1,0.1,0.2))
myapplication.AddTypicalLights()
# ==IMPORTANT!== Use this function for adding a ChIrrNodeAsset to all items
# in the system. These ChIrrNodeAsset assets are 'proxies' to the Irrlicht meshes.
myapplication.AssetBindAll()
# ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
# that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
