XDE Physics Tutorials. Release

Transcription

1 XDE Physics Tutorials Release July 04, 2012

2

3 CONTENTS 1 Simulate a simple pendulum Description of the system Building the system using XdeCore Displaying the mecanism Time integration The whole code Collision Detection and Friction Description of the system A few words on dry friction Defining friction materials in XdeCore Building the system using XdeCore Displaying the mecanism The whole code Dynamically Reconfiguring Kinetatic Graph Description of the system Operation on the kinematic graph Building the system using XdeCore Relinking and replacing joints The whole code Adding beam to XdeCore simulation Description of the system XdeCore Reissner beam Building the system using XdeCore The whole code The wheel chair Description of the system The whole code Adding beam to XdeCore simulation Description of the system Building the system using XdeCore The whole code Simulating a closed loop Description of the system Building the system using XdeCore i

4 ii 7.3 The whole code

5 iii

6 iv

7 CHAPTER ONE SIMULATE A SIMPLE PENDULUM Table of Contents Simulate a simple pendulum Description of the system Building the system using XdeCore Displaying the mecanism Time integration The whole code 1.1 Description of the system We want to simulate a simple pendulum, made of one rigid body connected to a fixed rigid body by an hinge joint. Intially, the pendulum isn t in its rest state, and will start to oscillate once the simulation is started. 1.2 Building the system using XdeCore Rigid Bodies XdeCore simulates the dynamics of multiple rigid bodies connected by joints. Rigid bodies can be created as simply as this : pendulum = xde::gvm::rigidbodyref::createobject("pendulum"); To physically simulate the dynamics of our system, we need to define the inertial properties of theses rigid bodies, i.e. we need to set their masses, intertia frames, center of mass and principal moments of inertia : pendulum.setmass(1.0); pendulum.setprincipalinertiaframe(displacementd::identity()); pendulum.setprincipalmomentsofinertia(eigen::vector3d::constant(1.)); Note that the method setprincipalinertiaframe takes a Displacement as argument, which means that it does not only set the inertia frame, but also defines the center of mass of the rigid body. The RigidBody class provides more than these 3 methods. We will cover theses methods in the following tutorials. 1

8 Figure 1.1: This is the pendulum kinematic graph. Attention: In XdeCore, there is a specific rigid bodies, called the GroundBody, which is automatically created, and which is the root of all the kinematic chains Joints In XdeCore, rigid bodies are interconnect by joint, that contrained motion between two rigid bodies. In this first tutorial, we ll use the HingeJoint, which adds and hinge constraint between two rigid bodies. hinge = xde::gvm::hingejointref::createobject("hinge"); This constraint must obviously be configured, to specify: 1. its position relative to the previous body, in this case, the GroundBody 2. the 3d position of its center in the previous body frame 3. its axis of rotation in the previous body frame 4. its reference joint position Once again, this is quite straightforward: Eigen::Vector3d axis(0., 0., 1.); Eigen::Vector3d center(0., 0., 0.); hinge.configure(displacementd(-1.5, 0., 0, 1.0, 0., 0., 0.), center, axis, 0.); mechanicalscene.addrigidbodytoground(pendulum, hinge); 2 Chapter 1. Simulate a simple pendulum

9 1.2.3 Mechanical scene Once we have created our rigid body, we d like to add it to our simulation. In XdeCore, the object responsible for the the simulation is the Scene. All the simulation objects, rigid bodies, joints, forces, interaction, collision mesh,... are added to the simulation through this Scene object. To create it, we need to set at least these three parameters : 1. The simulation time step 2. The kind of solver used: FRICTION_DYNAMIC_INTEGRATOR, NO_FRICTION_DYNAMIC_INTEGRATOR, The direction of the gravity field, which if the z axis by default. mechanicalscene = xde::gvm::sceneref::createobject("mechanicalscene"); mechanicalscene.setintegratorflags(xde::gvm::friction_dynamic_integrator); mechanicalscene.settimestep(1e-3); mechanicalscene.setverticaldirectionup(eigen::vector3d(0., 1.0, 0.)); Once it has been created, we can add our joint and rigid body to the simulation root rigid body, i.e. the GroundBody: mechanicalscene.addrigidbodytoground(pendulum, hinge); The rigid body of our pendulum has been created and its physical properties have been set. The joint connecting the pendulum to the GronudBody has also been created and configured. Both have been added to a mechcanical scene duly configured. XdeCore is ready to simulate our pendulum. However, it would be much more handy to have a graphical display to evaluate the simulation result. 1.3 Displaying the mecanism To display the simulation result we ll have to associate each simulation RigidBody with a graphical mesh. We provide with the tutorial code a simple class to do so. All the tutorials inherit from the same c++ class ugl::app whose interface follows : class App {... public: App(const std::string& n, unsigned int w = DEFAULT_WIDTH, unsigned int h = DEFAULT_HEIGHT); void Go(); void Start(); void Stop(); void Render(); void Update(double msec); }; virtual void OnRender() = 0; virtual void OnUpdate(double msec) = 0; virtual void OnMouse(int x, int y, int type, int button) = 0; virtual void OnKeyboard(char key, int type) = 0; virtual void OnLog(const std::string e) = 0; 1.3. Displaying the mecanism 3

10 This simple class handle the rendering using an OpenGL windows. All we have to do to create a XdeCore simulation is to create a TestApp class that inherits from this class, build the mechanical scene in its constructor, and overload the method iterate: class TestApp : public ugl::app { private: xde::gvm::sceneref mechanicalscene; xde::gvm::rigidbodyref pendulum; xde::gvm::hingejointref hinge; //graphical Objects PhysicsMapping physicsmapping; ugl::geom::trimesh meshground; ugl::geom::trimesh meshpendulum; public: TestApp(); protected: ugl::util::arcball trackball; bool mouse_right; }; virtual void OnRender(); virtual void OnUpdate(double msec); virtual void OnMouse(int x, int y, int type, int button); virtual void OnKeyboard(char key, int type); virtual void OnLog(const std::string message); Then, to associate a mesh to the GroundBody and the pendulum, we first load the geometry from an obj file, then add it to the renderlist and eventually link a RigidBody with this mesh : ///////////////////////////////////// // Create graphical objects // ///////////////////////////////////// //parse geometry from wavefront obj file xde::xgl::simplicialcomplexref scomplex = xde::xgl::simplicialcomplexref::createobject(); xde::xgl::objreader::readfromobj(scomplex,"sphere.obj",1.0/5.0,false); meshground = ugl::geom::trimesh::fromobj("sphere.obj", "sphere", Eigen::Vector4f(0., 1., 0., 0.), 1./5., false); meshground.build(); meshpendulum = ugl::geom::trimesh::fromobj("sphere.obj", "sphere", Eigen::Vector4f(0., 1., 0., 0.), 1./5., false); meshpendulum.build(); meshpendulum.position = pendulum.getposition(); this->renderlist.push_back(&meshground); this->renderlist.push_back(&meshpendulum); physicsmapping.mapmeshtobody(pendulum.getname(), meshpendulum); As the GroundBody does not move, it is unnecessary to map the graphical mesh with the physical body. 4 Chapter 1. Simulate a simple pendulum

11 1.4 Time integration In order to see the evolution of our system in time, we need to integrate the dynamical equation. This is simply done by calling the integrate method on the mechanicalscene inside the OnUpdate method: for(int t = 0 ; t < nbstepsbyframe ; ++t) { mechanicalscene.integrate(); physicsmapping.updategraphicspostion(mechanicalscene); } As the simulation period is quite shorter that the graphic period, we integrate nbstepsbyframe times. The graphical update is simply done calling updategraphicspostion. 1.5 The whole code 1.4. Time integration 5

12 6 Chapter 1. Simulate a simple pendulum

13 CHAPTER TWO COLLISION DETECTION AND FRICTION Table of Contents Collision Detection and Friction Description of the system A few words on dry friction Defining friction materials in XdeCore Building the system using XdeCore Displaying the mecanism The whole code 2.1 Description of the system We want to simulate two spheres falling under the effect of gravity, and colliding with a plan. Theses spheres have different friction parameters. One is made of steel and easily slides, whereas the other is made of rubber, and encounters more friction. The ground is made of steel. Rubber Sphere Steel Sphere Ground Figure 2.1: The initial set up of our simulation. The two spheres are freely falling on the ground. 7

14 2.2 A few words on dry friction As stated in the user manual, XdeCore support three friction laws : The Signorini Law The Signorini law, which is in fact not a friction law, but a contact law. This law ensures that when two objects are in contact, the minimal distance between the two object is null, and there is a strictly positive contact force. On the opposite, when there is no contact, the contact force must be null and the minimal distance between the two object is strictly positive. With this law, there is no tangent force, hence no friction The Coulomb Law The Coulomb law adds information for the tangent forces. It simply states that when a contact occurs, the tangential force norm must be included in a disk whose radius is mu * n, where n is the contact force normal value, and mu the friction coefficient. When the tangential forces lies inside the disk, there is no slipping, whereas when the tangential force is on the circle edge, the contact is slipping, and this slipping occurs in the opposite direction of the tangential force. This is the most frequently used law to model friction The Coulomb Contensou Law The Coulomb Contensou law is an extension of the Coulomb law to rotational friction. Indeed, with the coulomb law, no friction occurs when an object is rotated around a contact points. This means that if you grab an object with two material points using Coulomb friction, you won t be able to control the object orientation around the axis formed by the two contact points. The object will freely rotate around this axis. But, if you use a Coulomb Contensou model, friction will occur around this axis, and the rotation will be stopped, or at least reduce, depending on the value of the contact force normal component. The intensity of the friction moment around the contact normal depends on the contact force normal value and a parameters r that represents the radius of the surface in contact. The bigger r is, the bigger is the rotational friction. 2.3 Defining friction materials in XdeCore The friction properties are not defined for a material, but for a couple of materials. The coulomb friction coefficient of a glass sphere rolling on a steel table is not the same as the one for a rubber sphere. Therefore XdeCore defines friction properties for pairs of materials Defining a contact material Each rigid body can be associated with a contact material. All you have to do is call the setcontactmaterial method on a rigid body and specify a material name: rubberball.setcontactmaterial("rubber");... steelball.setcontactmaterial("steel"); 8 Chapter 2. Collision Detection and Friction

15 2.3.2 Defining friction properties for a couple of material The contact properties associated with a couple of materials are specified using a xde::gvm::contactlawdesc object. This class constructor takes up to 3 parameters, depending on the friction model used. Signorini friction If the contact model used the Signorini law, the xde::gvm::contactlawdesc object is created as follows: xde::gvm::contactlawdesc steelrubberlaw(xde::gvm::contactlaw::signorini); And there is not need for additional parameters. Coulomb friction If the contact model used the Coulomb law, the xde::gvm::contactlawdesc object is created as follows: double mu = 0.5; xde::gvm::contactlawdesc steelrubberlaw(xde::gvm::contactlaw::coulomb, mu); Where mu is the Coulomb friction coefficient. As explained above, the tangential friction forces are garanteed to be included in the disk of radius mu * normal force, and slipping occures only when the tangential forces are on the edge of this disk. Coulomb Contensou friction In the case of Contensou friction, the xde::gvm::contactlawdesc object takes three parameters and is created as follows: double mu = 0.5; double radius = 0.01; xde::gvm::contactlawdesc steelrubberlaw(xde::gvm::contactlaw::coulombcontensou, mu, radius); Where mu is the Coulomb friction coefficient, and radius precises the contact surface radius between the two objects. The bigger the radius is, the more important is the rotational friction. 2.4 Building the system using XdeCore This tutorial is not very complicated. Except for the handling of contact and friction, it is quite similar to the first one. Our system is made of two spheres falling under the effect of gravity, and encountering contact and friction with the ground. As the two spheres are freely falling, they are connected to the root body using a free joint, whereas the ground, that is fixed, is connected by a fixed joint Rigid Bodies The creation of the rigid bodies is quite simple. We set the bodies inertia properties as well as their position: //create ground ground = xde::gvm::rigidbodyref::createobject("ground"); mechanicalscene.addfixedrigidbody(ground); Eigen::Quaterniond q = Eigen::Quaterniond( 2.4. Building the system using XdeCore 9

16 Eigen::AngleAxisd(-15.0*M_PI / 180.0, Eigen::Vector3d::UnitY())) * Eigen::Quaterniond( Eigen::AngleAxisd(110.0*M_PI / 180.0, Eigen::Vector3d::UnitX())); Displacementd d(displacementd::identity()); d.getrotation() = Rotation3d(q); ground.setposition(d); ground.setmass(0.0); // ONLY fixed object can have a null mass. ground.setcontactmaterial("steel"); //create rubber Ball rubberball = xde::gvm::rigidbodyref::createobject("rubberball"); mechanicalscene.addfreerigidbody(rubberball); rubberball.setposition(displacementd(0., 1., 0., 1., 0., 0., 0.)); rubberball.setmass(1.0); rubberball.setprincipalinertiaframe(displacementd::identity()); rubberball.setprincipalmomentsofinertia(eigen::vector3d::constant(1.)); rubberball.setcontactmaterial("rubber"); //create steel Ball steelball = xde::gvm::rigidbodyref::createobject("steelball"); mechanicalscene.addfreerigidbody(steelball); steelball.setposition(displacementd(0.7, 1., 0., 1., 0., 0., 0.)); steelball.setmass(1.0); steelball.setprincipalinertiaframe(displacementd::identity()); steelball.setprincipalmomentsofinertia(eigen::vector3d::constant(1.)); steelball.setcontactmaterial("steel"); Note that XdeCore offers a simplified way to add free and fixed rigid bodies : the addfreerigidbody() and addfree- RigidBody() methods of the mechanical scene. With this two methods you don t have to bother with the joints creation Mechanical scene As you may have noticed, we have used a mechanical scene to add the rigid bodies to our simulation. This scene has been created with the following code : mechanicalscene = xde::gvm::sceneref::createobject("mechanicalscene"); lmdscene = xde::xcd::lmdsceneref::createobject("lmdscene", 0.05, 3.0 / * M_PI); mechanicalscene.setgeometricalscene(lmdscene); mechanicalscene.setintegratorflags(xde::gvm::friction_dynamic_integrator); mechanicalscene.settimestep(1e-3); mechanicalscene.setverticaldirectionup(eigen::vector3d(0., 1.0, 0.)); As for the first tutorial, we use a dynamical integrator with support for friction. As we plan to allow collision between rigid bodies, we also add a geometrical scene to the mechanical scene. This geometrical scene is responsible for the contact queries between the rigid bodies. XdeCore offers two differents geometrical scene: 1. The LmdScene, which computes local minimal distances on triangles meshes. LmdScene computes very precise contact informations but might be time consuming for large meshes. 2. The CddifScene, which computes distance between voxels and points shells. It is a very efficient engine, which supports large mesh at haptic rate. However, the contacts information is less precise than that of Lmd. 10 Chapter 2. Collision Detection and Friction

17 In this tutorial, as the meshes used are very simple, we choose the Lmd Engine. Warning: Sp?cifier ce que sont la lmd max et le param?tre de r?gularisation Setting the collision environment Added meshes to the geometrical scene At this point, we have created our three rigid bodies and added them to a duly configured mechanical scene. Now, we need to associate collision meshes to these rigid bodies. In XdeCore, a rigid body collision mesh is called a composite. A composite is made of several triangles meshes. Warning: Although TriMesh stands for Triangle Mesh, a TriMesh can contain only points and edges. We will see in tutorial 3 how, and why to use such sort of meshes. Let s see how we specified the collision mesh for the ground body: xde::xcd::compositeref& groundcomposite = lmdscene.createrigidcomposite ("groundcomposite"); xde::xcd::trimeshref& groundtrimesh = groundcomposite.createtrimesh ("groundtrimesh"); groundcomposite.addtrimesh (groundtrimesh); SimpleCollisionMeshBuilder::buildCollisionMesh(groundTrimesh, meshground, 1e-3); groundcomposite.updateprecomputeddata (); ground.setcomposite (groundcomposite); First, using the lmdscene, we create an empty groundcomposite. Then, using this composite, we create an empty groundtrimesh, and add it to the groundcomposite. Then, using a simple creation function, we fill the groundtrimesh with geometrical information: vertex and triangles. And finally, we precompute some data required by the Lmd engine, calling updateprecomputeddata (), and add the composite to the body ground. For the two spheres, the code is the same: //rubberball collision xde::xcd::compositeref& rubberballcomposite = lmdscene.createrigidcomposite ("rubberballcomposite"); xde::xcd::trimeshref& rubberballtrimesh = rubberballcomposite.createtrimesh ("rubberballtrimesh"); rubberballcomposite.addtrimesh (rubberballtrimesh); SimpleCollisionMeshBuilder::buildCollisionMesh(rubberBallTrimesh, rubbermeshball, 1e-3); rubberballcomposite.updateprecomputeddata (); rubberball.setcomposite (rubberballcomposite); mechanicalscene.enablecontactforbodypair(ground, rubberball, true); //steelball collision xde::xcd::compositeref& steelballcomposite = lmdscene.createrigidcomposite ("steelballcomposite"); xde::xcd::trimeshref& steelballtrimesh = steelballcomposite.createtrimesh ("steelballtrimesh"); steelballcomposite.addtrimesh (steelballtrimesh); SimpleCollisionMeshBuilder::buildCollisionMesh(steelBallTrimesh, rubbermeshball, 1e-3); steelballcomposite.updateprecomputeddata (); steelball.setcomposite (steelballcomposite); 2.4. Building the system using XdeCore 11

18 Enabling the collision For the optimisation sake, it is sometime interesting to enable collision only between a few number of objects. Hence, in XdeCore, no collision is enabled by default. In this tutorial, the two spheres should never collide, so we don t enable collision between them. mechanicalscene.enablecontactforbodypair(ground, steelball, true); mechanicalscene.enablecontactforbodypair(ground, rubberball, true); 2.5 Displaying the mecanism All we have to do to ensure the display of the three objects is to create the graphical meshes, add them to the viewer, and associate them with the corresponding rigid body : meshground = ugl::geom::trimesh::fromobj("plane.obj", "ground", Eigen::Vector4f(0.35, 0.35, 0.35, 0.), 4., false); meshground.build(); meshground.position = ground.getposition(); meshsteelball = ugl::geom::trimesh::fromobj("sphere.obj", "steelball", Eigen::Vector4f(0.45, 0.45, 0.45, 0.), 1. / 5., true); meshsteelball.build(); meshsteelball.position = steelball.getposition(); meshrubberball = ugl::geom::trimesh::fromobj("sphere.obj", "steelball", Eigen::Vector4f(0.45, 0.45, 0.45, 0.), 1. / 5., true); meshrubberball.build(); meshrubberball.position = rubberball.getposition(); this->renderlist.push_back(&meshground); this->renderlist.push_back(&meshsteelball); this->renderlist.push_back(&meshrubberball); physicsmapping.mapmeshtobody(steelball.getname(), meshsteelball); physicsmapping.mapmeshtobody(rubberball.getname(), meshrubberball); The graphical update is done in the the viewer OnUpdate method with the call below: physicsmapping.updategraphicspostion(mecanicalscene); 2.6 The whole code 12 Chapter 2. Collision Detection and Friction

19 CHAPTER THREE DYNAMICALLY RECONFIGURING KINETATIC GRAPH Table of Contents Dynamically Reconfiguring Kinetatic Graph Description of the system Operation on the kinematic graph Building the system using XdeCore Relinking and replacing joints The whole code 3.1 Description of the system In this tutorial, we will see a feature of XdeCore that can be very usefull : the dynamic modification of the kinematic graph. As you already know, in XdeCore, rigid bodies are interconnected by joints. The relation between all the rigids bodies and theirs joints can be seen as a graph, whose vertices are rigid bodies, and edges are joints. This graph is called the kinematic graph. XdeCore allows the user to change this graph dynamically, during the simulation execution. This can be very usefull in many simulations, where the kinematic constraints between objects changed during the simulation. The mechanical system simulated in this tutorial is made of three objets : Two fixed rigid bodies, that will be used as fixed centers of rotation for an hinge joint : FixedPoint0 and Fixed- Point1. A moving rigid body, pendulum, whose joint and preceding body are changed during the simulation. At the beginning, this body oscillate around FixedPoint0, but when its x coordinate reaches a defined value, his hinge joint is replaced by a free joint. Then, pendulum fall freely under the effect of gravity. Again, when its position reaches a specific value, the free joint is replaced by the previous hinge joint, and its preceding rigid body becomes FixedPoint Operation on the kinematic graph XdeCore allows the following operations on the kinematic graph: 13

20 Point 0 Point 1 Addition : You can always add a rigid body to the kinematic graph. Replacement : You can replace a joint by another kind of joint. Relink : You can change the preceding rigid body of a rigid body at any time. All these operations are made through the mechanical scene, using the three following methods: AddRigidBody(precedingRigidBody, newrigidbody, newjoint) ReplaceDgmJoint(oldJoint, newjoint) relink(rigidbody, newprecedingrigidbody) We have already seen in the previous tutorials how to add rigid bodies. In this tutorial, we ll discover how to replace a joint by another one, and how to relink a rigid body to another body. 3.3 Building the system using XdeCore This tutorial is not very complicated. Except for the handling of contact and friction, it is quite similar to the first one. Our system is made of two spheres falling under the effect of gravity, and encountering contact and friction with the ground. As the two spheres are freely falling, they are connected to the root body using a free joint, whereas the ground, that is fixed, is connected by a fixed joint Rigid Bodies The rigid bodies creation is very similar to what we do in the previous tutorials. The pendulum is created as usual: //create pendulum pendulum = xde::gvm::rigidbodyref::createobject("pendulum"); pendulum.setmass(1.0); pendulum.setprincipalinertiaframe(displacementd::identity()); pendulum.setprincipalmomentsofinertia(eigen::vector3d::constant(1.)); 14 Chapter 3. Dynamically Reconfiguring Kinetatic Graph

21 On the opposite, the creattion of FixedPoint0 and FixedPoint1 differs from what we ve done till now. XdeCore provides a dedicated method to add fixed object to the mechanical scene : addfixedrigidbody(). This methods add the addition of fixed bodies as it handle the creattion of the fixed joint. fixedpoint0 = xde::gvm::rigidbodyref::createobject("fixedpoint0"); fixedpoint1 = xde::gvm::rigidbodyref::createobject("fixedpoint1"); mechanicalscene.addfixedrigidbody(fixedpoint0); mechanicalscene.addfixedrigidbody(fixedpoint1); As we don t create fixed joint manually,we can t configure them to set the bodies positions. However, XdeCore provides a method in the RigidBody class, setposition(), that allows to set the position of a rigid body, if it as been added to the scene using the mechanical scene addfixedrigidbody or addfreerigidbody. fixedpoint0.setposition(displacementd(-2., 0., 0., 1.0, 0., 0., 0.)); fixedpoint1.setposition(displacementd(2., 0., 0., 1.0, 0., 0., 0.)); Warning: Be aware that we haven t set any inertia properties for FixedPoint0 and FixedPoint1. They are not required, as this two objects are fixed and add no degree of freedom to the simulation. So their inertia properties appear nowhere in the equations Joints The only moving object, pendulum, will use alternatively an hinge joint and a free joint. hinge = xde::gvm::hingejointref::createobject("hinge"); Eigen::Vector3d axis(0., 0., 1.); Eigen::Vector3d center(0., 0., 0.); hinge.configure(displacementd(-1.5, 0., 0, 1.0, 0., 0., 0.), center, axis, 0.); mechanicalscene.addrigidbody(fixedpoint0, pendulum, hinge); freejoint = xde::gvm::freejointref::createobject("pendulumfree"); //not used yet. At the beginning, the pendulum is attached to the FixedPoint0 using only the hinge, therefore we configure only this joint Mechanical scene We create the mechanical scene as usual: mechanicalscene = xde::gvm::sceneref::createobject("mechanicalscene"); mechanicalscene.setintegratorflags(xde::gvm::friction_dynamic_integrator); mechanicalscene.settimestep(10e-3); mechanicalscene.setverticaldirectionup(eigen::vector3d(0., 1.0, 0.)); As for the first tutorial, we use a dynamical integrator with support for friction. 3.4 Relinking and replacing joints Our simulation is now configure and can be runned immediately. However, we plan to dynamically change its kinematic graph. Our simulatio can be in three state: 3.4. Relinking and replacing joints 15

22 1. The pendulum is linked to FixedPoint0 by a hinge. 2. The pendulum moves freely under the effect of gravity. 3. The pendulum is linked to FixedPoint1 by a hinge. To manage these three states, we create two methods: 1. relinkwithfixedpoint 2. replacebyfree replacebyfree This method is the simplest one. It replaces the hinge joint by a free joint, without changing the pendulum preceding body. void Replace::replaceByFree(xde::gvm::RigidBodyRef body) { Twistd vel = pendulum.getvelocity(); } freejoint.configure(body.getinjoint().getprecedingrigidbody().getposition().inverse() * body.getposition()); mechanicalscene.replacedgmjoint(body.getinjoint(), freejoint); freejoint.setjointvelocities(vel); We configure the free joint with the position of the pendulum in the reference frame, and then replace hinge by freejoint. And then, to ensure the speed continuity, we set the free joint velocities to the pendulum velocity relinkwithfixedpoint This methods is slightly more complicated. We need to change the pendulum preceding rigid body as weel as the joint. void Replace::relinkWithFixedPoint(xde::gvm::RigidBodyRef body, xde::gvm::rigidbodyref fixedpoint) { Displacementd pos = body.getposition(); } mechanicalscene.relinkrigidbody(body, fixedpoint); Displacementd disp = fixedpoint.getposition().inverse() * pos; hinge.configure(disp, Eigen::Vector3d(0., 0., 0.), Eigen::Vector3d(0., 0., 1.), 0.); mechanicalscene.replacedgmjoint(body.getinjoint(), hinge); Eigen::VectorXd vel(1); vel.setzero(); hinge.setjointvelocities(vel); hinge.setjointposition(0); First we store the pendulum position. Second, we relink the pendulum with the new fixed point. Third, we configure the hinge so that pendulum stays at the same position. Fourth, we replace pendulum current joint by hinge. Finally, we set the hinge velocity to zero. Warning: For the sake of simplicity we have set the hinge velocity to zero. This will result in a non smooth motion and in energy loss. 16 Chapter 3. Dynamically Reconfiguring Kinetatic Graph

23 3.4.3 Dynamically switching from on state to the other Now we have all the code necessary to dynamically reconfigure our kinematic graph. All we have to do is improve a little the iterate() method to handle the transition between our simulation states. This is done quite simple with a few if : void Replace::iterate() { mechanicalscene.integrate(); meshes["fixedmesh0"].position = fixedpoint0.getposition(); meshes["fixedmesh1"].position = fixedpoint1.getposition(); meshes["pendulummesh"].position = pendulum.getposition(); if(pendulum.getposition().gettranslation()[0] > -0.7 && nextstep == FREE_TOWARD_1) { replacebyfree(pendulum); nextstep = FIXED1; } else if(pendulum.getposition().gettranslation()[0] > 0.0 && nextstep == FIXED1) { relinkwithfixedpoint(pendulum, fixedpoint1); nextstep = FREE_TOWARD_0; } else if(pendulum.getposition().gettranslation()[0] < 0.3 && pendulum.getvelocity().vx() < 0. && nextstep == FREE_TOWARD_0) { replacebyfree(pendulum); nextstep = FIXED0; } else if(pendulum.getposition().gettranslation()[0] < && nextstep == FIXED0) { relinkwithfixedpoint(pendulum, fixedpoint0); nextstep = FREE_TOWARD_1; } } 3.5 The whole code 3.5. The whole code 17

24 18 Chapter 3. Dynamically Reconfiguring Kinetatic Graph

25 CHAPTER FOUR ADDING BEAM TO XDECORE SIMULATION Table of Contents Adding beam to XdeCore simulation Description of the system XdeCore Reissner beam Building the system using XdeCore The whole code 4.1 Description of the system In this tutorial, we will add a new kind of body : a reissner beam. A reissner beam is a beam that deforms according to the law of elasticity, supports large displacement as long a deformation remains small, and can have arbitrary rest configuration. In this tutorial, we ll create a spring whose rest shape is helicoidal : Our beam looks like a spring. We ll also add a freely moving rigid body to illustrate the collision between rigid bodies and reissner beams. 4.2 XdeCore Reissner beam Features XdeCore allows to simulate beams with the following properties : They can have multiple concentric materials. They can undergo large displacement as long as the deformation remain small. They can have arbitrary rest configuration. They support collision with rigid bodies, other beams, as well as autocollision. Their section must be circular. 19

26 4.2.2 Setting cable physical properties XdeCore is an interactive simulator that try to simulate accurately physical phenomenum. Therefore, as for rigid bodies, that required inertia properties, the reissner beam need some physical parameters to be correctly configured. XdeCore reduces the number of these parameters to the strict minimum : the Young modulus, the shear modulus and the linear mass. Material 1 Air Material 2 Section 0 Section 1 Section 2 Figure 4.1: A beam with two materials and an empty core. In XdeCore, a Reissner beam can have multiple concentric materials. In the figure above, you can see an example of pipe with two external materials. A typical Beissner beam code creation follows : reissnerbeam = xde::gvm::generalizedreissnerbeamsdref::createobject("beam"); reissnerbeam.setnumberofnodes(nbnodes); reissnerbeam.setnumberofmaterials (2); reissnerbeam.init(); { } { } const double youngmodulus = 95.0e9 / ((meterstocentimeters)); const double poissonratio = 0.2; reissnerbeam.setmaterialyoungmodulus(youngmodulus, 0); reissnerbeam.setmaterialshearmodulus(youngmodulus / (2.0 * (1.0 + poissonratio)), 0); reissnerbeam.setsectionradius( *meterstocentimeters, 0); const double youngmodulus = 0.0; const double poissonratio = 0.2; reissnerbeam.setmaterialyoungmodulus(youngmodulus, 1); reissnerbeam.setmaterialshearmodulus(youngmodulus / (2.0 * (1.0 + poissonratio)), 1); reissnerbeam.setsectionradius( *meterstocentimeters, 1); This simply creates the beam, set the number of nodes in the beam, set the number of material, and finally set the mechanical properties of these materials. 20 Chapter 4. Adding beam to XdeCore simulation

27 Note: Note that the setmaterialyoungmodulus, setmaterialshearmodulus and setsectionradius take the material id as parameter Configuring the rest position The rest configuration of the beam must be given after adding the beam to the mechanical scene: std::vector<displacementd> referenceconfiguration;... mechanicalscene.addbeam(reissnerbeam); reissnerbeam.setreferenceconfiguration(referenceconfiguration); Collision support XdeCore automtically creates a collision mesh for your cable, so you don t have to bother with creating a collision mesh, as this is required for rigid bodies. 4.3 Building the system using XdeCore Rigid Bodies The rigid bodies creation is very similar to what we do in the previous tutorials. We have only 2 fixed bodies and 1 free body. mechanicalscene = xde::gvm::sceneref::createobject("mechanicalscene"); lmdscene = xde::xcd::lmdsceneref::createobject("lmdscene", 0.005, 3.0 / * M_PI); mechanicalscene.setgeometricalscene(lmdscene); mechanicalscene.setintegratorflags(xde::gvm::friction_dynamic_integrator); mechanicalscene.settimestep(10e-3); mechanicalscene.setverticaldirectionup(eigen::vector3d(0., 1.0, 0.)); //create freebody freebody = xde::gvm::rigidbodyref::createobject("freebody"); freebody.setmass(1.0); freebody.setprincipalinertiaframe(displacementd::identity()); freebody.setprincipalmomentsofinertia(eigen::vector3d::constant(1.)); mechanicalscene.addfreerigidbody(freebody); freebody.setposition(displacementd(0., 2.0, 0., 1.0, 0., 0., 0.)); //create fixed points fixedpoint0 = xde::gvm::rigidbodyref::createobject("fixedpoint0"); fixedpoint1 = xde::gvm::rigidbodyref::createobject("fixedpoint1"); //Note that we don t create fixed joint. The mechanical scene does it for us. mechanicalscene.addfixedrigidbody(fixedpoint0); mechanicalscene.addfixedrigidbody(fixedpoint1); 4.3. Building the system using XdeCore 21

28 //As our body are fixed, wa can direclty set their position using setposition() //Note that this methods works only for bodies added // using addfixedrigidbody() or addfreerigidbody() fixedpoint0.setposition(displacementd(-1., 2.5, 0., 1.0, 0., 0., 0.)); fixedpoint1.setposition(displacementd(1., 2.5, 0., 1.0, 0., 0., 0.)); //Important : we don t have to set fixed bodies intertia properties //as fixed bodies are not really simulated since their don t move. //They add no additional degree of freedoms in the simulation. We don t bother with the joints creation and use the two mechanical scene helper methods : addfreerigidbody and addfixedrigidbody Beam Our beam is made of a unique material. It s configuration is done as follow: //create beam reissnerbeam = xde::gvm::generalizedreissnerbeamsdref::createobject("beam"); reissnerbeam.setnumberofnodes(nbnodes); reissnerbeam.setnumberofmaterials (1); reissnerbeam.init(); const double youngmodulus = 95.0e7; const double poissonratio = 0.2; const double radius = 0.01; const double volumicmass = 9.0; const double section = M_PI * radius*radius; reissnerbeam.setmaterialyoungmodulus(youngmodulus, 0); reissnerbeam.setmaterialshearmodulus(youngmodulus / (2.0 * (1.0 + poissonratio)), 0); reissnerbeam.setsectionradius(radius, 0); reissnerbeam.setlinearmass (section * volumicmass); reissnerbeam.setdampingcoeff(0.0); In its rest state, our beam has a spring shape. The nodes position is computed by the following lines: const int nbloops = 8; std::vector<displacementd> referenceconfiguration; for(int nidx = 0 ; nidx < nbnodes ; ++nidx) { const double angle = nbloops*nidx* 2.0*M_PI / nbnodes; const double xoffset = nidx * 2.0 / nbnodes; Displacementd localdisp = Displacementd(Eigen::Vector3d::Identity(), Eigen::AngleAxisd(angle, Eigen::Vector3d::UnitX()) ) * Displacementd(xOffset, 3/5., 0., 1., 0., 0., 0. ); Displacementd disp = freebody.getposition() * localdisp; } referenceconfiguration.push_back(disp); This configuration is then given to the beam, after having added it to the mechanical scene: reissnerbeam.setreferenceconfiguration(referenceconfiguration); As we want to weld the beam endings to the two fixed bodies, we use the mechanical scene weldreissnerbeamnodeto- RigidBody() method: 22 Chapter 4. Adding beam to XdeCore simulation

29 mechanicalscene.weldreissnerbeamnodetorigidbody(reissnerbeam, 0, fixedpoint0); mechanicalscene.weldreissnerbeamnodetorigidbody(reissnerbeam, reissnerbeam.getnumberofnodes()-1, fixedpoint1); The first call weld the first beam node beam to fixedpoint0, whereas the second line weld the last node to fixedpoint Mechanical scene We create the mechanical scene as usual: mechanicalscene = xde::gvm::sceneref::createobject("mechanicalscene"); lmdscene = xde::xcd::lmdsceneref::createobject("lmdscene", 0.005, 3.0 / * M_PI); mechanicalscene.setgeometricalscene(lmdscene); mechanicalscene.setintegratorflags(xde::gvm::friction_dynamic_integrator); mechanicalscene.settimestep(10e-3); mechanicalscene.setverticaldirectionup(eigen::vector3d(0., 1.0, 0.)); As for all the tutorials, we use a dynamical integrator with friction support. Warning: As XdeCore automatically add a collision mesh to beam, the mechanical must be associated with a geometrical scene. 4.4 The whole code 4.4. The whole code 23

30 24 Chapter 4. Adding beam to XdeCore simulation

31 CHAPTER FIVE THE WHEEL CHAIR Table of Contents The wheel chair Description of the system The whole code 5.1 Description of the system Todo 5.2 The whole code 25

32 26 Chapter 5. The wheel chair

33 CHAPTER SIX ADDING BEAM TO XDECORE SIMULATION Table of Contents Adding beam to XdeCore simulation Description of the system Building the system using XdeCore The whole code 6.1 Description of the system In this tutorial we ll simulate a simple car. It will consist in the following elements : A main rigid body, the chassis. Four wheels, that will be attached to the chassis with a serial joint made of one prismatic and one hinge joints. This tutorial is a good opportunity to expose an interesting feature of XdeCore : the articular control using a Proportional Derivative Coupling, reffered below ad a PD coupling. This features allows the user to control the speed and/or position of a joint. For this tutorial, we use both control mode: The four wheels are controlled in position, to simulated their shock absorber. The two front wheels are controlled in velocity, to create a torque and drive the car. This tutorial also introduces a new king of joint, the serial joint, that allows to introduce multiple joints between two rigid bodies without having to create intermediate bodies. 6.2 Building the system using XdeCore Controlling articular position and speed The building of the mecanism is very similar to what we ve done in the previous tutorials. The main difference lies in the use of the joint Proportional Derivative coupling, which can be activated and configure as follows, when controlling the position : 27

34 prisma.configure(pos, Eigen::Vector3d::UnitY(), 0.); prisma.setdesiredjointvelocity(0.); prisma.setdesiredjointposition(0.); prisma.setjointpdgains(1e5, 1e4); prisma.enablejointpdcoupling(); The method setjointpdgains defines the proportional and derivative gains for the coupling, i.e. the gain in position and velocity. These gains can be regarded as a stiffness for the gain in position and a damping for the gain in velocity. To simulate the shock absorber, we have to simulate a spring as well as a damper, hence we set these two gains to non null values. The desired articular position and velocity are then simply defined using setdesiredjointposition and setdesiredjointvelocity. Concerning the velocity control of the two front wheels, we use the same methods. However, as we don t what to control the wheels articular position, we set the position gain to zero. hinge.configure(pos, center, axis, 0.); hinge.setjointpdgains(0., 1.e2); hinge.setdesiredjointvelocity(0.); As we want that, initially, the car rests immobile, we set the desired joint velocity to zero. When we want to drive the car, we just have to press the z or s keys. The following lines, found in OnKeyboard method will activate the velocity control: if (key == z ) { hinge0.setdesiredjointvelocity(-3.); hinge1.setdesiredjointvelocity(-3.); } if (key == s ) { hinge0.setdesiredjointvelocity(3.); hinge1.setdesiredjointvelocity(3.); } Creating serial joint Usually, a wheel has two or three degrees of freedom, with respect to the chassis. If it s a rear wheel, it can: translate along the ground normal. This freedom is allowed vy the shock absorber. rotate along its axis, thanks to an hinge. If it s a front wheel it has the same degrees of freedom, plus the ability to rotate along the ground normal. This allows to oriente the car. AS you have learned in the previous tutorial, it is not possible to connect a joint to another joint. A joint always connect two rigid bodies together. Hence, if we want to connect the rear wheels with a prismatic and an hinge joints, to ensure the two DOF listed above, we have to introduce an intermediate rigid body. This is not very handy, as this required the creation of an additional, quite useless, rigid body for each rear wheel. Fortunately, XdeCore offers a joint which can gather multiple joints and hence avoid the addition of arbitrary intermediate rigid bodies. This joint is the SerialJoint, and can be use like this: serial = xde::gvm::serialjointref::createobject(ss.str()); serial.setnbjoints(2); ss.str(""); 28 Chapter 6. Adding beam to XdeCore simulation

35 ss << name << "hinge"; hinge = xde::gvm::hingejointref::createobject(ss.str()); ss.str(""); ss << name << "prisma"; xde::gvm::prismaticjointref prisma = xde::gvm::prismaticjointref::createobject(ss.str()); serial.setdgmjoint(0, prisma); serial.setdgmjoint(1, hinge); serial.init(); Eigen::Vector3d axis(0., 0., 1.); Eigen::Vector3d center = pos.gettranslation(); prisma.configure(pos, Eigen::Vector3d::UnitY(), 0.); prisma.setdesiredjointvelocity(0.); prisma.setdesiredjointposition(0.); prisma.setjointpdgains(1e5, 1e4); prisma.enablejointpdcoupling(); hinge.configure(pos, center, axis, 0.); hinge.setjointpdgains(0., 1.e2); hinge.setdesiredjointvelocity(0.); hinge.enablejointpdcoupling(); mechanicalscene.addrigidbody(chassis, wheel, serial); First we create the SerialJoint as well as the two joints it ll gather. Then we configure the SerialJoint by specifying the number of joints it ll gather, set these joints, and init the SerialJoint. The hinge and prismatic joint are the configured as usual, and the rigid body is attached to the previous one as usual, using the addrigidbody method. Note: Each joint in the SerialJoint is configured with respect to the previous joint position, except for the joint 0 that is configured according to the previous rigid body position. 6.3 The whole code 6.3. The whole code 29

36 30 Chapter 6. Adding beam to XdeCore simulation

37 CHAPTER SEVEN SIMULATING A CLOSED LOOP Table of Contents Simulating a closed loop Description of the system Building the system using XdeCore The whole code 7.1 Description of the system The robot that we d like to simulate in this tutorial has a kinematic graph tha include a closed loop: CutJoint Figure 7.1: This is the kinematic graph of our robot. It forms a closed loop. XdeCore can simulate this kind of robot. As specific joint, the CutJoint, allows to close a kinematic graph and hence create a robot with a closed loop. 31

38 7.2 Building the system using XdeCore Closing a loop The building of the mecanism is very similar to what we ve done in the previous tutorials. As seen on the picture above, our robot is made of 4 BallJoint, a FixedJoint and a CutJoint. The creation of the usuals joint is done as usual. The CutJoint creation and configuration is new but isn t much different from what we ve done before. We encapsulate this code into the method weld(). The most important lines are shown below: } if (!cutjoint.isvalid()) // check wheter cutjoint has already been created { cutjoint = xde::gvm::cutjointref::createobject("cutjoint"); cutjoint.setrigidbody_i(body_i); cutjoint.setrigidbody_j(body_j); cutjoint.configurefromcurrentrigidbodypositions(); cutjoint.enable(); mechanicalscene.add(cutjoint); } else { cutjoint.configurefromcurrentrigidbodypositions(); cutjoint.enable(); } First, using the ObjectRef method isvalid(), we ensure that the cutjoint has not already been created. If this is not the case, we create the CutJoint, set the two rigid bodies to weld. Then, we configure the joint using the current rigid bodies position, which means that the two rigid bodies will be weld using their current relative position. Eventually, we enable it and add it to the scene. On the opposite, if the CutJoint has already been created, we simply reconfigure the CutJoint using body_i and body_j current position an re enable it Opening a loop You re application may also require the opening of the loop. This can be done very easily. The few instruction required for this operation can be found in the method unweld(). The only lines required is: cutjoint.disable(); An alternative way to build a closed loop XdeCore xde::gvm::sceneref provides two methods to even more easily create a closed loop. These methods are the weld() and unweld(). Using these two methods, the closing of the loop is made with this simple call: mechanicalscene.weld(body_i, body_j); Whereas the loop opening is made with: mechanicalscene.unweld(body_i, body_j); 32 Chapter 7. Simulating a closed loop

39 7.3 The whole code 7.3. The whole code 33