Rigid components such as bodies with mass and inertia and massless rods

Package **Parts** contains **rigid components** of a
multi-body system. These components may be used to build up
more complicated structures. For example, a part may be built up of
a "Body" and of several "FixedTranslation" components.

Model | Description |
---|---|

Fixed | Frame fixed in world frame at a given position.
It is visualized with a shape, see shapeType below
(the frames on the two
sides do not belong to the component): |

FixedTranslation | Fixed translation of frame_b with respect to frame_a.
It is visualized with a shape, see shapeType below
(the frames on the two sides do not belong to the component): |

FixedRotation | Fixed translation and fixed rotation of frame_b with respect to frame_a
It is visualized with a shape, see shapeType below
(the frames on the two sides do not belong to the component): |

Body | Rigid body with mass, inertia tensor and one frame connector.
It is visualized with a cylinder and a sphere at the
center of mass: |

BodyShape | Rigid body with mass, inertia tensor, different shapes
(see shapeType below)
for animation, and two frame connectors: |

Fixed BodyBox | Rigid body with box shape (mass and animation properties are computed
from box data and from density): |

BodyCylinder | Rigid body with cylinder shape (mass and animation properties
are computed from cylinder data and from density): |

PointMass | Rigid body where inertia tensor and rotation is neglected: |

Mounting1D | Propagate 1-dim. support torque to 3-dim. system |

Rotor1D | 1D inertia attachable on 3-dim. bodies (without neglecting dynamic effects) |

BevelGear1D | 1D gearbox with arbitrary shaft directions (3D bearing frame) |

Components **Fixed**, **FixedTranslation**, **FixedRotation**
and **BodyShape** are visualized according to parameter
**shapeType**, that may have the following values (e.g., shapeType = "box"):

All the details of the visualization shape parameters are given in Visualizers.FixedShape

Colors in all animation parts are defined via parameter **color**.
This is an Integer vector with 3 elements, {r, g, b}, and specifies the
color of the shape. {r,g,b} are the "red", "green" and "blue" color parts,
given in the ranges 0 .. 255, respectively. The predefined type
**MultiBody.Types.Color** contains a menu
definition of the colors used in the MultiBody library
(this will be replaced by a color editor).

Extends from `Modelica.Icons.Package`

(Icon for standard packages).

Name | Description |
---|---|

`BevelGear1D` | 1D gearbox with arbitrary shaft directions and 3-dim. bearing frame (3D dynamic effects are taken into account provided world.driveTrainMechanics3D=true) |

`Body` | Rigid body with mass, inertia tensor and one frame connector (12 potential states) |

`BodyBox` | Rigid body with box shape. Mass and animation properties are computed from box data and density (12 potential states) |

`BodyCylinder` | Rigid body with cylinder shape. Mass and animation properties are computed from cylinder data and density (12 potential states) |

`BodyShape` | Rigid body with mass, inertia tensor, different shapes for animation, and two frame connectors (12 potential states) |

`Fixed` | Frame fixed in the world frame at a given position |

`FixedRotation` | Fixed translation followed by a fixed rotation of frame_b with respect to frame_a |

`FixedTranslation` | Fixed translation of frame_b with respect to frame_a |

`Mounting1D` | Propagate 1-dim. support torque to 3-dim. system (provided world.driveTrainMechanics3D=true) |

`PointMass` | Rigid body where body rotation and inertia tensor is neglected (6 potential states) |

`RollingWheel` | Ideal rolling wheel on flat surface z=0 (5 positional, 3 velocity degrees of freedom) |

`RollingWheelSet` | Ideal rolling wheel set consisting of two ideal rolling wheels connected together by an axis |

`Rotor1D` | 1D inertia attachable on 3-dim. bodies (3D dynamic effects are taken into account if world.driveTrainMechanics3D=true) |

Frame fixed in the world frame at a given position

Element consisting of a frame (frame_b) that is fixed in the world
frame at a given position defined by parameter vector **r**
(vector from origin of world frame to frame_b, resolved in the
world frame).

By default, this component is visualized by a cylinder connecting the
world frame and frame_b of this components, as shown in the figure below.
Note, that the visualized world frame on the left side and
Fixed.frame_b on the right side are not part of the
component animation and that the animation may be switched off via parameter
animation = **false**.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled |

`Position` | `r[3]` | `{0, 0, 0}` | Position vector from world frame to frame_b, resolved in world frame |

`ShapeType` | `shapeType` | `"cylinder"` | Type of shape |

`Position` | `r_shape[3]` | `{0, 0, 0}` | Vector from world frame to shape origin, resolved in world frame |

`Axis` | `lengthDirection[3]` | `to_unit1(r - r_shape)` | Vector in length direction of shape, resolved in world frame |

`Axis` | `widthDirection[3]` | `{0, 1, 0}` | Vector in width direction of shape, resolved in world frame |

`Length` | `length` | `Modelica.Math.Vectors.length(r - r_shape)` | Length of shape |

`Distance` | `width` | `length / world.defaultWidthFraction` | Width of shape |

`Distance` | `height` | `width` | Height of shape |

`ShapeExtra` | `extra` | `0` | Additional parameter for cone, pipe etc. (see docu of Visualizers.Advanced.Shape) |

Type | Name | Description |
---|---|---|

`Frame_b` | `frame_b` | Coordinate system fixed in the world frame |

Fixed translation of frame_b with respect to frame_a

Component for a **fixed translation** of frame_b with respect
to frame_a, i.e., the relationship between connectors frame_a and frame_b
remains constant and frame_a is always **parallel** to frame_b.

By default, this component is visualized by a cylinder connecting
frame_a and frame_b, as shown in the figure below. Note, that the
two visualized frames are not part of the component animation and that
the animation may be switched off via parameter animation = **false**.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled |

`Position` | `r[3]` | Vector from frame_a to frame_b resolved in frame_a | |

`ShapeType` | `shapeType` | `"cylinder"` | Type of shape |

`Position` | `r_shape[3]` | `{0, 0, 0}` | Vector from frame_a to shape origin, resolved in frame_a |

`Axis` | `lengthDirection[3]` | `to_unit1(r - r_shape)` | Vector in length direction of shape, resolved in frame_a |

`Axis` | `widthDirection[3]` | `{0, 1, 0}` | Vector in width direction of shape, resolved in frame_a |

`Length` | `length` | `Modelica.Math.Vectors.length(r - r_shape)` | Length of shape |

`Distance` | `width` | `length / world.defaultWidthFraction` | Width of shape |

`Distance` | `height` | `width` | Height of shape |

`ShapeExtra` | `extra` | `0` | Additional parameter depending on shapeType (see docu of Visualizers.Advanced.Shape) |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed to the component with one cut-force and cut-torque |

`Frame_b` | `frame_b` | Coordinate system fixed to the component with one cut-force and cut-torque |

Fixed translation followed by a fixed rotation of frame_b with respect to frame_a

Component for a **fixed translation** and **fixed rotation** of frame_b with respect
to frame_a, i.e., the relationship between connectors frame_a and frame_b
remains constant. There are several possibilities to define the
orientation of frame_b with respect to frame_a:

**Planar rotation**along axis 'n' (that is fixed and resolved in frame_a) with a fixed angle 'angle'.**Vectors n_x**and**n_y**that are directed along the corresponding axes direction of frame_b and are resolved in frame_a (if n_y is not orthogonal to n_x, the y-axis of frame_b is selected such that it is orthogonal to n_x and in the plane of n_x and n_y).**Sequence**of**three planar axes rotations**. For example, "sequence = {1,2,3}" and "angles = {90, 45, -90}" means to rotate frame_a around the x axis with 90 degrees, around the new y axis with 45 degrees and around the new z axis around -90 degrees to arrive at frame_b. Note, that sequence={1,2,3} is the Cardan angle sequence and sequence = {3,1,3} is the Euler angle sequence.

By default, this component is visualized by a cylinder connecting
frame_a and frame_b, as shown in the figure below. In this figure
frame_b is rotated along the z-axis of frame_a with 60 degree. Note, that the
two visualized frames are not part of the component animation and that
the animation may be switched off via parameter animation = **false**.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled |

`Position` | `r[3]` | `{0, 0, 0}` | Vector from frame_a to frame_b resolved in frame_a |

`RotationTypes` | `rotationType` | `Modelica.Mechanics.MultiBody.Types.RotationTypes.RotationAxis` | Type of rotation description |

`Axis` | `n[3]` | `{1, 0, 0}` | Axis of rotation in frame_a (= same as in frame_b) |

`Angle_deg` | `angle` | `0` | Angle to rotate frame_a around axis n into frame_b |

`Axis` | `n_x[3]` | `{1, 0, 0}` | Vector along x-axis of frame_b resolved in frame_a |

`Axis` | `n_y[3]` | `{0, 1, 0}` | Vector along y-axis of frame_b resolved in frame_a |

`RotationSequence` | `sequence[3]` | `{1, 2, 3}` | Sequence of rotations |

`Angle_deg` | `angles[3]` | `{0, 0, 0}` | Rotation angles around the axes defined in 'sequence' |

`ShapeType` | `shapeType` | `"cylinder"` | Type of shape |

`Position` | `r_shape[3]` | `{0, 0, 0}` | Vector from frame_a to shape origin, resolved in frame_a |

`Axis` | `lengthDirection[3]` | `to_unit1(r - r_shape)` | Vector in length direction of shape, resolved in frame_a |

`Axis` | `widthDirection[3]` | `{0, 1, 0}` | Vector in width direction of shape, resolved in frame_a |

`Length` | `length` | `Modelica.Math.Vectors.length(r - r_shape)` | Length of shape |

`Distance` | `width` | `length / world.defaultWidthFraction` | Width of shape |

`Distance` | `height` | `width` | Height of shape |

`ShapeExtra` | `extra` | `0` | Additional parameter depending on shapeType (see docu of Visualizers.Advanced.Shape) |

`Orientation` | `R_rel` | `if rotationType == Types.RotationTypes.RotationAxis then Frames.planarRotation(Modelica.Math.Vectors.normalizeWithAssert(n), Cv.from_deg(angle), 0) else if rotationType == Types.RotationTypes.TwoAxesVectors then Frames.from_nxy(n_x, n_y) else Frames.axesRotations(sequence, Cv.from_deg(angles), zeros(3))` | Fixed rotation object from frame_a to frame_b |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed to the component with one cut-force and cut-torque |

`Frame_b` | `frame_b` | Coordinate system fixed to the component with one cut-force and cut-torque |

Rigid body with mass, inertia tensor and one frame connector (12 potential states)

**Rigid body** with mass and inertia tensor.
All parameter vectors have to be resolved in frame_a.
The **inertia tensor** has to be defined with respect to a
coordinate system that is parallel to frame_a with the
origin at the center of mass of the body.

By default, this component is visualized by a **cylinder** located
between frame_a and the center of mass and by a **sphere** that has
its center at the center of mass. If the cylinder length is smaller as
the radius of the sphere, e.g., since frame_a is located at the
center of mass, the cylinder is not displayed. Note, that
the animation may be switched off via parameter animation = **false**.

**States of Body Components**

Every body has potential states. If possible a tool will select the states of joints and not the states of bodies because this is usually the most efficient choice. In this case the position, orientation, velocity and angular velocity of frame_a of the body will be computed by the component that is connected to frame_a. However, if a body is moving freely in space, variables of the body have to be used as states. The potential states of the body are:

- The
**position vector**frame_a.r_0 from the origin of the world frame to the origin of frame_a of the body, resolved in the world frame and the**absolute velocity**v_0 of the origin of frame_a, resolved in the world frame (= der(frame_a.r_0)). - If parameter
**useQuaternions**in the "Advanced" menu is**true**(this is the default), then**4 quaternions**are potential states. Additionally, the coordinates of the absolute angular velocity vector of the body are 3 potential states.

If**useQuaternions**in the "Advanced" menu is**false**, then**3 angles**and the derivatives of these angles are potential states. The orientation of frame_a is computed by rotating the world frame along the axes defined in parameter vector "sequence_angleStates" (default = {1,2,3}, i.e., the Cardan angle sequence) around the angles used as potential states. For example, the default is to rotate the x-axis of the world frame around angles[1], the new y-axis around angles[2] and the new z-axis around angles[3], arriving at frame_a.

The quaternions have the slight disadvantage that there is a
non-linear constraint equation between the 4 quaternions.
Therefore, at least one non-linear equation has to be solved
during simulation. A tool might, however, analytically solve this
simple constraint equation. Using the 3 angles as states has the
disadvantage that there is a singular configuration in which a
division by zero will occur. If it is possible to determine in advance
for an application class that this singular configuration is outside
of the operating region, the 3 angles might be used as potential
states by setting **useQuaternions** = **false**.

In text books about 3-dimensional mechanics often 3 angles and the angular velocity are used as states. This is not the case here, since 3 angles and their derivatives are used as potential states (if useQuaternions = false). The reason is that for real-time simulation the discretization formula of the integrator might be "inlined" and solved together with the body equations. By appropriate symbolic transformation the performance is drastically increased if angles and their derivatives are used as states, instead of angles and the angular velocity.

Whether or not variables of the body are used as states is usually
automatically selected by the Modelica translator. If parameter
**enforceStates** is set to **true** in the "Advanced" menu,
then body variables are forced to be used as states according
to the setting of parameters "useQuaternions" and
"sequence_angleStates".

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled (show cylinder and sphere) |

`Position` | `r_CM[3]` | Vector from frame_a to center of mass, resolved in frame_a | |

`Mass` | `m` | Mass of rigid body | |

`Inertia` | `I_11` | `0.001` | (1,1) element of inertia tensor |

`Inertia` | `I_22` | `0.001` | (2,2) element of inertia tensor |

`Inertia` | `I_33` | `0.001` | (3,3) element of inertia tensor |

`Inertia` | `I_21` | `0` | (2,1) element of inertia tensor |

`Inertia` | `I_31` | `0` | (3,1) element of inertia tensor |

`Inertia` | `I_32` | `0` | (3,2) element of inertia tensor |

`Boolean` | `angles_fixed` | `false` | = true, if angles_start are used as initial values, else as guess values |

`Angle` | `angles_start[3]` | `{0, 0, 0}` | Initial values of angles to rotate frame_a around 'sequence_start' axes into frame_b |

`RotationSequence` | `sequence_start[3]` | `{1, 2, 3}` | Sequence of rotations to rotate frame_a into frame_b at initial time |

`Boolean` | `w_0_fixed` | `false` | = true, if w_0_start are used as initial values, else as guess values |

`AngularVelocity` | `w_0_start[3]` | `{0, 0, 0}` | Initial or guess values of angular velocity of frame_a resolved in world frame |

`Boolean` | `z_0_fixed` | `false` | = true, if z_0_start are used as initial values, else as guess values |

`AngularAcceleration` | `z_0_start[3]` | `{0, 0, 0}` | Initial values of angular acceleration z_0 = der(w_0) |

`Diameter` | `sphereDiameter` | `world.defaultBodyDiameter` | Diameter of sphere |

`Diameter` | `cylinderDiameter` | `sphereDiameter / Types.Defaults.BodyCylinderDiameterFraction` | Diameter of cylinder |

`Boolean` | `enforceStates` | `false` | = true, if absolute variables of body object shall be used as states (StateSelect.always) |

`Boolean` | `useQuaternions` | `true` | = true, if quaternions shall be used as potential states otherwise use 3 angles as potential states |

`RotationSequence` | `sequence_angleStates[3]` | `{1, 2, 3}` | Sequence of rotations to rotate world frame into frame_a around the 3 angles used as potential states |

`Inertia` | `I[3,3]` | `[I_11,I_21,I_31; I_21,I_22,I_32; I_31,I_32,I_33]` | inertia tensor |

`Orientation` | `R_start` | `Modelica.Mechanics.MultiBody.Frames.axesRotations(sequence_start, angles_start, zeros(3))` | Orientation object from world frame to frame_a at initial time |

`AngularAcceleration` | `z_a_start[3]` | `Frames.resolve2(R_start, z_0_start)` | Initial values of angular acceleration z_a = der(w_a), i.e., time derivative of angular velocity resolved in frame_a |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed at body |

Rigid body with mass, inertia tensor, different shapes for animation, and two frame connectors (12 potential states)

**Rigid body** with mass and inertia tensor and **two frame connectors**.
All parameter vectors have to be resolved in frame_a.
The **inertia tensor** has to be defined with respect to a
coordinate system that is parallel to frame_a with the
origin at the center of mass of the body. The coordinate system **frame_b**
is always parallel to **frame_a**.

By default, this component is visualized by any **shape** that can be
defined with Modelica.Mechanics.MultiBody.Visualizers.FixedShape. This shape is placed
between frame_a and frame_b (default: length(shape) = Frames.length(r)).
Additionally a **sphere** may be visualized that has
its center at the center of mass.
Note, that
the animation may be switched off via parameter animation = **false**.

The following shapes can be defined via parameter **shapeType**,
e.g., shapeType="cone":

A BodyShape component has potential states. For details of these states and of the "Advanced" menu parameters, see model MultiBody.Parts.Body.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled (show shape between frame_a and frame_b and optionally a sphere at the center of mass) |

`Boolean` | `animateSphere` | `true` | = true, if mass shall be animated as sphere provided animation=true |

`Position` | `r[3]` | Vector from frame_a to frame_b resolved in frame_a | |

`Position` | `r_CM[3]` | Vector from frame_a to center of mass, resolved in frame_a | |

`Mass` | `m` | Mass of rigid body | |

`Inertia` | `I_11` | `0.001` | (1,1) element of inertia tensor |

`Inertia` | `I_22` | `0.001` | (2,2) element of inertia tensor |

`Inertia` | `I_33` | `0.001` | (3,3) element of inertia tensor |

`Inertia` | `I_21` | `0` | (2,1) element of inertia tensor |

`Inertia` | `I_31` | `0` | (3,1) element of inertia tensor |

`Inertia` | `I_32` | `0` | (3,2) element of inertia tensor |

`Boolean` | `angles_fixed` | `false` | = true, if angles_start are used as initial values, else as guess values |

`Angle` | `angles_start[3]` | `{0, 0, 0}` | Initial values of angles to rotate frame_a around 'sequence_start' axes into frame_b |

`RotationSequence` | `sequence_start[3]` | `{1, 2, 3}` | Sequence of rotations to rotate frame_a into frame_b at initial time |

`Boolean` | `w_0_fixed` | `false` | = true, if w_0_start are used as initial values, else as guess values |

`AngularVelocity` | `w_0_start[3]` | `{0, 0, 0}` | Initial or guess values of angular velocity of frame_a resolved in world frame |

`Boolean` | `z_0_fixed` | `false` | = true, if z_0_start are used as initial values, else as guess values |

`AngularAcceleration` | `z_0_start[3]` | `{0, 0, 0}` | Initial values of angular acceleration z_0 = der(w_0) |

`ShapeType` | `shapeType` | `"cylinder"` | Type of shape |

`Position` | `r_shape[3]` | `{0, 0, 0}` | Vector from frame_a to shape origin, resolved in frame_a |

`Axis` | `lengthDirection[3]` | `to_unit1(r - r_shape)` | Vector in length direction of shape, resolved in frame_a |

`Axis` | `widthDirection[3]` | `{0, 1, 0}` | Vector in width direction of shape, resolved in frame_a |

`Length` | `length` | `Modelica.Math.Vectors.length(r - r_shape)` | Length of shape |

`Distance` | `width` | `length / world.defaultWidthFraction` | Width of shape |

`Distance` | `height` | `width` | Height of shape |

`ShapeExtra` | `extra` | `0` | Additional parameter depending on shapeType (see docu of Visualizers.Advanced.Shape) |

`Diameter` | `sphereDiameter` | `2 * width` | Diameter of sphere |

`Boolean` | `enforceStates` | `false` | = true, if absolute variables of body object shall be used as states (StateSelect.always) |

`Boolean` | `useQuaternions` | `true` | = true, if quaternions shall be used as potential states otherwise use 3 angles as potential states |

`RotationSequence` | `sequence_angleStates[3]` | `{1, 2, 3}` | Sequence of rotations to rotate world frame into frame_a around the 3 angles used as potential states |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed to the component with one cut-force and cut-torque |

`Frame_b` | `frame_b` | Coordinate system fixed to the component with one cut-force and cut-torque |

Rigid body with box shape. Mass and animation properties are computed from box data and density (12 potential states)

**Rigid body** with **box** shape.
The mass properties of the body (mass, center of mass,
inertia tensor) are computed
from the box data. Optionally, the box may be hollow.
The (outer) box shape is by default used in the animation.
The hollow part is not shown in the animation.
The two connector frames **frame_a** and **frame_b**
are always parallel to each other. Example of component
animation (note, that
the animation may be switched off via parameter animation = **false**):

A BodyBox component has potential states. For details of these states and of the "Advanced" menu parameters, see model MultiBody.Parts.Body.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled (show box between frame_a and frame_b) |

`Position` | `r[3]` | Vector from frame_a to frame_b resolved in frame_a | |

`Position` | `r_shape[3]` | `{0, 0, 0}` | Vector from frame_a to box origin, resolved in frame_a |

`Axis` | `lengthDirection[3]` | `to_unit1(r - r_shape)` | Vector in length direction of box, resolved in frame_a |

`Axis` | `widthDirection[3]` | `{0, 1, 0}` | Vector in width direction of box, resolved in frame_a |

`Length` | `length` | `Modelica.Math.Vectors.length(r - r_shape)` | Length of box |

`Distance` | `width` | `length / world.defaultWidthFraction` | Width of box |

`Distance` | `height` | `width` | Height of box |

`Distance` | `innerWidth` | `0` | Width of inner box surface (0 <= innerWidth <= width) |

`Distance` | `innerHeight` | `innerWidth` | Height of inner box surface (0 <= innerHeight <= height) |

`Density` | `density` | `7700` | Density of cylinder (e.g., steel: 7700 .. 7900, wood : 400 .. 800) |

`Boolean` | `angles_fixed` | `false` | = true, if angles_start are used as initial values, else as guess values |

`Angle` | `angles_start[3]` | `{0, 0, 0}` | Initial values of angles to rotate frame_a around 'sequence_start' axes into frame_b |

`RotationSequence` | `sequence_start[3]` | `{1, 2, 3}` | Sequence of rotations to rotate frame_a into frame_b at initial time |

`Boolean` | `w_0_fixed` | `false` | = true, if w_0_start are used as initial values, else as guess values |

`AngularVelocity` | `w_0_start[3]` | `{0, 0, 0}` | Initial or guess values of angular velocity of frame_a resolved in world frame |

`Boolean` | `z_0_fixed` | `false` | = true, if z_0_start are used as initial values, else as guess values |

`AngularAcceleration` | `z_0_start[3]` | `{0, 0, 0}` | Initial values of angular acceleration z_0 = der(w_0) |

`Boolean` | `enforceStates` | `false` | = true, if absolute variables of body object shall be used as states (StateSelect.always) |

`Boolean` | `useQuaternions` | `true` | = true, if quaternions shall be used as potential states otherwise use 3 angles as potential states |

`RotationSequence` | `sequence_angleStates[3]` | `{1, 2, 3}` | Sequence of rotations to rotate world frame into frame_a around the 3 angles used as potential states |

`Mass` | `mo` | `density * length * width * height` | Mass of box without hole |

`Mass` | `mi` | `density * length * innerWidth * innerHeight` | Mass of hole of box |

`Mass` | `m` | `mo - mi` | Mass of box |

`Orientation` | `R` | `Frames.from_nxy(r, widthDirection)` | Orientation object from frame_a to coordinates system spanned by r and widthDirection |

`Position` | `r_CM[3]` | `r_shape + 0.5 * (normalizeWithAssert(lengthDirection) * length)` | Position vector from origin of frame_a to center of mass, resolved in frame_a |

`Inertia` | `I[3,3]` | `Frames.resolveDyade1(R, diagonal(0.083333333333333 * {mo * (width * width + height * height) - mi * (innerWidth * innerWidth + innerHeight * innerHeight), mo * (length * length + height * height) - mi * (length * length + innerHeight * innerHeight), mo * (length * length + width * width) - mi * (length * length + innerWidth * innerWidth)}))` | Inertia tensor of body box with respect to center of mass, parallel to frame_a |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed to the component with one cut-force and cut-torque |

`Frame_b` | `frame_b` | Coordinate system fixed to the component with one cut-force and cut-torque |

Rigid body with cylinder shape. Mass and animation properties are computed from cylinder data and density (12 potential states)

**Rigid body** with **cylinder** shape.
The mass properties of the body (mass, center of mass,
inertia tensor) are computed
from the cylinder data. Optionally, the cylinder may be hollow.
The cylinder shape is by default used in the animation.
The two connector frames **frame_a** and **frame_b**
are always parallel to each other. Example of component
animation (note, that
the animation may be switched off via parameter animation = **false**):

A BodyCylinder component has potential states. For details of these states and of the "Advanced" menu parameters, see model MultiBody.Parts.Body.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled (show cylinder between frame_a and frame_b) |

`Position` | `r[3]` | Vector from frame_a to frame_b, resolved in frame_a | |

`Position` | `r_shape[3]` | `{0, 0, 0}` | Vector from frame_a to cylinder origin, resolved in frame_a |

`Axis` | `lengthDirection[3]` | `to_unit1(r - r_shape)` | Vector in length direction of cylinder, resolved in frame_a |

`Length` | `length` | `Modelica.Math.Vectors.length(r - r_shape)` | Length of cylinder |

`Distance` | `diameter` | `length / world.defaultWidthFraction` | Diameter of cylinder |

`Distance` | `innerDiameter` | `0` | Inner diameter of cylinder (0 <= innerDiameter <= Diameter) |

`Density` | `density` | `7700` | Density of cylinder (e.g., steel: 7700 .. 7900, wood : 400 .. 800) |

`Boolean` | `angles_fixed` | `false` | = true, if angles_start are used as initial values, else as guess values |

`Angle` | `angles_start[3]` | `{0, 0, 0}` | Initial values of angles to rotate frame_a around 'sequence_start' axes into frame_b |

`RotationSequence` | `sequence_start[3]` | `{1, 2, 3}` | Sequence of rotations to rotate frame_a into frame_b at initial time |

`Boolean` | `w_0_fixed` | `false` | = true, if w_0_start are used as initial values, else as guess values |

`AngularVelocity` | `w_0_start[3]` | `{0, 0, 0}` | Initial or guess values of angular velocity of frame_a resolved in world frame |

`Boolean` | `z_0_fixed` | `false` | = true, if z_0_start are used as initial values, else as guess values |

`AngularAcceleration` | `z_0_start[3]` | `{0, 0, 0}` | Initial values of angular acceleration z_0 = der(w_0) |

`Boolean` | `enforceStates` | `false` | = true, if absolute variables of body object shall be used as states (StateSelect.always) |

`Boolean` | `useQuaternions` | `true` | = true, if quaternions shall be used as potential states otherwise use 3 angles as potential states |

`RotationSequence` | `sequence_angleStates[3]` | `{1, 2, 3}` | |

`Distance` | `radius` | `0.5 * diameter` | Radius of cylinder |

`Distance` | `innerRadius` | `0.5 * innerDiameter` | Inner-Radius of cylinder |

`Mass` | `mo` | `density * pi * length * radius * radius` | Mass of cylinder without hole |

`Mass` | `mi` | `density * pi * length * innerRadius * innerRadius` | Mass of hole of cylinder |

`Inertia` | `I22` | `0.083333333333333 * (mo * (length * length + 3 * radius * radius) - mi * (length * length + 3 * innerRadius * innerRadius))` | Inertia with respect to axis through center of mass, perpendicular to cylinder axis |

`Mass` | `m` | `mo - mi` | Mass of cylinder |

`Orientation` | `R` | `Frames.from_nxy(r, {0, 1, 0})` | Orientation object from frame_a to frame spanned by cylinder axis and axis perpendicular to cylinder axis |

`Position` | `r_CM[3]` | `r_shape + 0.5 * (normalizeWithAssert(lengthDirection) * length)` | Position vector from frame_a to center of mass, resolved in frame_a |

`Inertia` | `I[3,3]` | `Frames.resolveDyade1(R, diagonal({0.5 * (mo * radius * radius - mi * innerRadius * innerRadius), I22, I22}))` | Inertia tensor of cylinder with respect to center of mass, resolved in frame parallel to frame_a |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed to the component with one cut-force and cut-torque |

`Frame_b` | `frame_b` | Coordinate system fixed to the component with one cut-force and cut-torque |

Rigid body where body rotation and inertia tensor is neglected (6 potential states)

**Rigid body** where the inertia tensor is neglected.
This body is
solely defined by its mass.
By default, this component is visualized by a **sphere** that has
its center at frame_a. Note, that
the animation may be switched off via parameter animation = **false**.

Every PointMass has potential states. If possible a tool will select
the states of joints and not the states of PointMass because this is
usually the most efficient choice. In this case the position and
velocity of frame_a of the body will be computed
by the component that is connected to frame_a. However, if a PointMass is moving
freely in space, variables of the PointMass have to be used as states. The potential
states are: The **position vector** frame_a.r_0 from the origin of the
world frame to the origin of frame_a of the body, resolved in
the world frame and the **absolute velocity** v_0 of the origin of
frame_a, resolved in the world frame (= der(frame_a.r_0)).

Whether or not variables of the body are used as states is usually
automatically selected by the Modelica translator. If parameter
**enforceStates** is set to **true** in the "Advanced" menu,
then PointMass variables frame_a.r_0 and der(frame_a.r_0)
are forced to be used as states.

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled (show sphere) |

`Mass` | `m` | Mass of mass point | |

`StateSelect` | `stateSelect` | `StateSelect.avoid` | Priority to use frame_a.r_0, v_0 (= der(frame_a.r_0)) as states |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Coordinate system fixed at center of mass point |

Propagate 1-dim. support torque to 3-dim. system (provided world.driveTrainMechanics3D=true)

This component is used to acquire support torques from a 1-dim.-rotational mechanical system (e.g., components from Modelica.Mechanics.Rotational) and to propagate them to a carrier body.

The 1-dim. support torque at `flange_b`

is transformed into 3-dim. space under
consideration of the rotation axis, parameter `n`

, which has to be given in the
local coordinate system of `frame_a`

.

All components of a 1-dim.-rotational mechanical system that are connected to **a** common
**Mounting1D** element need to have the same axis of rotation
along parameter vector `n`

. This means that, e.g., bevel
gears where the axis of rotation of `flange_a`

and
`flange_b`

are different cannot be described properly by
connecting to the **Mounting1D** component. In this case, a combination of several
**Mounting1D** components or the component **BevelGear1D** should be used.

**Reference**

Schweiger, Christian ;
Otter, Martin:
Modelling
3D Mechanical Effects of 1-dim. Powertrains. In: *Proceedings of the 3rd International
Modelica Conference*. Linköping : The Modelica Association and Linköping University,
November 3-4, 2003, pp. 149-158

Type | Name | Default | Description |
---|---|---|---|

`Angle` | `phi0` | `0` | Fixed offset angle of housing |

`Axis` | `n[3]` | `{1, 0, 0}` | Axis of rotation = axis of support torque (resolved in frame_a) |

Type | Name | Description |
---|---|---|

`Flange_b` | `flange_b` | (right) flange fixed in housing |

`Frame_a` | `frame_a` | Frame in which housing is fixed (connector is removed, if world.driveTrainMechanics3D=false) |

1D inertia attachable on 3-dim. bodies (3D dynamic effects are taken into account if world.driveTrainMechanics3D=true)

This component is used to model the gyroscopic torques exerted by a 1-dim.
inertia (so called *rotor*) on its 3-dim. carrier body. Gyroscopic torques
appear, if the vector of the carrier body's angular velocity is not parallel
to the vector of the rotor's axis. The axis of rotation of the rotor is defined by
the parameter `n`

, which has to be given in the local coordinate system
of `frame_a`

. The default animation of this component is
shown in the figure below.

This component is a replacement for Modelica.Mechanics.Rotational.Components.Inertia for the case, that a 1-dim.-rotational mechanical system should be attached with a 3-dim. carrier body.

The Boolean parameter `exact`

was introduced due to performance
reasons. If `exact`

is set to **false**, the influence of the carrier body
motion on the angular velocity of the rotor is neglected. This influence is usually
negligible if the 1-dim.-rotational mechanical system accelerates much faster as the base body (this is,
e.g., the case in vehicle powertrains). The essential advantage is
that an algebraic loop is removed since then there is only an
action on acceleration level from the powertrain to the base body
but not vice versa.

**Reference**

Schweiger, Christian ;
Otter, Martin:
Modelling
3D Mechanical Effects of 1-dim. Powertrains. In: *Proceedings of the 3rd International
Modelica Conference*. Linköping : The Modelica Association and Linköping University,
November 3-4, 2003, pp. 149-158

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation shall be enabled (show rotor as cylinder) |

`Inertia` | `J` | Moment of inertia of rotor around its axis of rotation | |

`Axis` | `n[3]` | `{1, 0, 0}` | Axis of rotation resolved in frame_a |

`Position` | `r_center[3]` | `zeros(3)` | Position vector from origin of frame_a to center of cylinder |

`Distance` | `cylinderLength` | `2 * world.defaultJointLength` | Length of cylinder representing the rotor |

`Distance` | `cylinderDiameter` | `2 * world.defaultJointWidth` | Diameter of cylinder representing the rotor |

`StateSelect` | `stateSelect` | `StateSelect.default` | Priority to use rotor angle (phi) and rotor speed (w) as states |

`Boolean` | `exact` | `true` | = true, if exact calculations; false if influence of bearing on rotor acceleration is neglected to avoid an algebraic loop |

Type | Name | Description |
---|---|---|

`Flange_a` | `flange_a` | (left) driving flange (flange axis directed INTO cut plane) |

`Flange_b` | `flange_b` | (right) driven flange (flange axis directed OUT OF cut plane) |

`Frame_a` | `frame_a` | Frame in which rotor housing is fixed (connector is removed, if world.driveTrainMechanics3D=false) |

1D gearbox with arbitrary shaft directions and 3-dim. bearing frame (3D dynamic effects are taken into account provided world.driveTrainMechanics3D=true)

This component is used to model a 1-dim. gearbox
with non-parallel axes (defined by parameters `n_a`

, `n_b`

).
A 3-dim. `bearing`

frame is necessary to reflect the
correct support torque, as the axes of rotation of `flange_a`

and
`flange_b`

and the direction of the support torque vector
are different in general.

Note: The name BevelGear1D is kept only for simplicity. Regardless, this component could be used to model any kind of gearbox with non-parallel axes. For a usage example, see Examples.Rotational3DEffects.BevelGear1D.

**Reference**

Schweiger, Christian ;
Otter, Martin:
Modelling
3D Mechanical Effects of 1-dim. Powertrains. In: *Proceedings of the 3rd International
Modelica Conference*. Linköping : The Modelica Association and Linköping University,
November 3-4, 2003, pp. 149-158

Extends from `Modelica.Mechanics.Rotational.Interfaces.PartialTwoFlanges`

(Partial model for a component with two rotational 1-dim. shaft flanges).

Type | Name | Default | Description |
---|---|---|---|

`Real` | `ratio` | Gear speed ratio | |

`Axis` | `n_a[3]` | `{1, 0, 0}` | Axis of rotation of flange_a, resolved in frame_a |

`Axis` | `n_b[3]` | `{1, 0, 0}` | Axis of rotation of flange_b, resolved in frame_a |

Type | Name | Description |
---|---|---|

`Flange_a` | `flange_a` | Flange of left shaft |

`Flange_b` | `flange_b` | Flange of right shaft |

`Frame_a` | `frame_a` | Bearing frame |

Ideal rolling wheel on flat surface z=0 (5 positional, 3 velocity degrees of freedom)

A wheel rolling on the x-y plane of the world frame including
wheel mass and simple visualization.
The rolling contact is considered being ideal, i.e. there is no
slip between the wheel and the ground.
The wheel can not take off but it can incline toward the ground.
The frame frame_a is placed in the wheel center point and rotates
with the wheel itself. Therefore, a
rotational joint
with rotation axis `n={0,1,0}`

should be used to
connect the wheel to a carrier.

To work properly, the gravity acceleration vector g of the world must point in the negative z-axis, i.e.

inner Modelica.Mechanics.MultiBody.World world(n={0,0,-1});

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation of wheel shall be enabled |

`Radius` | `wheelRadius` | Radius of wheel | |

`Mass` | `wheelMass` | Mass of wheel | |

`Inertia` | `wheel_I_axis` | Inertia along the wheel axis | |

`Inertia` | `wheel_I_long` | Inertia perpendicular to the wheel axis | |

`StateSelect` | `stateSelect` | `StateSelect.always` | Priority to use generalized coordinates as states |

`Distance` | `width` | `0.035` | Width of wheel |

`Real` | `hollowFraction` | `0.8` | 1.0: Completely hollow, 0.0: rigid cylinder |

`Color` | `wheelColor[3]` | `{30, 30, 30}` | Color of wheel |

Type | Name | Description |
---|---|---|

`Frame_a` | `frame_a` | Frame fixed in wheel center point (y-axis: along wheel axis, z-axis: upwards) |

Ideal rolling wheel set consisting of two ideal rolling wheels connected together by an axis

Two wheels are connected by an axis and can rotate around this axis. The wheels are rolling on the x-y plane of the world frame. The coordinate system attached to the center of the wheel axis (frameMiddle) is constrained so that it is always parallel to the x-y plane. If all generalized coordinates are zero, frameMiddle is parallel to the world frame.

To work properly, the gravity acceleration vector g of the world must point in the negative z-axis, i.e.

inner Modelica.Mechanics.MultiBody.World world(n={0,0,-1});

Type | Name | Default | Description |
---|---|---|---|

`Boolean` | `animation` | `true` | = true, if animation of wheel set shall be enabled |

`Radius` | `wheelRadius` | Radius of one wheel | |

`Mass` | `wheelMass` | Mass of one wheel | |

`Inertia` | `wheel_I_axis` | Inertia along one wheel axis | |

`Inertia` | `wheel_I_long` | Inertia perpendicular to one wheel axis | |

`Distance` | `wheelDistance` | Distance between the two wheels | |

`StateSelect` | `stateSelect` | `StateSelect.always` | Priority to use the generalized coordinates as states |

`Distance` | `wheelWidth` | `0.01` | Width of one wheel |

`Real` | `hollowFraction` | `0.8` | 1.0: Completely hollow, 0.0: rigid cylinder |

`Color` | `wheelColor[3]` | `{30, 30, 30}` | Color of wheels |

Type | Name | Description |
---|---|---|

`Frame_a` | `frameMiddle` | Frame fixed in middle of axis connecting both wheels (y-axis: along wheel axis, z-axis: upwards) |

`Frame_a` | `frame1` | Frame fixed in center point of left wheel (y-axis: along wheel axis, z-axis: upwards) |

`Frame_b` | `frame2` | Frame fixed in center point of right wheel (y-axis: along wheel axis, z-axis: upwards) |

`Flange_a` | `axis1` | 1-dim. rotational flange that drives the left wheel |

`Flange_a` | `axis2` | 1-dim. rotational flange that drives the right wheel |

`Flange_b` | `support` | Support of 1D axes |

Generated 2018-12-12 12:12:52 EST by *MapleSim*.