def add_container(self):
padding = 10
# Create the five walls of the rectangular container, using fixed rigid bodies of 'box' type
floor_body = chrono.ChBodyEasyBox(self.container_width + padding, 1,
self.container_length + padding,
1000, True, True, self.ground_mat)
floor_body.SetPos(chrono.ChVectorD(0, 0, 0))
floor_body.SetBodyFixed(True)
self.system.Add(floor_body)
if self.with_walls:
wall_body_1 = chrono.ChBodyEasyBox(1, self.wall_height,
self.container_length + padding,
1000, True, True,
self.ground_mat)
wall_body_1.SetPos(
chrono.ChVectorD(-self.container_width / 2,
self.wall_height / 2, 0))
wall_body_1.SetBodyFixed(True)
self.system.Add(wall_body_1)
wall_body_2 = chrono.ChBodyEasyBox(1, self.wall_height,
self.container_length + padding,
1000, True, True,
self.ground_mat)
wall_body_2.SetPos(
chrono.ChVectorD(self.container_width / 2,
self.wall_height / 2, 0))
wall_body_2.SetBodyFixed(True)
self.system.Add(wall_body_2)
wall_body_3 = chrono.ChBodyEasyBox(self.container_width + padding,
self.wall_height, 1, 1000,
False, True, self.ground_mat)
wall_body_3.SetPos(
chrono.ChVectorD(0, self.wall_height / 2,
-self.container_length / 2))
wall_body_3.SetBodyFixed(True)
self.system.Add(wall_body_3)
wall_body_4 = chrono.ChBodyEasyBox(self.container_width + padding,
self.wall_height, 1, 1000, True,
True, self.ground_mat)
wall_body_4.SetPos(
chrono.ChVectorD(0, self.wall_height / 2,
self.container_length / 2))
wall_body_4.SetBodyFixed(True)
self.system.Add(wall_body_4)
def CreateSliderGuide(material, msystem, mpos):
mguide = chrono.ChBodyEasyBox(4, 0.3, 0.6, 1000, True, True, material)
mguide.SetPos(mpos)
mguide.SetBodyFixed(True)
msystem.Add(mguide)
mslider = chrono.ChBodyEasyBox(0.4, 0.2, 0.5, 1000, True, True, material)
mslider.SetPos(mpos + chrono.ChVectorD(0, 0.3, 0))
msystem.Add(mslider)
mcolor = chrono.ChColorAsset(0.6, 0.6, 0.0)
mslider.AddAsset(mcolor)
obstacle = chrono.ChBodyEasyBox(0.4, 0.4, 0.4, 8000, True, True, material)
obstacle.SetPos(mpos + chrono.ChVectorD(1.5, 0.4, 0))
msystem.Add(obstacle)
mcolorobstacle = chrono.ChColorAsset(0.2, 0.2, 0.2)
mslider.AddAsset(mcolorobstacle)
return mguide, mslider
def CreateStatorRotor(material, msystem, mpos):
mstator = chrono.ChBodyEasyCylinder(0.5, 0.1, 1000, True, True, material)
mstator.SetPos(mpos)
mstator.SetRot(chrono.Q_from_AngAxis(chrono.CH_C_PI_2, chrono.VECT_X))
mstator.SetBodyFixed(True)
msystem.Add(mstator)
mrotor = chrono.ChBodyEasyBox(1, 0.1, 0.1, 1000, True, True, material)
mrotor.SetPos(mpos + chrono.ChVectorD(0.5, 0, -0.15))
msystem.Add(mrotor)
mcolor = chrono.ChColorAsset(0.6, 0.6, 0.0)
mrotor.AddAsset(mcolor)
return mstator, mrotor
def AddFallingItems(sys):
# Shared contact materials for falling objects
sph_mat = chrono.ChMaterialSurfaceNSC()
sph_mat.SetFriction(0.2)
box_mat = chrono.ChMaterialSurfaceNSC()
cyl_mat = chrono.ChMaterialSurfaceNSC()
# Create falling rigid bodies (spheres and boxes etc.)
for bi in range(29):
msphereBody = chrono.ChBodyEasySphere(1.1, # radius size
1000, # density
True, # visualization?
True, # collision?
sph_mat) # contact material
msphereBody.SetPos(chrono.ChVectorD(-5 + chrono.ChRandom() * 10, 4 + bi * 0.05, -5 + chrono.ChRandom() * 10))
sys.Add(msphereBody)
mtexture = chrono.ChTexture()
mtexture.SetTextureFilename(chrono.GetChronoDataFile("textures/bluewhite.png"))
msphereBody.AddAsset(mtexture)
mboxBody = chrono.ChBodyEasyBox(1.5, 1.5, 1.5, # x,y,z size
100, # density
True, # visualization?
True, # collision?
box_mat) # contact material
mboxBody.SetPos(chrono.ChVectorD(-5 + chrono.ChRandom() * 10, 4 + bi * 0.05, -5 + chrono.ChRandom() * 10))
sys.Add(mboxBody)
mtexturebox = chrono.ChTexture()
mtexturebox.SetTextureFilename(chrono.GetChronoDataFile("textures/cubetexture_bluewhite.png"))
mboxBody.AddAsset(mtexturebox)
mcylBody = chrono.ChBodyEasyCylinder(0.75, 0.5, # radius, height
100, # density
True, # visualization?
True, # collision?
cyl_mat) # contact material
mcylBody.SetPos(chrono.ChVectorD(-5 + chrono.ChRandom() * 10, 4 + bi * 0.05, -5 + chrono.ChRandom() * 10))
sys.Add(mcylBody)
# optional, attach a texture for better visualization
mtexturecyl = chrono.ChTexture()
mtexturecyl.SetTextureFilename(chrono.GetChronoDataFile("textures/pinkwhite.png"))
mcylBody.AddAsset(mtexturecyl)
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
# ---------------
for points in (track.left.points,track.right.points):
for i in range(len(points)-1):
p1 = points[i]+chrono.ChVectorD(0,0,.5)
p2 = points[i+1]
box = chrono.ChBodyEasyBox((p2-p1).Length()/10, .2, .8, 1000, True, True)
box.SetPos(p1)
v1 = p2-p1
v2 = chrono.ChVectorD(1,0,0)
ang = math.atan2((v1%v2).Length(), v1^v2)
if (chrono.ChVectorD(0,0,1)^(v1%v2) > 0.0): ang *= -1
q = chrono.Q_from_AngZ(ang)
box.SetRot(q)
box.SetBodyFixed(True)
box_asset = box.GetAssets()[0]
visual_asset = chrono.CastToChVisualization(box_asset)
vis_mat = chrono.ChVisualMaterial()
vis_mat.SetAmbientColor(chrono.ChVectorF(0, 0, 0))
# mysystem = chrono.ChSystemNSC() # Set the global collision margins. This is expecially important for very large or # very small objects. Set this before creating shapes. Not before creating mysystem. chrono.ChCollisionModel.SetDefaultSuggestedEnvelope(0.001) chrono.ChCollisionModel.SetDefaultSuggestedMargin(0.001) # --------------------------------------------------------------------- # # Create the simulation system and add items # # Create a floor mfloor = chrono.ChBodyEasyBox(3, 0.2, 3, 1000, True, True) mfloor.SetBodyFixed(True) mysystem.Add(mfloor) # Now we will create a falling object whose shape is defined by a .obj mesh. # # NOTE: collision detection with generic concave meshes is slower and less # robust than any other options for collision shapes, so use it if defining # collision shapes via primitives like spheres boxes cylinders or their # clusters is too complex. # # NOTE: the mesh shape is a .obj file in Wavefront file format, # you can generate it from 3D modelers such as Blender, Maya, etc. # # NOTE: for collision purposes, the .obj mesh must be "watertight", i.e. having # no gaps in edges, no repeated vertexes, etc.
measured_joint_pos_mm = chrono.ChVectorD(0, 48, 120)
scale = 1. / 1000. # because we use meters instead of mm
joint_pos = chrono.ChVectorD(
root_frame.TransformPointLocalToParent(measured_joint_pos_mm * scale))
# transform because we rotated everything
if (mrigidBody1 and mrigidBody2):
my_link = chrono.ChLinkLockRevolute()
my_link.Initialize(mrigidBody1, mrigidBody2, chrono.ChCoordsysD(joint_pos))
mysystem.Add(my_link)
# Create a large cube as a floor.
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))
def main():
# -----------------
# Create the system
# -----------------
mphysicalSystem = chrono.ChSystemNSC()
mphysicalSystem.Set_G_acc(chrono.ChVectorD(0, 0, -9.81))
# ----------------------------------------
# add a floor, box and sphere to the scene
# ----------------------------------------
phys_mat = chrono.ChMaterialSurfaceNSC()
phys_mat.SetFriction(0.5)
phys_mat.SetDampingF(0.00000)
phys_mat.SetCompliance(1e-9)
phys_mat.SetComplianceT(1e-9)
floor = chrono.ChBodyEasyBox(10, 10, 1, 1000, True, True, phys_mat)
floor.SetPos(chrono.ChVectorD(0, 0, -1))
floor.SetBodyFixed(True)
mphysicalSystem.Add(floor)
box = chrono.ChBodyEasyBox(1, 1, 1, 1000, True, True, phys_mat)
box.SetPos(chrono.ChVectorD(0, 0, 5))
box.SetRot(chrono.Q_from_AngAxis(.2, chrono.ChVectorD(1, 0, 0)))
mphysicalSystem.Add(box)
sphere = chrono.ChBodyEasySphere(.5, 1000, True, True, phys_mat)
sphere.SetPos(chrono.ChVectorD(0, 0, 8))
sphere.SetRot(chrono.Q_from_AngAxis(.2, chrono.ChVectorD(1, 0, 0)))
mphysicalSystem.Add(sphere)
sphere_asset = sphere.GetAssets()[0]
visual_asset = chrono.CastToChVisualization(sphere_asset)
vis_mat = chrono.ChVisualMaterial()
vis_mat.SetAmbientColor(chrono.ChVectorF(0, 0, 0))
vis_mat.SetDiffuseColor(chrono.ChVectorF(.2, .2, .9))
vis_mat.SetSpecularColor(chrono.ChVectorF(.9, .9, .9))
visual_asset.material_list.append(vis_mat)
# -----------------------
# Create a sensor manager
# -----------------------
manager = sens.ChSensorManager(mphysicalSystem)
manager.scene.AddPointLight(chrono.ChVectorF(100, 100, 100),
chrono.ChVectorF(1, 1, 1), 1000.0)
manager.scene.AddPointLight(chrono.ChVectorF(-100, -100, 100),
chrono.ChVectorF(1, 1, 1), 1000.0)
# ------------------------------------------------
# Create a camera and add it to the sensor manager
# ------------------------------------------------
offset_pose = chrono.ChFrameD(
chrono.ChVectorD(-8, 0, 1),
chrono.Q_from_AngAxis(0, chrono.ChVectorD(0, 1, 0)))
cam = sens.ChCameraSensor(
floor, # body camera is attached to
cam_update_rate, # update rate in Hz
offset_pose, # offset pose
image_width, # number of horizontal samples
image_height, # number of vertical channels
cam_fov # vertical field of view
)
cam.SetName("Camera Sensor")
cam.SetLag(cam_lag)
cam.SetCollectionWindow(cam_collection_time)
# ------------------------------------------------------------------
# Create a filter graph for post-processing the data from the camera
# ------------------------------------------------------------------
# Visualizes the image
if vis:
cam.PushFilter(
sens.ChFilterVisualize(image_width, image_height, "RGB Image"))
# Save the current image to a png file at the specified path
if (save):
cam.PushFilter(sens.ChFilterSave(out_dir + "/rgb/"))
# Provides the host access to this RGBA8 buffer
cam.PushFilter(sens.ChFilterRGBA8Access())
# Filter the sensor to grayscale
cam.PushFilter(sens.ChFilterGrayscale())
# Render the buffer again to see the new grayscaled image
if (vis):
cam.PushFilter(
sens.ChFilterVisualize(int(image_width / 2), int(image_height / 2),
"Grayscale Image"))
# Save the grayscaled image at the specified path
if (save):
cam.PushFilter(sens.ChFilterSave(out_dir + "/gray/"))
# Access the grayscaled buffer as R8 pixels
cam.PushFilter(sens.ChFilterR8Access())
# Add a camera to a sensor manager
manager.AddSensor(cam)
# ------------------------------------------------
# Create a lidar and add it to the sensor manager
# ------------------------------------------------
offset_pose = chrono.ChFrameD(
chrono.ChVectorD(-8, 0, 1),
chrono.Q_from_AngAxis(0, chrono.ChVectorD(0, 1, 0)))
lidar = sens.ChLidarSensor(
floor, # body lidar is attached to
lidar_update_rate, # scanning rate in Hz
offset_pose, # offset pose
horizontal_samples, # number of horizontal samples
vertical_samples, # number of vertical channels
horizontal_fov, # horizontal field of view
max_vert_angle,
min_vert_angle, # vertical field of view
100 #max lidar range
)
lidar.SetName("Lidar Sensor")
lidar.SetLag(lidar_lag)
lidar.SetCollectionWindow(lidar_collection_time)
# -----------------------------------------------------------------
# Create a filter graph for post-processing the data from the lidar
# -----------------------------------------------------------------
if vis:
# Randers the raw lidar data
lidar.PushFilter(
sens.ChFilterVisualize(horizontal_samples, vertical_samples,
"Raw Lidar Depth Data"))
# Provides the host access to the Depth,Intensity data
lidar.PushFilter(sens.ChFilterDIAccess())
# Convert Depth,Intensity data to XYZI point cloud data
lidar.PushFilter(sens.ChFilterPCfromDepth())
if vis:
# Visualize the point cloud
lidar.PushFilter(
sens.ChFilterVisualizePointCloud(640, 480, 1.0,
"Lidar Point Cloud"))
# Provides the host access to the XYZI data
lidar.PushFilter(sens.ChFilterXYZIAccess())
# Add the lidar to the sensor manager
manager.AddSensor(lidar)
# ----------------------------------------------
# Create an IMU sensor and add it to the manager
# ----------------------------------------------
offset_pose = chrono.ChFrameD(
chrono.ChVectorD(-8, 0, 1),
chrono.Q_from_AngAxis(0, chrono.ChVectorD(0, 1, 0)))
imu = sens.ChIMUSensor(
box, # body imu is attached to
imu_update_rate, # update rate in Hz
offset_pose, # offset pose
imu_noise_none, # noise model
)
imu.SetName("IMU Sensor")
imu.SetLag(imu_lag)
imu.SetCollectionWindow(imu_collection_time)
# Provides the host access to the imu data
imu.PushFilter(sens.ChFilterIMUAccess())
# Add the imu to the sensor manager
manager.AddSensor(imu)
# ----------------------------------------------
# Create an GPS sensor and add it to the manager
# ----------------------------------------------
offset_pose = chrono.ChFrameD(
chrono.ChVectorD(-8, 0, 1),
chrono.Q_from_AngAxis(0, chrono.ChVectorD(0, 1, 0)))
gps = sens.ChGPSSensor(
box, # body imu is attached to
gps_update_rate, # update rate in Hz
offset_pose, # offset pose
gps_reference,
gps_noise_none # noise model
)
gps.SetName("GPS Sensor")
gps.SetLag(gps_lag)
gps.SetCollectionWindow(gps_collection_time)
# Provides the host access to the gps data
gps.PushFilter(sens.ChFilterGPSAccess())
# Add the gps to the sensor manager
manager.AddSensor(gps)
# ---------------
# Simulate system
# ---------------
t1 = time.time()
ch_time = 0
while (ch_time < end_time):
# Access the sensor data
camera_data_RGBA8 = cam.GetMostRecentRGBA8Buffer()
camera_data_R8 = cam.GetMostRecentR8Buffer()
lidar_data_DI = lidar.GetMostRecentDIBuffer()
lidar_data_XYZI = lidar.GetMostRecentXYZIBuffer()
gps_data = gps.GetMostRecentGPSBuffer()
imu_data = imu.GetMostRecentIMUBuffer()
# Check data is present
# If so, print out the max value
if camera_data_RGBA8.HasData():
print("Camera RGBA8:",
camera_data_RGBA8.GetRGBA8Data().shape, "max:",
np.max(camera_data_RGBA8.GetRGBA8Data()))
if camera_data_R8.HasData():
print("Camera R8:",
camera_data_R8.GetChar8Data().shape, "max:",
np.max(camera_data_R8.GetChar8Data()))
if lidar_data_DI.HasData():
print("Lidar DI:",
lidar_data_DI.GetDIData().shape, "max:",
np.max(lidar_data_DI.GetDIData()))
if lidar_data_XYZI.HasData():
print("Lidar XYZI:",
lidar_data_XYZI.GetXYZIData().shape, "max:",
np.max(lidar_data_XYZI.GetXYZIData()))
if gps_data.HasData():
print("GPS:",
gps_data.GetGPSData().shape, "max:",
np.max(gps_data.GetGPSData()))
if imu_data.HasData():
print("IMU:",
imu_data.GetIMUData().shape, "max:",
np.max(imu_data.GetIMUData()))
# Update sensor manager
# Will render/save/filter automatically
manager.Update()
# Perform step of dynamics
mphysicalSystem.DoStepDynamics(step_size)
# Get the current time of the simulation
ch_time = mphysicalSystem.GetChTime()
print("Sim time:", end_time, "Wall time:", time.time() - t1)
my_link7 = chrono.ChLinkLockRevolute()
my_link7.Initialize(mrigidBody_turret, mrigidBody_cylinder, frame_marker_turret_cylinder.GetCoord())
mysystem.Add(my_link7)
my_link8 = chrono.ChLinkLockRevolute()
my_link8.Initialize(mrigidBody_cylinder, mrigidBody_rod, frame_marker_cylinder_rod.GetCoord())
mysystem.Add(my_link8)
my_link9 = chrono.ChLinkLockRevolute()
my_link9.Initialize(mrigidBody_rod, mrigidBody_bicep, frame_marker_rod_bicep.GetCoord())
mysystem.Add(my_link9)
# Create a large cube as a floor.
mfloor = chrono.ChBodyEasyBox(5, 1, 5, 1000, True, True)
mfloor.SetPos(chrono.ChVectorD(0,-0.5,0))
mfloor.SetBodyFixed(True)
mysystem.Add(mfloor)
mcolor = chrono.ChColorAsset(0.3, 0.3, 0.8)
mfloor.AddAsset(mcolor)
# We want to move the hand of the robot using a trajectory.
# Since in this demo all joints are 'off' (i.e just revolute joints),
# it follows that if we move the hand all the robot will automatically
# move as in inverse kinematics.
# Create a ChLinePath geometry, for the hand path, and insert arc/lines sub-paths:
mpath = chrono.ChLinePath()
print("Example: create a system and visualize it in realtime 3D")
# The path to the Chrono data directory containing various assets (meshes, textures, data files)
# is automatically set, relative to the default location of this demo.
# If running from a different directory, you must change the path to the data directory with:
#chrono.SetChronoDataPath('path/to/data')
# ---------------------------------------------------------------------
#
# Create the simulation system and add items
#
mysystem = chrono.ChSystemNSC()
mfloor = chrono.ChBodyEasyBox(3, 0.2, 3, 1000)
mfloor.SetBodyFixed(True)
mysystem.Add(mfloor)
#
# EXAMPLE1
#
# Create a ChLinePath geometry, and insert sub-paths:
mpath = chrono.ChLinePath()
mseg1 = chrono.ChLineSegment(chrono.ChVectorD(1, 2, 0),
chrono.ChVectorD(2, 2, 0))
mpath.AddSubLine(mseg1)
marc1 = chrono.ChLineArc(chrono.ChCoordsysD(chrono.ChVectorD(2, 2.5, 0)), 0.5,
-chrono.CH_C_PI_2, chrono.CH_C_PI_2, True)
mpath.AddSubLine(marc1)
cut_off = 0.00001
run_visible = True
system = chrono.ChSystemNSC()
system.SetSolverType(chrono.ChSolver.Type_BARZILAIBORWEIN)
# Contact material for container
ground_mat = chrono.ChMaterialSurfaceNSC()
ground_mat.SetFriction(0.8)
# Shared contact materials for falling objects
dice_mat = chrono.ChMaterialSurfaceNSC()
dice_mat.SetFriction(0.5)
# Create the five walls of the rectangular container, using fixed rigid bodies of 'box' type
floor_body = chrono.ChBodyEasyBox(210, 1, 210, 1000, True, True, ground_mat)
floor_body.SetPos(chrono.ChVectorD(0, 0, 0))
floor_body.SetBodyFixed(True)
system.Add(floor_body)
die_file = dodeca.get_chrono_mesh()
die = chrono.ChBodyEasyMesh(
die_file, # obj filename
10000, # density
True, # compute mass?
True, # visualization?
True, # collision?
dice_mat) # material
system.Add(die)
dice_position = [0, 5, 0]
my_tolerance = cascade.ChCascadeTriangulateTolerances(0.1 ,True,0.5)
my_body = cascade.ChBodyEasyCascade(my_shape,# the CAD shape
1000, # the density
my_tolerance, # must visualize triangle mesh geometry?
True, # must collide?
my_material) # collision material
mysystem.Add(my_body)
# Create a large cube as a floor.
my_floor = chrono.ChBodyEasyBox(1, 0.2, 1, # x y z size
1000, # density
True, # must visualize?
True, # must collide?
my_material) # collision material
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
#
# Set the global collision margins. This is expecially important for very large or # very small objects. Set this before creating shapes. Not before creating mysystem. chrono.ChCollisionModel.SetDefaultSuggestedEnvelope(0.001); chrono.ChCollisionModel.SetDefaultSuggestedMargin(0.001); # --------------------------------------------------------------------- # # Create the simulation system and add items # # Create a contact material (with default properties, shared by all collision shapes) contact_material = chrono.ChMaterialSurfaceNSC() # Create a floor mfloor = chrono.ChBodyEasyBox(3, 0.2, 3, 1000,True,True, contact_material) mfloor.SetBodyFixed(True) mysystem.Add(mfloor) # Now we will create a falling object whose shape is defined by a .obj mesh. # # NOTE: collision detection with generic concave meshes is slower and less # robust than any other options for collision shapes, so use it if defining # collision shapes via primitives like spheres boxes cylinders or their # clusters is too complex. # # NOTE: the mesh shape is a .obj file in Wavefront file format, # you can generate it from 3D modelers such as Blender, Maya, etc. # # NOTE: for collision purposes, the .obj mesh must be "watertight", i.e. having
mcolor = chrono.ChColorAsset(0.6, 0.6, 0.0)
mrotor.AddAsset(mcolor)
return mstator, mrotor
print("Copyright (c) 2017 projectchrono.org")
# Create a ChronoENGINE physical system
mphysicalSystem = chrono.ChSystemNSC()
# Contact material shared among all objects
material = chrono.ChMaterialSurfaceNSC()
# Create a floor that is fixed (that is used also to represent the absolute reference)
floorBody = chrono.ChBodyEasyBox(20, 2, 20, 3000, True, True, material)
floorBody.SetPos(chrono.ChVectorD(0, -2, 0))
floorBody.SetBodyFixed(True)
mphysicalSystem.Add(floorBody)
mtexture = chrono.ChTexture()
mtexture.SetTextureFilename(chrono.GetChronoDataFile("textures/blue.png"))
floorBody.AddAsset(mtexture)
# In the following we will create different types of motors
# - rotational motors: examples A.1, A.2, etc.
# - linear motors, examples B.1, B.2 etc.
# EXAMPLE A.1
#
# - class: ChLinkMotorRotationSpeed
my_torus = BRepPrimAPI.BRepPrimAPI_MakeTorus(0.1, 0.02).Shape()
my_cylinder = BRepPrimAPI.BRepPrimAPI_MakeCylinder(0.09, 0.1).Shape()
my_shape = BRepAlgoAPI.BRepAlgoAPI_Cut(my_torus, my_cylinder).Shape()
# use it to make a body with proper center of mass and inertia tensor,
# given the CAD shape. Also visualize it.
my_body = cascade.ChBodyEasyCascade(
my_shape, # the CAD shape
1000, # the density
True, # must collide using the triangle mesh geometry?
True) # must be visualized?
mysystem.Add(my_body)
# 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))
def AddContainer(sys):
# Contact material for container
ground_mat = chrono.ChMaterialSurfaceNSC()
# Create the five walls of the rectangular container, using fixed rigid bodies of 'box' type
floorBody = chrono.ChBodyEasyBox(20, 1, 20, 1000, True, True, ground_mat)
floorBody.SetPos(chrono.ChVectorD(0, -5, 0))
floorBody.SetBodyFixed(True)
sys.Add(floorBody)
wallBody1 = chrono.ChBodyEasyBox(1, 10, 20.99, 1000, True, True, ground_mat)
wallBody1.SetPos(chrono.ChVectorD(-10, 0, 0))
wallBody1.SetBodyFixed(True)
sys.Add(wallBody1)
wallBody2 = chrono.ChBodyEasyBox(1, 10, 20.99, 1000, True, True, ground_mat)
wallBody2.SetPos(chrono.ChVectorD(10, 0, 0))
wallBody2.SetBodyFixed(True)
sys.Add(wallBody2)
wallBody3 = chrono.ChBodyEasyBox(20.99, 10, 1, 1000, False, True, ground_mat)
wallBody3.SetPos(chrono.ChVectorD(0, 0, -10))
wallBody3.SetBodyFixed(True)
sys.Add(wallBody3)
wallBody4 = chrono.ChBodyEasyBox(20.99, 10, 1, 1000, True, True, ground_mat)
wallBody4.SetPos(chrono.ChVectorD(0, 0, 10))
wallBody4.SetBodyFixed(True)
sys.Add(wallBody4)
# optional, attach textures for better visualization
mtexturewall = chrono.ChTexture()
mtexturewall.SetTextureFilename(chrono.GetChronoDataFile("textures/concrete.jpg"))
wallBody1.AddAsset(mtexturewall) # note: most assets can be shared
wallBody2.AddAsset(mtexturewall)
wallBody3.AddAsset(mtexturewall)
wallBody4.AddAsset(mtexturewall)
floorBody.AddAsset(mtexturewall)
# Add the rotating mixer
mixer_mat = chrono.ChMaterialSurfaceNSC()
mixer_mat.SetFriction(0.4)
rotatingBody = chrono.ChBodyEasyBox(10, 5, 1, # x,y,z size
4000, # density
True, # visualization?
True, # collision?
mixer_mat) # contact material
rotatingBody.SetPos(chrono.ChVectorD(0, -1.6, 0))
sys.Add(rotatingBody)
# .. a motor between mixer and truss
my_motor = chrono.ChLinkMotorRotationSpeed()
my_motor.Initialize(rotatingBody,
floorBody,
chrono.ChFrameD(chrono.ChVectorD(0, 0, 0),
chrono.Q_from_AngAxis(chrono.CH_C_PI_2, chrono.VECT_X)))
mfun = chrono.ChFunction_Const(chrono.CH_C_PI / 4.0) # speed 45 deg/s
my_motor.SetSpeedFunction(mfun)
sys.AddLink(my_motor)
# NOTE: Instead of creating five separate 'box' bodies to make
# the walls of the container, you could have used a single body
# made of five box shapes, which build a single collision description,
# as in the alternative approach:
"""
# create a plain ChBody (no colliding shape nor visualization mesh is used yet)
mrigidBody = chrono.ChBody()
# set as fixed body, and turn collision ON, otherwise no collide by default
mrigidBody.SetBodyFixed(True)
mrigidBody.SetCollide(True)
# Clear model. The colliding shape description MUST be between ClearModel() .. BuildModel() pair.
mrigidBody.GetCollisionModel().ClearModel()
# Describe the (invisible) colliding shape by adding five boxes (the walls and floor)
mrigidBody.GetCollisionModel().AddBox(ground_mat, 20, 1, 20, chrono.ChVectorD(0, -10, 0))
mrigidBody.GetCollisionModel().AddBox(ground_mat, 1, 40, 20, chrono.ChVectorD(-11, 0, 0))
mrigidBody.GetCollisionModel().AddBox(ground_mat, 1, 40, 20, chrono.ChVectorD(11, 0, 0))
mrigidBody.GetCollisionModel().AddBox(ground_mat, 20, 40, 1, chrono.ChVectorD(0, 0, -11))
mrigidBody.GetCollisionModel().AddBox(ground_mat, 20, 40, 1, chrono.ChVectorD(0, 0, 11))
# Complete the description of collision shape.
mrigidBody.GetCollisionModel().BuildModel()
# Attach some visualization shapes if needed:
vshape = chrono.ChBoxShape()
vshape.GetBoxGeometry().SetLengths(chrono.ChVectorD(20, 1, 20))
vshape.GetBoxGeometry().Pos = chrono.ChVectorD(0, -5, 0)
this.AddAsset(vshape)
# etc. for other 4 box shapes..
"""
return rotatingBody
# # Create the simulation system and add items # mysystem = chrono.ChSystemNSC() # Some data shared in the following crank_center = chrono.ChVectorD(-1, 0.5, 0) crank_rad = 0.4 crank_thick = 0.1 rod_length = 1.5 # Create four rigid bodies: the truss, the crank, the rod, the piston. # Create the floor truss mfloor = chrono.ChBodyEasyBox(3, 1, 3, 1000) mfloor.SetPos(chrono.ChVectorD(0, -0.5, 0)) mfloor.SetBodyFixed(True) mysystem.Add(mfloor) # Create the flywheel crank mcrank = chrono.ChBodyEasyCylinder(crank_rad, crank_thick, 1000) mcrank.SetPos(crank_center + chrono.ChVectorD(0, 0, -0.1)) # Since ChBodyEasyCylinder creates a vertical (y up) cylinder, here rotate it: mcrank.SetRot(chrono.Q_ROTATE_Y_TO_Z) mysystem.Add(mcrank) # Create a stylized rod mrod = chrono.ChBodyEasyBox(rod_length, 0.1, 0.1, 1000) mrod.SetPos(crank_center + chrono.ChVectorD(crank_rad + rod_length / 2, 0, 0)) mysystem.Add(mrod)
# The path to the Chrono data directory containing various assets (meshes, textures, data files)
# is automatically set, relative to the default location of this demo.
# If running from a different directory, you must change the path to the data directory with:
#chrono.SetChronoDataPath('relative/path/to/data/directory/')
# ---------------------------------------------------------------------
#
# Create the simulation system and add items
#
mysystem = chrono.ChSystemNSC()
mysystem.Set_G_acc(chrono.ChVectorD(0, 0, 0))
# Create the ground body
ground = chrono.ChBodyEasyBox(3, 2, 0.1, 10, True, False)
ground.SetBodyFixed(True)
mysystem.Add(ground)
# Create the sliding body
# Give an initial angular velocity
body = chrono.ChBodyEasyBox(0.5, 0.5, 0.5, 10, True, False)
body.SetBodyFixed(False)
mysystem.Add(body)
body.SetPos(chrono.ChVectorD(-1.25, -0.75, 0.1))
body.SetWvel_loc(chrono.ChVectorD(0.1, 0.1, 0.1))
body_col = chrono.ChColorAsset()
body_col.SetColor(chrono.ChColor(0.9, 0.4, 0.1))
body.AddAsset(body_col)
