**actuator**An

*actuator*is a machine component that converts a Simulink^{®}signal into Simscape™ Multibody™ force, torque, or motion signals.You can configure a

*body**actuator*to apply forces/torques to a body either as an explicit function of time or through feedback forces/torques.You can configure a

*joint actuator*to apply forces/torques between the bodies connected on either side of the joint.You can configure a

*driver actuator*to apply relative motion between the bodies connected on either side of the driver.

Two specialized Simscape Multibody actuators set

*joint initial conditions*and apply*stiction*to a joint, respectively.Actuator What the Actuator Does Body Actuator Applies forces to a body Driver Actuator Applies motion to a time-dependent constraint Joint Actuator Applies forces or motions to a joint Joint Initial Condition Actuator Sets a joint's initial conditions Joint Stiction Actuator Applies static and kinetic friction to joint motion A Simscape Multibody Actuator block has an open round Simscape Multibody connector port for connecting with a Body, Joint, or Driver block and an angle bracket > Simulink inport for connecting with normal Simulink blocks, such as Source blocks for generating force or torque signals.

See also

*body*,*connector port*,*driver*,*initial condition actuator*,*joint*,*primitive joint*,*sensor,*and*stiction actuator.***adjoining CS**The

*adjoining CS*of a Body coordinate system (CS) is the CS on the neighboring body or ground directly connected to the original Body CS by a Joint, Constraint, or Driver.See also

*body*,*Body CS*,*coordinate system (CS)*,*grounded CS*, and*World*.**assembled configuration**A machine is in its

*assembled configuration*once it passes from its home configuration through its initial configuration and its disassembled joints are then assembled. The assembly of joints can change body and joint configurations.See also

*home configuration*and*initial configuration*.**assembled joint**An

*assembled joint*restricts the Body coordinate systems (CSs) on the two bodies at either end of the joint.For an

*assembled prismatic joint,*the two Body CS origins must lie along the prismatic axis. The two Bodies translate relatively along the same axis.For an assembled joint with multiple prismatic primitives, the two Body CS origins must lie in the plane or space defined by the directions of the prismatic axes.

For an

*assembled revolute joint,*the two Body CS origins must be collocated. The two Bodies rotate relatively about the same axis.For an assembled joint with multiple revolute primitives, the two Body CS origins must be collocated.

For an

*assembled spherical joint,*the two Body CS origins must be collocated at the spherical primitive's pivot point. The two Bodies pivot relatively about this common origin.

You specify an assembly tolerance for assembled joints, the maximum dislocation distance allowed between all pairs of assembled Body CS origins and the maximum angle of misalignment between all pairs of assembled Body motion axes. If the distance dislocations and/or axis misalignments in an assembled joint grow larger than the assembly tolerance, the simulation stops with an error.

See also

*assembly tolerance, Body CS, collocation, disassembled joint, joint,*and*primitive joint*.**assembly**An

*assembly*represents a mechanical system in computer-aided design (CAD). An assembly includes*parts*(bodies with full geometric, mass, and inertia tensor information), as well as*constraints*(sometimes called*mates*) restricting the*degrees of freedom*of the parts.Every assembly has a

*fundamental root*attached to the assembly coordinate origin. Assemblies can also have one or more*subassemblies*branching off the main assembly at a single point.Assembly specifications typically also include design tolerances and how subassemblies move and how they are connected to the main assembly.

See also

*associativity*,*body*,*computer-aided design (CAD)*,*constraint*,*degree of freedom (DoF)*,*fundamental root*,*inertia tensor*,*mass*,*part*, and*subassembly*.**assembly tolerance**The

*assembly tolerance*is a range that determines how closely an*assembled joint*must be collocated and aligned. An*assembled joint*is connected on either side to Body coordinate systems (CSs) on two Bodies and restricts the relative configurations and motions of those Body CSs.The assembly tolerances set the

*maximum dislocation*of Body CS origins and*maximum misalignment*of motion axes allowed in assembled joints during the simulation.For

*assembled prismatic primitives,*each pair of Body CS origins must lie in the subspace defined by the prismatic axes. Each pair of Bodies translates along these common axes.For

*assembled revolute primitives,*each pair of Body CS origins must be collocated and their respective rotational axes aligned. Each pair of Bodies rotates about these common axes.For an

*assembled spherical primitive,*the pair of Body CS origins must be collocated. The two Bodies pivot about this common origin.

A Simscape Multibody simulation attempts to assemble all joints in your machine at the start of simulation, including initially disassembled joints. If it cannot, the simulation stops with an error.

If the two Body CSs separate or the joint axes misalign in a way that makes their connecting assembled joint primitives no longer respect the assembly tolerances, the simulation stops with an error.

See also

*assembled joint, Body CS, collocation, disassembled joint,*and*joint*.**associativity***Associativity*is a persistent and session-independent parallel relationship among certain components of a CAD assembly, Physical Modeling XML files exported from it, and Simscape Multibody models generated from the XML. This relationship preserves the identities and parallelisms of certain CAD components (parts, geometric and kinematic relationships, subassembly hierarchy) and the corresponding components of the Simscape Multibody model. These Simscape Multibody model components include:Body and Ground blocks

Joint blocks

Coordinate systems connected to Joints

Subsystem hierarchies

CAD assembly and Simscape Multibody model components related in this way are

*associated*. If they are not so related, they are not associated or*nonassociated*.See also

*assembly*,*body*,*Body CS*,*computer-aided design (CAD)*,*constraint*,*ground*,*joint*,*part*, and*subassembly*.**axis-angle rotation**An

*axis-angle rotation*mathematically represents a three-dimensional spherical rotation as a rotation axis vector= (*n**n*_{x},*n*_{y}*,n*_{z}) of unit length (=*n·n**n*_{x}^{2}+*n*_{y}^{2}+*n*_{z}^{2}= 1) and a rotation angle θ. Define the rotation axis by the vector; rotate about that axis by θ using the right-hand rule. The*n*axis is sometimes called the*n**eigenaxis*.The rotation axis direction is equivalent to specifying two independent angles; θ is the third independent angle making up the rotation.

In VRML, you represent body rotations by a vector signal [

*n*_{x}*n*_{y}*n*_{z}θ].See also

*degree of freedom (DoF)*,*Euler angles*,*primitive joint*,*quaternion*,*right-hand rule*,*rotation matrix*, and*VRML*.**base (base body)**The

*base body*is the body from which a joint is directed. The joint directionality runs from base to follower body.Joint directionality sets the direction and the positive sign of all joint motion and force-torque data.

See also

*body, directionality, follower (follower body),*and*right-hand rule.***body**A

*body*is the basic element of a mechanical system. It is characterized by itsMass properties (mass and inertia tensor)

Position and orientation in space

Attached Body coordinate systems

Bodies are connected to one another by joints, constraints, or drivers. Bodies carry no degrees of freedom.

You can attach to a Body block any number of Body coordinate systems (CSs). All Simscape Multibody Bodies automatically maintain a minimum of one Body CS at the body's center of gravity (CG). The Body block has distinctive axis triad CS ports , instead of the open, round connector ports , to indicate the attached Body CSs.

See also

*actuator, adjoining CS, Body CS, center of gravity (CG), convex hull, coordinate system (CS), degree of freedom (DoF), equivalent ellipsoid, inertia tensor, joint, local CS, mass,*and*sensor*.**Body CS**A

*Body CS*is a local coordinate system (CS) attached to a body, carried along with that body's motion. In general, bodies accelerate as they move, and therefore Body CSs define noninertial reference frames.You can attach any number of Body CSs to a Body block, and you can choose where to place the Body CS origins and how to orient the Body CS axes. The Body block has distinctive axis triad Body CS ports instead of the open, round connector ports, to give you access to these Body CSs for connecting Joint, Sensor, and Actuator blocks.

Every Body block has an automatic, minimum Body CS at its center of gravity (CG). By default, it also has two other Body CSs for connection to adjacent Joints. Once you set the origin and axis orientation of each Body CS during Body configuration, the Body CSs are interpreted as fixed rigidly in that body during the simulation.

See also

*body, center of gravity (CG), convex hull, coordinate system (CS), ground, grounded CS, local CS, reference frame (RF),*and*World*.**CAD****center of gravity (CG)**The

*center of gravity*or center of mass of an extended body is the point in space about which the entire body balances in a uniform gravitational field. For translational dynamics, the body's entire mass can be considered as if concentrated at this point.Every Body block has an automatic, minimum Body coordinate system (CS) with its origin at the CG — the CG CS. This origin point and the Body CS coordinate axes remain fixed rigidly in the body during the simulation.

See also

*body, Body CS, degree of freedom (DoF), inertia tensor, kinematics,*and*primitive joint*.**CG****closed loop machine**A machine diagram contains one or more

*closed loops*if, beginning at a starting point, you can trace a path through the machine back to the starting point without jumping out of or cutting the diagram. The number of closed loops is equal to the minimum number of cuttings needed to convert the diagram into a*tree*or*open*machine.See also

*open machine*and*topology*.**collocation***Collocation*is the coincidence of two points in space, within assembly tolerances.See also

*assembled joint*,*assembly tolerance*, and*disassembled joint.***composite joint**A

*composite joint*is a joint compounded from more than one joint primitive and thus representing more than one degree of freedom. The joint primitives constituting a composite joint are the*primitives*of that joint.A spherical primitive represents three rotational degrees of freedom, but is treated as a primitive.

See also

*constrained joint, degree of freedom (DoF), joint,*and*primitive joint*.**computer-aided design (CAD)**Computer-aided design systems or platforms provide an environment to design machines, with full geometric information about

*parts*(bodies) and their spatial relationships, as well as the*degrees of freedom*and mass properties of the parts.A CAD representation of a machine is an

*assembly*.See also

*assembly*,*associativity*,*body*,*constraint*,*degree of freedom (DoF)*,*inertia tensor*,*mass*,*part*, and*STL*.**connection line**You connect each Simscape Multibody block to another by using

*Simscape Multibody connection lines*. These lines function only with Simscape Multibody blocks. They do not carry signals, unlike normal Simulink lines, and cannot be branched. You cannot link connection lines directly to Simulink lines.By default, connection lines appear red and dashed if they are not anchored at both ends to a connector port . Once you anchor them, the lines become black and solid.

However, if you have selected a nonnull choice in

**Sample Time Display**from your model's**Format**menu, the connection line displays instead with whatever color chosen to indicate the sample time.See also

*actuator, connector port,*and*sensor*.**connector port**A

*connector port*is an anchor for a connection line. Each Simscape Multibody block has one or more open round Simscape Multibody connector ports for connecting to other Simscape Multibody blocks. You must connect these round ports only to other Simscape Multibody round ports. When an open connector port is attached to a connection line, the Port changes to solid .A

*Connection Port block*is provided in the Simscape Multibody library to create a round Simscape Multibody connector port for an entire subsystem on that subsystem's boundary.See also

*actuator, connection line,*and*sensor*.**constrained joint**A

*constrained joint*is a composite joint with one or more internal constraints restricting the joint's primitives.An example is the Screw block, which has a prismatic and a revolute primitive with their motions in fixed ratio. Only one of these degrees of freedom is independent.

See also

*degrees of freedom (DoF), joint,*and*primitive joint.***constraint**A

*constraint*is a restriction among degrees of freedom imposed independently of any applied forces/torques. A*constraint*removes one or more independent degrees of freedom, unless that constraint is*redundant*and restricts degrees of freedom that otherwise could not move anyway. Constraints can also create*inconsistencies*with the applied forces/torques that lead to simulation errors.Constraints are

*kinematic*: they must involve only coordinates and/or velocities. Higher derivatives of coordinates (accelerations, etc.) are determined by the Newtonian force and torque laws and cannot be independently constrained.Constraints are

*holonomic*(integrable into a form involving only coordinates) or*nonholonomic*(not integrable; that is, irreducibly involving velocities).Constraints specify kinematic relationships that are explicit functions of time

*(rheonomic)*or not*(scleronomic)*.Simscape Multibody

*Constraints*represent scleronomic constraints, and*Drivers*represent rheonomic constraints. Simscape Multibody Constraint and Driver blocks are attached to pairs of Body blocks.In Simscape Multibody models with closed loops, one Joint, Constraint, or Driver per loop is internally cut and replaced by an invisible scleronomic or rheonomic constraint.

Constraints are

*redundant*if they independently impose the same restrictions on a machine.

In computer-aided design (CAD) assemblies, a constraint restricts one or more degrees of freedom of the assembly parts. (CAD constraints are sometimes called

*mates*.) When a CAD assembly is converted to a Simscape Multibody model, such restricted degrees of freedom are translated into specific joints. (Simscape Multibody bodies have no degrees of freedom.)See also

*assembly*,*associativity*,*body*,*computer-aided design (CAD)*,*degree of freedom (DoF)*,*directionality*,*driver*,*joint*,*machine precision constraint*,*part*,*stabilizing constraint*,*tolerance*, and*topology*.**convex hull**The

*convex hull*of a set of points in space is the surface of minimum area with convex (outward) curvature that passes through all the points in the set. In three dimensions, this set must contain at least four distinct, non-coplanar points to make a closed surface with nonzero enclosed volume.The convex hull is an option for visualizing a Simscape Multibody body. The set of points is all the Body coordinate system (CS) origins configured in that Body block. The visualization of an entire machine is the set of the convex hulls of all its bodies. A Simscape Multibody convex hull excludes the body's center of gravity CS.

If a Body has fewer than four distinct, non-coplanar Body CSs, its convex hull is a lower-dimensional figure:

Three distinct Body CSs produce a triangle without volume.

Two distinct Body CSs produce a line without area.

One Body CS produces a point without length.

See also

*body*,*Body CS*,*equivalent ellipsoid*, and*STL*.**coordinate system (CS)**A

*coordinate system*is a geometric object defined, in a particular reference frame, by a choice of*origin*and orientation of*coordinate axes*, assumed orthogonal and Cartesian (rectangular). An observer attached to that CS measures distances from that origin and directions relative to those axes.Simscape Multibody software supports two CS types:

World:

*global*or*absolute inertial*CS at restThe assembly origin of a CAD assembly translated into a model becomes the World CS origin.

Local:

Grounded CS

Body CS, including the center of gravity (CG) CS

Constraint points on CAD parts in a CAD assembly translated into a model become Body CS origins on the bodies representing the parts.

Local coordinate systems are sometimes called

*working frames*.See also

*body, Body CS, center of gravity (CG),*and*computer-aided design (CAD)*convex hull, grounded CS, local CS, reference frame (RF),*World*.**degree of freedom (DoF)**A

*degree of freedom*is a single coordinate of relative motion between two bodies. Such a coordinate is free only if it can respond without constraint or imposed motion to externally applied forces or torques. For translational motion, a DoF is a linear coordinate along a single direction. For rotational motion, a DoF is an angular coordinate about a single, fixed axis.A

*prismatic*joint primitive represents a single translational DoF. A*revolute*joint primitive represents a single rotational DoF. A*spherical*joint primitive represents three rotational DoFs in angle-axis form. A*weld*joint primitive represents zero DoFs.See also

*body, coordinate system (CS), dynamics, joint,*and*kinematics*.**directionality**The

*directionality*of a joint, constraint, or driver is its direction of forward motion.The joint directionality is set by the order of the joint's connected bodies and the direction of the joint axis vector. One body is the

*base*body, the other the*follower*body. The joint direction runs from base to follower, up to the sign of the joint axis vector. Reversing the base-follower order or the joint axis vector direction reverses the forward direction of the joint.Joint directionality sets the direction and the positive sign of all joint motion and force-torque data.

Directionality of constraints and drivers is similar, except there is no joint axis, only the base-follower sequence.

See also

*base (base body)*,*body, follower (follower body), joint,*and*right-hand rule*.**disassembled joint**A

*disassembled joint*is a joint that need not respect the assembly tolerances of your machine.For a

*disassembled prismatic primitive*, the Body coordinate system (CS) origins do not have to lie on the prismatic axis.For a

*disassembled revolute primitive*, the Body CS origins do not have to be collocated.For a

*disassembled spherical primitive*, the Body CS origins do not have to be collocated.

A Simscape Multibody simulation attempts to assemble all disassembled joints in your machine at the start of simulation. If it cannot, the simulation stops with an error.

You can use disassembled joints only in a closed loop, with no more than one per loop.

See also

*assembled joint*,*assembly tolerance, closed loop system*,*collocation*, and*topology.***DoF****driver**A

*driver*is a constraint that restricts degrees of freedom as an explicit function of time (a rheonomic constraint) and*independently*of any applied forces/torques. A driver removes one or more independent degrees of freedom, unless that driver is*inconsistent*with the applied forces/torques and forces a simulation error.You specify the driver function of time in a dialog box in terms of an input Simulink signal from a Driver Actuator.

Simscape Multibody Driver blocks are attached to pairs of Body blocks.

See also

*actuator*,*body*,*constraint*,*directionality*, and*degree of freedom (DoF)*.**dynamics***Dynamics*is distinguished from*kinematics*by explicit specification of applied forces/torques and body mass properties.A

*forward dynamic*analysis of a mechanical system specifiesThe topology of how bodies are connected

The degrees of freedom (DoFs) and constraints among DoFs

All the forces/torques applied to the bodies

The mass properties (masses and inertia tensors) of the bodies

The initial condition of all DoFs:

Initial linear coordinates and velocities

Initial angular coordinates and velocities

The analysis then solves Newton's laws to find the system's motion for all later times.

*Inverse dynamics*is the same, except that the system's motion is specified and the forces/torques necessary to produce this motion are determined.See also

*constraint*,*degree of freedom (DoF)*,*inertia tensor*,*kinematics*,*mass*, and*topology*.**equivalent ellipsoid**The

*equivalent ellipsoid*of a body is the homogeneous solid ellipsoid, centered at the body's center of gravity, with the same principal moments of inertia and principal axes as the body. A homogeneous solid ellipsoid is the simplest body with three distinct principal moments.Every body has a unique equivalent ellipsoid, but a given homogeneous ellipsoid corresponds to an infinite number of other, more complicated, bodies. The rotational dynamics of a body depend only on its equivalent ellipsoid (which determines its principal moments and principal axes), not on its detailed shape.

The equivalent ellipsoid is an option for visualizing a Simscape Multibody body.

See also

*body*,*convex hull*,*dynamics*,*inertia tensor*,*principal axes*,*principal inertial moments*, and*STL*.**Euler angles***Euler angles*mathematically represents a three-dimensional spherical rotation as a product of three successive independent rotations about three independent axes by three independent (Euler) angles. Follow the Euler angle convention byRotating about one axis (which rotates the other two).

Then rotating about a second axis (rotated from its original direction) not identical to the first.

Lastly, rotating about another axis not identical to the second.

There are 3*2*2 = 12 possible Euler angle rotation sequences.

See also

*axis-angle rotation*,*degree of freedom (DoF)*,*primitive joint*,*quaternion*,*right-hand rule*, and*rotation matrix*.**fixed part**A

*fixed part*of a computer-aided design assembly or subassembly is a part that is welded to the assembly or subassembly root. A fixed part cannot move relative to the root.See also

*computer-aided design (CAD)*,*root body*,*subassembly*, and*subassembly root*.**follower (follower body)**The

*follower body*is the body to which a joint is directed. The joint directionality runs from base to follower body.Joint directionality sets the direction and the positive sign of all joint motion and force-torque data.

See also

*base (base body),**body, directionality,*and*right-hand rule.***fundamental root**The

*fundamental root*is a point in a computer-aided assembly that does not move, usually coincident with the assembly origin. All translational and rotational motion of parts in the assembly reference this unmoving point.The computer-aided assembly origin is recreated as the World coordinate system origin in a CAD-generated model.

See also

*assembly*,*computer-aided design (CAD)*,*ground*,*part*,*root body*, and*World*.**ground**A

*ground*or*ground point*is a point fixed at rest in the absolute or global inertial World reference frame.Each ground has an associated grounded coordinate system (CS). The grounded CS's origin is identical to the ground point.

See also

*body*,*coordinate system (CS)*,*grounded CS*,*machine*, and*World*.**grounded CS**A

*grounded CS*is a local CS attached to a ground point. It is at rest in World, but its origin is wherever the ground point is and in general shifted with respect to the World CS origin. The coordinate axes of a grounded CS are always parallel to the World CS axes.The World coordinate axes are defined so that:

+

*x*points right+

*y*points up (gravity in -*y*direction)+

*z*points out of the screen, in three dimensionsYou automatically create a Grounded CS whenever you set up a Ground block.

See also

*adjoining CS*,*body*,*Body CS*,*coordinate system (CS)*,*ground*,*local CS*, and*World*.**home configuration**The bodies of a machine are in their

*home configuration*when they are positioned and oriented purely according to the positions and orientations entered into the Body dialogs. This configuration assumes zero body velocities.See also

*assembled configuration*and*initial configuration*.**inertia tensor**The

*inertia*or*moment of inertia tensor*of an extended rigid body describes its internal mass distribution and the body's angular acceleration in response to an applied torque.Let

*V*be the body's volume and ρ() its mass density, a function of vector position*r*within the body. Then the components of the inertia tensor*r*are:*I*$${I}_{ij}={\displaystyle \underset{V}{\int}dV\left[{\delta}_{ij}{\left|r\right|}^{2}-{r}_{i}{r}_{j}\right]}\rho \left(r\right)$$

The indices

*i*,*j*range over 1, 2, 3, or*x*,*y*,*z*. This tensor is a real, symmetric 3-by-3 matrix or equivalent MATLAB^{®}expression.The inertia tensor of a Simscape Multibody body is always evaluated in that body's center of gravity coordinate system (CG CS). That is, the origin is set to the body's CG and the coordinate axes are the CG CS axes.

Because the CG CS of a Body block is fixed rigidly in the body during simulation, the values of the inertia tensor components do not change as the body rotates.

See also

*body,**Body CS,**equivalent ellipsoid*,*mass, principal axes,*and*principal inertial moments*.**initial condition actuator**An

*initial condition actuator*sets a system's degrees of freedom nondynamically to prepare a system for dynamical integration, in a way consistent with all constraints.The initial conditions are applied to a Simscape Multibody joint primitive.

See also

*actuator,**dynamics,*and*kinematics.***initial configuration**A machine is in its

*initial configuration*once all initial condition actuators have been applied to its joints. This step can change the positions and orientations of the machine's bodies, as well as apply nonzero initial velocities.See also

*assembled configuration*,*home configuration*, and*initial condition actuator*.**joint**A

*joint*is a machine component that represents one or more mechanical degrees of freedom between two bodies. Joint blocks connect two Body blocks in a Simscape Multibody schematic. A Joint has no mass properties such as a mass or an inertia tensor, and the reaction force and torque are equal and opposite on its two connected Bodies.A

*joint primitive*represents one translational or rotational degree of freedom or one spherical (three rotational degrees of freedom in angle-axis form). Prismatic and revolute primitives have motion axis vectors. A weld primitive has no degrees of freedom.A

*primitive joint*contains one joint primitive. A*composite joint*contains more than one joint primitive.Joints have a directionality set by their base-to-follower Body order and the direction of the joint primitive axis. The sign of all motion and force-torque data is determined by this directionality.

See also

*actuator*,*assembled joint*,*base (base body)*,*body*,*composite joint*,*constrained joint*,*constraint*,*degree of freedom (DoF)*,*directionality,**disassembled joint*,*follower (follower body)*,*ground*,*inertia tensor**, massless connector*,*primitive joint*, and*sensor.***kinematics**A

*kinematic*analysis of a mechanical system specifies topology, degrees of freedom (DoFs), motions, and constraints, without specification of applied forces/torques or the mass properties of the bodies.The

*machine state*at some time is the set of allInstantaneous positions and orientations

Instantaneous velocities

of all bodies in the system, for both linear (translational) and angular (rotational) DoFs of the bodies.

Specification of applied forces/torques and solution of the system's motion as a function of time are given by the system's dynamics.

See also

*constraint*,*degree of freedom (DoF)*,*dynamics*, and*topology*.**local CS**A

*local coordinate system (CS)*is attached to either a Ground or a Body:A

*Grounded CS*is automatically defined when you represent a ground point by a Ground block and is always at rest in the World reference frame. The origin of this Grounded CS is the same point as the ground point and not in general the same as the World CS origin.You define one or more

*Body CSs*when you configure the properties of a Body. A Body CS is fixed rigidly in the body and carried along with that body's motion.To indicate an attached coordinate system, a Body block has an axis triad CS port in place of the open, round connector port .

See also

*body*,*Body CS*,*coordinate system (CS)*,*grounded CS*,*reference frame (RF)*, and*World*.**machine**In a Simscape Multibody model, a

*machine*is a complete, connected block diagram representing one mechanical system. It is topologically isolated from any other machine in your model and has at least one ground and exactly one Machine Environment block.A Simscape Multibody model has one or more machines.

**machine precision constraint**A

*machine precision constraint*implements motion restrictions on constrained degrees of freedom to the precision of your computer processor's arithmetic. It is the most robust, computationally intensive, and slowest-simulating constraint.The precision to which the constraint is maintained depends on scale or the physical system of units.

See also

*constraint, stabilizing constraint,*and*tolerancing constraint.***mass**The

*mass*is the proportionality between a force on a body and the resulting translational acceleration of that body.Let

*V*be the body's volume and ρ() its mass density, a function of position*r*within the body. Then the mass*r**m*is:$$m={\displaystyle \underset{V}{\int}dV}\rho \left(r\right)$$

The mass is a real, positive scalar or equivalent MATLAB expression.

A body's mass is insensitive to choice of reference frame, coordinate system origin, or coordinate axes orientation.

See also

*body*and*inertia tensor*.**massless connector**A

*massless connector*is a machine component equivalent to two joints whose respective primitive axes are spatially separated by a fixed distance. You can specify the gap distance and the axis of separation. The space between the degrees of freedom is filled by a rigid connector of zero mass.You cannot actuate or sense a massless connector.

See also

*disassembled joint*and*joint*.**open machine**You can disconnect an

*open machine*diagram into two separate diagrams by cutting no more than one joint.Such machines can be divided into two types:

An

*open chain*is a series of bodies connected by joints and topologically equivalent to a line.An

*open tree*is a series of bodies connected by joints in which at least one body has more than two joints connected to it. Bodies with more than two connected joints define*branch points*in the tree. A tree can be disconnected into multiple chains by cutting the branch points.

The end body of a chain is a body with only one connected joint.

See also

*closed loop machine*and*topology*.**part**A

*part*represents a body in a computer-aided design (CAD) assembly. In CAD representations, a part typically includes full geometric, as well as mass and inertia tensor, information about a body.Body degrees of freedom are restricted in CAD by constraints (sometimes called

*mates*).After translation into a Simscape Multibody model, parts are represented by bodies.

See also

*assembly*,*associativity*,*body*,*computer-aided design (CAD)*,*constraint*,*degree of freedom (DoF)*,*inertia tensor*, and*mass*.**physical tree**You obtain the

*physical tree*representation from a full machine diagram by removing actuators and sensors and cutting each closed loop once. The physical tree retains bodies, joints, constraints, and drivers.See also

*closed loop machine, open machine, spanning tree,*and*topology.***primitive joint**A

*primitive joint*expresses one degree of freedom (DoF) or coordinate of motion, if this DoF is a translation along one direction (*prismatic joint*) or a rotation about one fixed axis (*revolute joint*).A Simscape Multibody

*spherical joint*(three DoFs: two rotations to specify directional axis, one rotation about that axis) is also treated as a primitive joint.These three types of primitive joints are the

*joint primitives*from which composite joints are built.A weld primitive has no degrees of freedom.

See also

*composite joint*and*joint*.**principal axes**The inertia tensor of a body is real and symmetric and thus can be diagonalized, with three real eigenvalues and three orthogonal eigenvectors. The

*principal axes*of a body are these eigenvectors.See also

*equivalent ellipsoid*,*inertia tensor*, and*principal inertia moments*.**principal inertial moments**The inertia tensor of a body is real, symmetric, and diagonalizable, with three real eigenvalues and three orthogonal eigenvectors. The

*principal inertial moments*or*principal moments of inertia*of a body are these eigenvalues, the diagonal values when the tensor is diagonalized.The principal moments of a real body satisfy the

*triangle inequalities:*the sum of any two moments is greater than or equal to the third moment.If two of the three principal moments are equal, the body has some symmetry and is dynamically equivalent to a

*symmetric top*. If all three principal moments are equal, the body is dynamically equivalent to a*sphere*.See also

*equivalent ellipsoid*,*inertia tensor*, and*principal axes*.**quaternion**A

*quaternion*mathematically represents a three-dimensional spherical rotation as a four-component row vector of unit length:$$q=\left[{n}_{x}\mathrm{sin}\left(\theta /2\right),{n}_{y}\mathrm{sin}\left(\theta /2\right),{n}_{z}\mathrm{sin}\left(\theta /2\right),\mathrm{cos}\left(\theta /2\right)\right]=\left[{q}_{\text{v}},{q}_{\text{s}}\right]$$

with

= 1. The vector`q*q`

= (*n**n*_{x},*n*_{y},*n*_{z}) is a three-component vector of unit length:= 1. The unit vector*n·n*specifies the axis of rotation. The rotation angle about that axis is θ and follows the right-hand rule.*n*The axis-angle representation of the rotation is just [

θ ].*n*See also

*axis-angle rotation*,*degree of freedom (DoF)*,*Euler angles*,*primitive joint*,*right-hand rule*, and*rotation matrix*.**reference frame (RF)**A

*reference frame (RF)*is the state of motion of an observer.An

*inertial*RF is a member of a set of all RFs moving uniformly with respect to one another, without relative acceleration. This set defines inertial space.An RF is necessary but not sufficient to define a coordinate system (CS). A CS requires an origin point and an oriented set of three orthogonal axes.

See also

*coordinate system (CS)*,*local CS*, and*World*.**RF****right-hand rule**The

*right-hand rule*is the standard convention for determining the sign of a rotation: point your right thumb into the positive rotation axis and curl your fingers into the forward rotational direction.See also

*degree of freedom (DoF), directionality,*and*joint*.**root body**A

*root body*is a component of a Simscape Multibody model translated from a computer-aided design (CAD) assembly. In the translated model, a block sequence Ground — Root Weld — Root Body or Root Body — Root Weld — Fixed Body represents the CAD assembly's fundamental or subassembly root, respectively.In CAD assemblies, the fundamental or subassembly root represents a fixed point relative to which all part motion or subassembly part motion is measured. The fundamental root is usually the same as the assembly origin.

See also

*assembly*,*body*,*computer-aided design (CAD)*,*fixed part*,*fundamental root*,*ground*,*subassembly*, and*fundamental root*.**rotation matrix**A

*rotation matrix*mathematically represents a three-dimensional spherical rotation as a 3-by-3 real, orthogonal matrix*R*:*R*^{T}*R*=*RR*^{T}=*I*, where*I*is the 3-by-3 identity and*R*^{T}is the transpose of*R*.$$R=\left(\begin{array}{ccc}{R}_{11}& {R}_{12}& {R}_{13}\\ {R}_{21}& {R}_{22}& {R}_{23}\\ {R}_{31}& {R}_{32}& {R}_{33}\end{array}\right)=\left(\begin{array}{ccc}{R}_{\text{xx}}& {R}_{\text{xy}}& {R}_{\text{xz}}\\ {R}_{\text{yx}}& {R}_{\text{yy}}& {R}_{\text{yz}}\\ {R}_{\text{zx}}& {R}_{\text{zy}}& {R}_{\text{zz}}\end{array}\right)$$

In general,

*R*requires three independent angles to specify the rotation fully. There are many ways to represent the three independent angles. Here are two:You can form three independent rotation matrices

*R*_{1},*R*_{2},*R*_{3}, each representing a single independent rotation. Then compose the full rotation matrix*R*with respect to fixed coordinate axes (like World) as a product of these three:*R = R*_{3}**R*_{2}**R*_{1}. The three angles are*Euler angles*.You can represent

*R*in terms of an*axis-angle rotation*= (*n**n*_{x},*n*_{y},*n*_{z}) and θ with= 1. The three independent angles are θ and the two needed to orient*n·n*. Form the antisymmetric matrix:*n*$$J=\left(\begin{array}{ccc}0& -{n}_{z}& {n}_{y}\\ {n}_{z}& 0& -{n}_{x}\\ -{n}_{y}& {n}_{x}& 0\end{array}\right)$$

Then

*Rodrigues' formula*simplifies*R*:$$R=\mathrm{exp}(\theta J)\text{}=\text{}I\text{}+\text{}J\mathrm{sin}\theta \text{}+\text{}{J}^{2}(1-\mathrm{cos}\theta )$$

See also

*axis-angle rotation*,*degree of freedom (DoF)*,*Euler angles*,*primitive joint*,*quaternion*, and*right-hand rule*.**sensor**A

*sensor*is a machine component that measures the motion of, or forces/torques acting on, a body or joint. A sensor can also measure the reaction forces in a constraint or driver constraining a pair of bodies.A Simscape Multibody Sensor block has an open round Simscape Multibody connector port for connecting with a Body or Joint block and an angle bracket > Simulink outport for connecting with normal Simulink blocks, such as a Sinks block like Scope.

See also

*actuator*,*body*,*connector port*,*constraint*,*driver*,*joint*, and*primitive joint*.**spanning tree**You obtain the

*spanning tree*representation from a full machine diagram by removing everything except bodies and joints and cutting each closed loop once.See also

*closed loop machine, open machine, physical tree,*and*topology.***stabilizing constraint**A

*stabilizing constraint*implements motion restrictions on constrained degrees of freedom by modifying the dynamics of a system so that the constraint manifold is attractive, without changing the constrained solution. This constraint solver type is computationally the least intensive, the least robust, and the fastest-simulating.The precision to which the constraint is maintained depends on scale or the physical system of units.

See also

*constraint*,*machine precision constraint*, and*tolerancing constraint*.**stiction actuator**A

*stiction actuator*is a machine component that applies discontinuous friction forces to a joint primitive according to the relative velocity of one body with the other body.If this relative velocity drops below a specified threshold, the relative motion ceases and the bodies or joints become locked rigidly to one another by static friction.

Above that threshold, the bodies or joints move relative to one another with kinetic friction.

See also

*actuator, composite joint, dynamics, joint,*and*primitive joint*.**STL***Stereolithographic*(STL) format is an open file format for specifying the three-dimensional surface geometry or shape of a body. STL format specifies surface geometry by linked triangles whose edges and vertices are oriented by the right-hand rule.Simscape Multibody visualization uses STL format files for custom body geometries and supports both ASCII and binary STL variants.

See also

*body*,*computer-aided design (CAD)*,*convex hull*,*equivalent ellipsoid*,*part*,*right-hand rule*,*VRML*and 3D Systems, creator of STL format, at`www.3dsystems.com`

.**subassembly**A

*subassembly*represents of a subset of machine parts and constraints (mates) in computer-aided design (CAD).A subassembly is attached to its parent CAD assembly at a single branching point.

A subassembly is either

*flexible*or*rigid*. That is, its parts either can move with respect to one another, or they cannot.See also

*assembly*,*computer-aided design (CAD)*,*constraint*,*part*, and*subassembly root*.**subassembly root**A

*subassembly root*is a point in a computer-aided design (CAD) subassembly that does not move relative to the assembly point off of which it branches. All translational and rotational motion of parts in the subassembly reference this unmoving point.See also

*assembly*,*computer-aided design (CAD)*,*fundamental root*,*part*,*root body*, and*subassembly*.**tolerancing constraint**A

*tolerancing constraint*implements motion restrictions on constrained degrees of freedom only up to a specified accuracy and/or precision.This accuracy/precision is independent of any accuracy/precision limits on the solver used to integrate the system's motion, although constraints cannot be maintained to greater accuracy than the accuracy of the solver.

The precision to which the constraint is maintained depends on scale or the physical system of units.

Tolerancing constraints are moderately robust and moderately intensive and execute at moderate speed. They are less intensive than machine precision constraints, but computationally more intensive than stabilizing constraints.

Tolerancing constraints are most useful in realistic simulation of constraint slippage ("slop" or "play").

See also

*constraint*,*machine precision constraint*, and*stabilizing constraint*.**topology**The

*topology*of a machine diagram is the global connectivity of all its elements. A diagram's*elements*are its bodies, and its*connections*are its joints, constraints, and drivers. Two topologies are*equivalent*if you can transform one diagram into another by continuous deformations and without cutting connections or joining elements.An

*open machine*diagram has no closed loops.An

*open chain*is topologically equivalent to a line; and each body is connected to only two other bodies, if the body is internal, or one other body if it is at an end.An

*open tree*has one or more*branch points*. A branch point is where an internal body is connected to more than two joints. A tree can be disconnected into multiple chains by cutting at the branch points.

A

*closed loop machine*diagram has one or more closed loops. The number of closed loops is equal to the minimum number of joints, minus one, that must be cut to dissociate a diagram into two disconnected diagrams.An actual diagram can have one of these primitive topologies or can be built from multiple primitive topologies.

See also

*body*,*closed loop machine,**constraint*,*driver*,*joint,**machine*,*open machine*, and*spanning tree*.**VRML***Virtual Reality Modeling Language (VRML)*is an open, Web-oriented ISO standard for defining three-dimensional virtual worlds and bodies in multimedia and the Internet.In VRML, body rotations are represented in the axis-angle form. The Simscape Multibody RotationMatrix2VR block converts rotation matrices to the equivalent axis-angle forms.

See also

*axis-angle rotation*,*STL*, and the Web3D Consortium at`www.web3d.org`

.**World**In the Simscape Multibody environment,

*World*is a kinematic and geometric construct defining both the absolute inertial*reference frame (RF)*and absolute*coordinate system (CS)*in that RF. World has a fixed origin and fixed coordinate axes that cannot be changed.The World coordinate axes are defined so that:

+

*x*points right+

*y*points up (gravity in -*y*direction)+

*z*points out of the screen, in three dimensionsThe assembly origin of a CAD assembly translated into a model becomes the World CS origin.

See also

*adjoining CS*,*computer-aided design (CAD)*,*coordinate system (CS), fundamental root, ground, grounded CS,*and*reference frame (RF).*

Was this topic helpful?