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 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 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 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 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 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()
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)
patch_mat = chrono.ChMaterialSurfaceNSC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) patch = terrain.AddPatch(patch_mat, chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(0, 0, 1), 600, 600) patch.SetColor(chrono.ChColor(0.8, 0.8, 1.0)) patch.SetTexture(veh.GetDataFile("terrain/textures/tile4.jpg"), 1200, 1200) terrain.Initialize() # ------------------------------------- # Create the vehicle Irrlicht interface # Create the driver system # ------------------------------------- app = veh.ChWheeledVehicleIrrApp(gator.GetVehicle(), 'Gator', irr.dimension2du(1000,800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(+130, +130, 150), irr.vector3df(-130, +130, 150), 120, 120, irr.SColorf(0.7, 0.7, 0.7, 1.0), irr.SColorf(0.7, 0.7, 0.7, 1.0)) app.AddTypicalLights(irr.vector3df(+130, -130, 150), irr.vector3df(-130, -130, 150), 120, 120, irr.SColorf(0.7, 0.7, 0.7, 1.0), irr.SColorf(0.7, 0.7, 0.7, 1.0)) app.SetChaseCamera(trackPoint, 6.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Create the interactive driver system driver = veh.ChIrrGuiDriver(app) # Set the time response for steering and throttle keyboard inputs.
mysystem.Add(body_B) # --------------------------------------------------------------------- # # Create an Irrlicht application to visualize the system # myapplication = chronoirr.ChIrrApp(mysystem, 'PyChrono example', chronoirr.dimension2du(1024,768)) myapplication.AddTypicalSky() myapplication.AddTypicalLogo(chrono.GetChronoDataPath() + 'logo_pychrono_alpha.png') myapplication.AddTypicalCamera(chronoirr.vector3df(0.5,1,1), chronoirr.vector3df(0,0,0)) #myapplication.AddTypicalLights() myapplication.AddLightWithShadow(chronoirr.vector3df(3,6,2), # point chronoirr.vector3df(0,0,0), # aimpoint 12, # radius (power) 1,11, # near, far 55) # 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.
def main(): #print("Copyright (c) 2017 projectchrono.org\nChrono version: ", CHRONO_VERSION , "\n\n") # Create the M113 vehicle # ------------------------ vehicle = veh.M113_Vehicle(False, veh.TrackShoeType_SINGLE_PIN, veh.BrakeType_SIMPLE, chrono.ChContactMethod_SMC, veh.CollisionType_NONE) vehicle.Initialize(chrono.ChCoordsysD(initLoc, initRot)) vehicle.SetChassisVisualizationType(veh.VisualizationType_PRIMITIVES) vehicle.SetSprocketVisualizationType(veh.VisualizationType_MESH) vehicle.SetIdlerVisualizationType(veh.VisualizationType_MESH) vehicle.SetRoadWheelAssemblyVisualizationType(veh.VisualizationType_MESH) vehicle.SetRoadWheelVisualizationType(veh.VisualizationType_MESH) vehicle.SetTrackShoeVisualizationType(veh.VisualizationType_MESH) # Create the powertrain system # ---------------------------- powertrain = veh.M113_SimpleCVTPowertrain("Powertrain") vehicle.InitializePowertrain(powertrain) # Create the terrain # ------------------ terrain = veh.RigidTerrain(vehicle.GetSystem()) if (contact_method == chrono.ChContactMethod_NSC): patch_mat = chrono.ChMaterialSurfaceNSC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) elif (contact_method == chrono.ChContactMethod_SMC): patch_mat = chrono.ChMaterialSurfaceSMC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) patch_mat.SetYoungModulus(2e7) patch = terrain.AddPatch(patch_mat, chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(0, 0, 1), terrainLength, terrainWidth) patch.SetTexture(veh.GetDataFile("terrain/textures/tile4.jpg"), 200, 200) patch.SetColor(chrono.ChColor(0.5, 0.8, 0.5)) terrain.Initialize() # Create the vehicle Irrlicht interface # ------------------------------------- app = veh.ChTrackedVehicleIrrApp(vehicle, 'M113', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(30, -30, 100), irr.vector3df(30, 50, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(trackPoint, 6.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Create the interactive driver system # ------------------------------------ driver = veh.ChIrrGuiDriver(app) # Set the time response for steering and throttle keyboard inputs. steering_time = 0.5 # time to go from 0 to +1 (or from 0 to -1) throttle_time = 1.0 # time to go from 0 to +1 braking_time = 0.3 # time to go from 0 to +1 driver.SetSteeringDelta(render_step_size / steering_time) driver.SetThrottleDelta(render_step_size / throttle_time) driver.SetBrakingDelta(render_step_size / braking_time) driver.Initialize() # Simulation loop # --------------- # Inter-module communication data shoe_forces_left = veh.TerrainForces(vehicle.GetNumTrackShoes(veh.LEFT)) shoe_forces_right = veh.TerrainForces(vehicle.GetNumTrackShoes(veh.RIGHT)) # Number of simulation steps between miscellaneous events render_steps = m.ceil(render_step_size / step_size) # Initialize simulation frame counter and simulation time step_number = 0 realtime_timer = chrono.ChRealtimeStepTimer() while (app.GetDevice().run()): time = vehicle.GetSystem().GetChTime() app.BeginScene(True, True, irr.SColor(255, 140, 161, 192)) app.DrawAll() app.EndScene() # Get driver inputs driver_inputs = driver.GetInputs() # Update modules (process inputs from other modules) driver.Synchronize(time) terrain.Synchronize(time) vehicle.Synchronize(time, driver_inputs, shoe_forces_left, shoe_forces_right) app.Synchronize("", driver_inputs) # Advance simulation for one timestep for all modules driver.Advance(step_size) terrain.Advance(step_size) vehicle.Advance(step_size) app.Advance(step_size) # Increment frame number step_number += 1 # Spin in place for real time to catch up realtime_timer.Spin(step_size) return 0
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
mjointC.Initialize(mpiston, mfloor, chrono.ChCoordsysD( crank_center + chrono.ChVectorD(crank_rad+rod_length,0,0), chrono.Q_ROTATE_Z_TO_X) ) mysystem.Add(mjointC) # --------------------------------------------------------------------- # # Create an Irrlicht application to visualize the system # myapplication = chronoirr.ChIrrApp(mysystem, 'PyChrono example', chronoirr.dimension2du(1024,768)) myapplication.AddTypicalSky() myapplication.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) myapplication.AddTypicalCamera(chronoirr.vector3df(1,1,3), chronoirr.vector3df(0,1,0)) 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!
mfloor = chrono.ChBodyEasyBox(1, 0.2, 1, 1000) mfloor.SetPos(chrono.ChVectorD(0,-0.3,0)) mfloor.SetBodyFixed(True) mysystem.Add(mfloor) mcolor = chrono.ChColorAsset(0.3, 0.3, 0.8) mfloor.AddAsset(mcolor) # --------------------------------------------------------------------- # # Create an Irrlicht application to visualize the system # myapplication = chronoirr.ChIrrApp(mysystem, 'Test', chronoirr.dimension2du(1024,768)) myapplication.AddTypicalSky() 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 # that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!
# 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(); # ==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!
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.GetChronoDataPath() + '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!
body_floor_texture = chrono.ChTexture() body_floor_texture.SetTextureFilename('concrete.jpeg') body_floor.GetAssets().push_back(body_floor_texture) my_system.Add(body_floor) if True: # 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(); # ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
# abscyssa s of the line, as a function of time s(t). # By default it was simply s=t. mspacefx = chrono.ChFunction_Ramp(0, 0.5) mtrajectory.Set_space_fx(mspacefx) # Just to constraint the hand rotation: mparallelism = chrono.ChLinkLockParallel() mparallelism.Initialize(mrigidBody_hand, mfloor, frame_marker_wrist_hand.GetCoord()) mysystem.Add(mparallelism); # --------------------------------------------------------------------- # # Create an Irrlicht application to visualize the system # myapplication = chronoirr.ChIrrApp(mysystem, 'Import STEP', chronoirr.dimension2du(1024,768)) myapplication.AddTypicalSky(chrono.GetChronoDataPath() + 'skybox/') myapplication.AddTypicalLogo(chrono.GetChronoDataPath() + 'logo_pychrono_alpha.png') myapplication.AddTypicalCamera(chronoirr.vector3df(2,2,2),chronoirr.vector3df(0,0.8,0)) #myapplication.AddTypicalLights() myapplication.AddLightWithShadow(chronoirr.vector3df(3,6,2), # point chronoirr.vector3df(0,0,0), # aimpoint 12, # radius (power) 1,11, # near, far 55) # 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.
# # ============================================================================= 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
def main(): #print("Copyright (c) 2017 projectchrono.org\nChrono version: ", CHRONO_VERSION , "\n\n") # Create the HMMWV vehicle, set parameters, and initialize my_hmmwv = veh.HMMWV_Full() my_hmmwv.SetContactMethod(chrono.ChContactMethod_SMC) my_hmmwv.SetInitPosition( chrono.ChCoordsysD(chrono.ChVectorD(-5, -2, 0.6), chrono.ChQuaternionD(1, 0, 0, 0))) my_hmmwv.SetPowertrainType(veh.PowertrainModelType_SHAFTS) my_hmmwv.SetDriveType(veh.DrivelineType_AWD) my_hmmwv.SetTireType(veh.TireModelType_RIGID) my_hmmwv.Initialize() my_hmmwv.SetChassisVisualizationType(veh.VisualizationType_NONE) my_hmmwv.SetSuspensionVisualizationType(veh.VisualizationType_PRIMITIVES) my_hmmwv.SetSteeringVisualizationType(veh.VisualizationType_PRIMITIVES) my_hmmwv.SetWheelVisualizationType(veh.VisualizationType_NONE) my_hmmwv.SetTireVisualizationType(veh.VisualizationType_MESH) # Create the (custom) driver driver = MyDriver(my_hmmwv.GetVehicle(), 0.5) driver.Initialize() # Create the SCM deformable terrain patch terrain = veh.SCMDeformableTerrain(my_hmmwv.GetSystem()) terrain.SetSoilParameters( 2e6, # Bekker Kphi 0, # Bekker Kc 1.1, # Bekker n exponent 0, # Mohr cohesive limit (Pa) 30, # Mohr friction limit (degrees) 0.01, # Janosi shear coefficient (m) 2e8, # Elastic stiffness (Pa/m), before plastic yield 3e4 # Damping (Pa s/m), proportional to negative vertical speed (optional) ) # Optionally, enable moving patch feature (single patch around vehicle chassis) terrain.AddMovingPatch(my_hmmwv.GetChassisBody(), chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(5, 3, 1)) # Set plot type for SCM (false color plotting) terrain.SetPlotType(veh.SCMDeformableTerrain.PLOT_SINKAGE, 0, 0.1) # Initialize the SCM terrain, specifying the initial mesh grid terrain.Initialize(terrainLength, terrainWidth, delta) # Create the vehicle Irrlicht interface app = veh.ChWheeledVehicleIrrApp(my_hmmwv.GetVehicle(), 'HMMWV Deformable Soil Demo', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(30, -30, 100), irr.vector3df(30, 50, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(chrono.ChVectorD(0.0, 0.0, 1.75), 6.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Simulation loop while (app.GetDevice().run()): time = my_hmmwv.GetSystem().GetChTime() # End simulation if (time >= 4): break # Draw scene app.BeginScene(True, True, irr.SColor(255, 140, 161, 192)) app.DrawAll() app.EndScene() # Get driver inputs driver_inputs = driver.GetInputs() # Update modules (process inputs from other modules) driver.Synchronize(time) terrain.Synchronize(time) my_hmmwv.Synchronize(time, driver_inputs, terrain) app.Synchronize("", driver_inputs) # Advance simulation for one timestep for all modules driver.Advance(step_size) terrain.Advance(step_size) my_hmmwv.Advance(step_size) app.Advance(step_size) return 0
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()
def main(): #print("Copyright (c) 2017 projectchrono.org\nChrono version: ", CHRONO_VERSION , "\n\n") step_size = 0.005 sys = chrono.ChSystemNSC() sys.Set_G_acc(chrono.ChVectorD(0, 0, -9.81)) sys.SetSolverType(chrono.ChSolver.Type_BARZILAIBORWEIN) sys.SetSolverMaxIterations(150) sys.SetMaxPenetrationRecoverySpeed(4.0) # Create the terrain terrain = veh.RigidTerrain(sys) patch_mat = chrono.ChMaterialSurfaceNSC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) patch = terrain.AddPatch(patch_mat, chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(0, 0, 1), 200, 100) patch.SetColor(chrono.ChColor(0.8, 0.8, 0.5)) patch.SetTexture(veh.GetDataFile("terrain/textures/tile4.jpg"), 200, 200) terrain.Initialize() # Create and initialize the first vehicle hmmwv_1 = veh.HMMWV_Reduced(sys) hmmwv_1.SetInitPosition( chrono.ChCoordsysD(chrono.ChVectorD(0, -1.5, 1.0), chrono.ChQuaternionD(1, 0, 0, 0))) hmmwv_1.SetPowertrainType(veh.PowertrainModelType_SIMPLE) hmmwv_1.SetDriveType(veh.DrivelineType_RWD) hmmwv_1.SetTireType(veh.TireModelType_RIGID) hmmwv_1.Initialize() hmmwv_1.SetChassisVisualizationType(veh.VisualizationType_PRIMITIVES) hmmwv_1.SetSuspensionVisualizationType(veh.VisualizationType_PRIMITIVES) hmmwv_1.SetSteeringVisualizationType(veh.VisualizationType_PRIMITIVES) hmmwv_1.SetWheelVisualizationType(veh.VisualizationType_NONE) hmmwv_1.SetTireVisualizationType(veh.VisualizationType_PRIMITIVES) driver_data_1 = veh.vector_Entry([ veh.DataDriverEntry(0.0, 0.0, 0.0, 0.0), veh.DataDriverEntry(0.5, 0.0, 0.0, 0.0), veh.DataDriverEntry(0.7, 0.3, 0.7, 0.0), veh.DataDriverEntry(1.0, 0.3, 0.7, 0.0), veh.DataDriverEntry(3.0, 0.5, 0.1, 0.0) ]) driver_1 = veh.ChDataDriver(hmmwv_1.GetVehicle(), driver_data_1) driver_1.Initialize() # Create and initialize the second vehicle hmmwv_2 = veh.HMMWV_Reduced(sys) hmmwv_2.SetInitPosition( chrono.ChCoordsysD(chrono.ChVectorD(7, 1.5, 1.0), chrono.ChQuaternionD(1, 0, 0, 0))) hmmwv_2.SetPowertrainType(veh.PowertrainModelType_SIMPLE) hmmwv_2.SetDriveType(veh.DrivelineType_RWD) hmmwv_2.SetTireType(veh.TireModelType_RIGID) hmmwv_2.Initialize() hmmwv_2.SetChassisVisualizationType(veh.VisualizationType_PRIMITIVES) hmmwv_2.SetSuspensionVisualizationType(veh.VisualizationType_PRIMITIVES) hmmwv_2.SetSteeringVisualizationType(veh.VisualizationType_PRIMITIVES) hmmwv_2.SetWheelVisualizationType(veh.VisualizationType_NONE) hmmwv_2.SetTireVisualizationType(veh.VisualizationType_PRIMITIVES) driver_data_2 = veh.vector_Entry([ veh.DataDriverEntry(0.0, 0.0, 0.0, 0.0), veh.DataDriverEntry(0.5, 0.0, 0.0, 0.0), veh.DataDriverEntry(0.7, -0.3, 0.7, 0.0), veh.DataDriverEntry(1.0, -0.3, 0.7, 0.0), veh.DataDriverEntry(3.0, -0.5, 0.1, 0.0) ]) driver_2 = veh.ChDataDriver(hmmwv_2.GetVehicle(), driver_data_2) driver_2.Initialize() # Create the vehicle Irrlicht interface app = veh.ChWheeledVehicleIrrApp(hmmwv_1.GetVehicle(), 'Two Car Demo', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(30, -30, 100), irr.vector3df(30, 50, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(chrono.ChVectorD(0.0, 0.0, 0.75), 6.0, 0.5) app.SetChaseCameraState(veh.ChChaseCamera.Track) app.SetChaseCameraPosition(chrono.ChVectorD(-15, 0, 2.0)) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Simulation loop realtime_timer = chrono.ChRealtimeStepTimer() while (app.GetDevice().run()): time = hmmwv_1.GetSystem().GetChTime() app.BeginScene(True, True, irr.SColor(255, 140, 161, 192)) app.DrawAll() app.EndScene() # Get driver inputs driver_inputs_1 = driver_1.GetInputs() driver_inputs_2 = driver_2.GetInputs() # Update modules (process inputs from other modules) driver_1.Synchronize(time) driver_2.Synchronize(time) hmmwv_1.Synchronize(time, driver_inputs_1, terrain) hmmwv_2.Synchronize(time, driver_inputs_2, terrain) terrain.Synchronize(time) app.Synchronize("", driver_inputs_1) # Advance simulation for one timestep for all modules driver_1.Advance(step_size) driver_2.Advance(step_size) hmmwv_1.Advance(step_size) hmmwv_2.Advance(step_size) terrain.Advance(step_size) app.Advance(step_size) # Advance state of entire system (containing both vehicles) sys.DoStepDynamics(step_size) # Spin in place for real time to catch up realtime_timer.Spin(step_size) return 0
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.GetChronoDataPath() + '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() # --------------------------------------------------------------------- # # Run the simulation #
patch_mat.SetRestitution(0.01) elif (contact_method == chrono.ChContactMethod_SMC): patch_mat = chrono.ChMaterialSurfaceSMC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) patch_mat.SetYoungModulus(2e7) patch = terrain.AddPatch(patch_mat, chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(0, 0, 1), terrainLength, terrainWidth) patch.SetTexture(veh.GetDataFile("terrain/textures/tile4.jpg"), 200, 200) patch.SetColor(chrono.ChColor(0.8, 0.8, 0.5)) terrain.Initialize() # Create the vehicle Irrlicht interface app = veh.ChWheeledVehicleIrrApp(my_bus.GetVehicle(), 'Citybus', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(30, -30, 100), irr.vector3df(30, 50, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(trackPoint, 15.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Create the driver system driver = veh.ChIrrGuiDriver(app) # Set the time response for steering and throttle keyboard inputs. steering_time = 1.0 # time to go from 0 to +1 (or from 0 to -1) throttle_time = 1.0 # time to go from 0 to +1
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!
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()
def main(): #print("Copyright (c) 2017 projectchrono.org\nChrono version: ", CHRONO_VERSION , "\n\n") # Create systems # Create the HMMWV vehicle, set parameters, and initialize my_hmmwv = veh.HMMWV_Full() my_hmmwv.SetContactMethod(contact_method) my_hmmwv.SetChassisCollisionType(chassis_collision_type) my_hmmwv.SetChassisFixed(False) my_hmmwv.SetInitPosition(chrono.ChCoordsysD(initLoc, initRot)) my_hmmwv.SetPowertrainType(powertrain_model) my_hmmwv.SetDriveType(drive_type) my_hmmwv.SetSteeringType(steering_type) my_hmmwv.SetTireType(tire_model) my_hmmwv.SetTireStepSize(tire_step_size) my_hmmwv.Initialize() my_hmmwv.SetChassisVisualizationType(chassis_vis_type) my_hmmwv.SetSuspensionVisualizationType(suspension_vis_type) my_hmmwv.SetSteeringVisualizationType(steering_vis_type) my_hmmwv.SetWheelVisualizationType(wheel_vis_type) my_hmmwv.SetTireVisualizationType(tire_vis_type) # Create the terrain terrain = veh.RigidTerrain(my_hmmwv.GetSystem()) if (contact_method == chrono.ChContactMethod_NSC): patch_mat = chrono.ChMaterialSurfaceNSC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) elif (contact_method == chrono.ChContactMethod_SMC): patch_mat = chrono.ChMaterialSurfaceSMC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) patch_mat.SetYoungModulus(2e7) patch = terrain.AddPatch(patch_mat, chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(0, 0, 1), terrainLength, terrainWidth) patch.SetTexture(veh.GetDataFile("terrain/textures/tile4.jpg"), 200, 200) patch.SetColor(chrono.ChColor(0.8, 0.8, 0.5)) terrain.Initialize() # Create the vehicle Irrlicht interface app = veh.ChWheeledVehicleIrrApp(my_hmmwv.GetVehicle(), 'HMMWV', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(30, -30, 100), irr.vector3df(30, 50, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(trackPoint, 6.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Initialize output try: os.mkdir(out_dir) except: print("Error creating directory ") # Set up vehicle output my_hmmwv.GetVehicle().SetChassisOutput(True) my_hmmwv.GetVehicle().SetSuspensionOutput(0, True) my_hmmwv.GetVehicle().SetSteeringOutput(0, True) my_hmmwv.GetVehicle().SetOutput(veh.ChVehicleOutput.ASCII, out_dir, "output", 0.1) # Generate JSON information with available output channels my_hmmwv.GetVehicle().ExportComponentList(out_dir + "/component_list.json") # Create the interactive driver system driver = veh.ChIrrGuiDriver(app) # Set the time response for steering and throttle keyboard inputs. steering_time = 1.0 # time to go from 0 to +1 (or from 0 to -1) throttle_time = 1.0 # time to go from 0 to +1 braking_time = 0.3 # time to go from 0 to +1 driver.SetSteeringDelta(render_step_size / steering_time) driver.SetThrottleDelta(render_step_size / throttle_time) driver.SetBrakingDelta(render_step_size / braking_time) driver.Initialize() # Simulation loop # Number of simulation steps between miscellaneous events render_steps = m.ceil(render_step_size / step_size) debug_steps = m.ceil(debug_step_size / step_size) # Initialize simulation frame counter and simulation time step_number = 0 render_frame = 0 if (contact_vis): app.SetSymbolscale(1e-4) #app.SetContactsDrawMode(irr.eCh_ContactsDrawMode::CONTACT_FORCES); realtime_timer = chrono.ChRealtimeStepTimer() while (app.GetDevice().run()): time = my_hmmwv.GetSystem().GetChTime() #End simulation if (time >= t_end): break app.BeginScene(True, True, irr.SColor(255, 140, 161, 192)) app.DrawAll() app.EndScene() #Debug logging if (debug_output and step_number % debug_steps == 0): print("\n\n============ System Information ============\n") print("Time = " << time << "\n\n") #my_hmmwv.DebugLog(OUT_SPRINGS | OUT_SHOCKS | OUT_CONSTRAINTS) marker_driver = my_hmmwv.GetChassis().GetMarkers()[0].GetAbsCoord( ).pos marker_com = my_hmmwv.GetChassis().GetMarkers()[1].GetAbsCoord( ).pos print("Markers\n") print(" Driver loc: ", marker_driver.x, " ", marker_driver.y, " ", marker_driver.z) print(" Chassis COM loc: ", marker_com.x, " ", marker_com.y, " ", marker_com.z) # Get driver inputs driver_inputs = driver.GetInputs() # Update modules (process inputs from other modules) driver.Synchronize(time) terrain.Synchronize(time) my_hmmwv.Synchronize(time, driver_inputs, terrain) app.Synchronize(driver.GetInputModeAsString(), driver_inputs) # Advance simulation for one timestep for all modules driver.Advance(step_size) terrain.Advance(step_size) my_hmmwv.Advance(step_size) app.Advance(step_size) # Increment frame number step_number += 1 # Spin in place for real time to catch up realtime_timer.Spin(step_size) return 0
def main(): #print("Copyright (c) 2017 projectchrono.org\nChrono version: ", CHRONO_VERSION , "\n\n") # Create the HMMWV vehicle, set parameters, and initialize my_hmmwv = veh.HMMWV_Full() my_hmmwv.SetContactMethod(contact_method) my_hmmwv.SetChassisFixed(False) my_hmmwv.SetInitPosition( chrono.ChCoordsysD(initLoc, chrono.ChQuaternionD(1, 0, 0, 0))) my_hmmwv.SetPowertrainType(powertrain_model) my_hmmwv.SetDriveType(drive_type) my_hmmwv.SetSteeringType(steering_type) my_hmmwv.SetTireType(tire_model) my_hmmwv.SetTireStepSize(tire_step_size) my_hmmwv.Initialize() my_hmmwv.SetChassisVisualizationType(chassis_vis_type) my_hmmwv.SetSuspensionVisualizationType(suspension_vis_type) my_hmmwv.SetSteeringVisualizationType(steering_vis_type) my_hmmwv.SetWheelVisualizationType(wheel_vis_type) my_hmmwv.SetTireVisualizationType(tire_vis_type) # Create the terrain terrain = veh.RigidTerrain(my_hmmwv.GetSystem()) if (contact_method == chrono.ChContactMethod_NSC): patch_mat = chrono.ChMaterialSurfaceNSC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) elif (contact_method == chrono.ChContactMethod_SMC): patch_mat = chrono.ChMaterialSurfaceSMC() patch_mat.SetFriction(0.9) patch_mat.SetRestitution(0.01) patch_mat.SetYoungModulus(2e7) patch = terrain.AddPatch(patch_mat, chrono.ChVectorD(0, 0, 0), chrono.ChVectorD(0, 0, 1), 300, 50) patch.SetTexture(veh.GetDataFile("terrain/textures/tile4.jpg"), 200, 200) patch.SetColor(chrono.ChColor(0.8, 0.8, 0.5)) terrain.Initialize() # Create the path-follower, cruise-control driver # Use a parameterized ISO double lane change (to left) path = veh.DoubleLaneChangePath(initLoc, 13.5, 4.0, 11.0, 50.0, True) driver = veh.ChPathFollowerDriver(my_hmmwv.GetVehicle(), path, "my_path", target_speed) driver.GetSteeringController().SetLookAheadDistance(5) driver.GetSteeringController().SetGains(0.8, 0, 0) driver.GetSpeedController().SetGains(0.4, 0, 0) driver.Initialize() # Create the vehicle Irrlicht interface app = veh.ChWheeledVehicleIrrApp(my_hmmwv.GetVehicle(), 'HMMWV', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(-60, -30, 100), irr.vector3df(60, 30, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(chrono.ChVectorD(0.0, 0.0, 1.75), 6.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() # Visualization of controller points (sentinel & target) ballS = app.GetSceneManager().addSphereSceneNode(0.1) ballT = app.GetSceneManager().addSphereSceneNode(0.1) ballS.getMaterial(0).EmissiveColor = irr.SColor(0, 255, 0, 0) ballT.getMaterial(0).EmissiveColor = irr.SColor(0, 0, 255, 0) # Simulation loop realtime_timer = chrono.ChRealtimeStepTimer() while (app.GetDevice().run()): time = my_hmmwv.GetSystem().GetChTime() # End simulation if (time >= t_end): break # Update sentinel and target location markers for the path-follower controller. pS = driver.GetSteeringController().GetSentinelLocation() pT = driver.GetSteeringController().GetTargetLocation() ballS.setPosition(irr.vector3df(pS.x, pS.y, pS.z)) ballT.setPosition(irr.vector3df(pT.x, pT.y, pT.z)) # Draw scene app.BeginScene(True, True, irr.SColor(255, 140, 161, 192)) app.DrawAll() app.EndScene() # Get driver inputs driver_inputs = driver.GetInputs() # Update modules (process inputs from other modules) driver.Synchronize(time) terrain.Synchronize(time) my_hmmwv.Synchronize(time, driver_inputs, terrain) app.Synchronize("", driver_inputs) # Advance simulation for one timestep for all modules driver.Advance(step_size) terrain.Advance(step_size) my_hmmwv.Advance(step_size) app.Advance(step_size) # Spin in place for real time to catch up realtime_timer.Spin(step_size) return 0
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
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(1,1,1),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(); # ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
def main(): #print("Copyright (c) 2017 projectchrono.org\nChrono version: ", CHRONO_VERSION , "\n\n") # -------------------------- # Create the various modules # -------------------------- # Create the vehicle system vehicle = veh.WheeledVehicle(vehicle_file, chrono.ChContactMethod_NSC) vehicle.Initialize(chrono.ChCoordsysD(initLoc, initRot)) #vehicle.GetChassis().SetFixed(True) vehicle.SetChassisVisualizationType(veh.VisualizationType_MESH) vehicle.SetSuspensionVisualizationType(veh.VisualizationType_PRIMITIVES) vehicle.SetSteeringVisualizationType(veh.VisualizationType_PRIMITIVES) vehicle.SetWheelVisualizationType(veh.VisualizationType_MESH) # Create and initialize the vehicle tires for axle in vehicle.GetAxles(): tireL = veh.TMeasyTire(vehicle_tire_file) vehicle.InitializeTire(tireL, axle.m_wheels[0], veh.VisualizationType_MESH) tireR = veh.TMeasyTire(vehicle_tire_file) vehicle.InitializeTire(tireR, axle.m_wheels[1], veh.VisualizationType_MESH) # Create and initialize the powertrain system powertrain = veh.SimpleMapPowertrain(vehicle_powertrain_file) vehicle.InitializePowertrain(powertrain) # Create and initialize the trailer trailer = veh.WheeledTrailer(vehicle.GetSystem(), trailer_file) trailer.Initialize(vehicle.GetChassis()) trailer.SetChassisVisualizationType(veh.VisualizationType_PRIMITIVES) trailer.SetSuspensionVisualizationType(veh.VisualizationType_PRIMITIVES) trailer.SetWheelVisualizationType(veh.VisualizationType_NONE) # Create abd initialize the trailer tires for axle in trailer.GetAxles(): tireL = veh.TMeasyTire(trailer_tire_file) trailer.InitializeTire(tireL, axle.m_wheels[0], veh.VisualizationType_PRIMITIVES) tireR = veh.TMeasyTire(trailer_tire_file) trailer.InitializeTire(tireR, axle.m_wheels[1], veh.VisualizationType_PRIMITIVES) # Create the ground terrain = veh.RigidTerrain(vehicle.GetSystem(), rigidterrain_file) app = veh.ChVehicleIrrApp(vehicle, 'Sedan+Trailer (JSON specification)', irr.dimension2du(1000, 800)) app.SetSkyBox() app.AddTypicalLights(irr.vector3df(30, -30, 100), irr.vector3df(30, 50, 100), 250, 130) app.AddTypicalLogo(chrono.GetChronoDataFile('logo_pychrono_alpha.png')) app.SetChaseCamera(trackPoint, 6.0, 0.5) app.SetTimestep(step_size) app.AssetBindAll() app.AssetUpdateAll() driver = veh.ChIrrGuiDriver(app) # Set the time response for steering and throttle keyboard inputs. # NOTE: this is not exact, since we do not render quite at the specified FPS. steering_time = 1.0 # time to go from 0 to +1 (or from 0 to -1) throttle_time = 1.0 # time to go from 0 to +1 braking_time = 0.3 # time to go from 0 to +1 driver.SetSteeringDelta(render_step_size / steering_time) driver.SetThrottleDelta(render_step_size / throttle_time) driver.SetBrakingDelta(render_step_size / braking_time) driver.Initialize() # --------------- # Simulation loop # --------------- realtime_timer = chrono.ChRealtimeStepTimer() while (app.GetDevice().run()): # Render scene app.BeginScene(True, True, irr.SColor(255, 140, 161, 192)) app.DrawAll() app.EndScene() # Collect output data from modules (for inter-module communication) driver_inputs = driver.GetInputs() # Update modules (process inputs from other modules) time = vehicle.GetSystem().GetChTime() driver.Synchronize(time) vehicle.Synchronize(time, driver_inputs, terrain) trailer.Synchronize(time, driver_inputs.m_braking, terrain) terrain.Synchronize(time) app.Synchronize(driver.GetInputModeAsString(), driver_inputs) # Advance simulation for one timestep for all modules driver.Advance(step_size) vehicle.Advance(step_size) trailer.Advance(step_size) terrain.Advance(step_size) app.Advance(step_size) # Spin in place for real time to catch up realtime_timer.Spin(step_size)
solver.SetTolerance(1e-10) solver.EnableWarmStart(True) system.SetSolver(solver) # Change integrator: # system.SetTimestepperType(ChTimestepper.Type.EULER_IMPLICIT_LINEARIZED) # default: fast, 1st order # system.SetTimestepperType(ChTimestepper.Type.HHT) # precise, slower, might iterate each step # 11. 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 "FEA cable collide demo", # title of the Irrlicht window chronoirr.dimension2du(1024, 768), # window dimension (width x height) False, # use full screen? True, # enable stencil shadows? True) # enable antialiasing? application.AddTypicalLogo() application.AddTypicalSky() application.AddTypicalLights() application.AddTypicalCamera( chronoirr.vector3df(0.1, 0.2, -2.0), # camera location chronoirr.vector3df(0.0, 0.0, 0.0)) # "look at" location # Enable drawing of contacts application.SetContactsDrawMode(chronoirr.ChIrrTools.CONTACT_FORCES) application.SetSymbolscale(0.1)
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.
# ------------------------------- # 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() # -----------------------------
# 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() # ==IMPORTANT!== Use this function for 'converting' into Irrlicht meshes the assets
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 # that you added to the bodies into 3D shapes, they can be visualized by Irrlicht!