Motion: Marker Based

Description

The motion input may be translational or rotational. You define an expression for the motion characteristics. The expression may be used to define a displacement, velocity, or acceleration input. The expression is usually a function of time. Refer to Comment 8 if you want to make the motion expression dependent on system states.

Format

<Motion_Marker
       id                  = "integer"     
     [ label               = "string" ]       
       i_marker_id         = "integer"       
       j_marker_id         = "integer"       
       direction           = { "X" | "Y" | "Z" | "B1" | "B2" | "B3" }
  
   {   val_typ             = "D"
     | val_typ             = "V"
       ic_disp             = "real"     
     | val_typ             = "A"
       ic_disp             = "real"       
       ic_vel              = "real"  
   }  
   {       
       type                = "expression"
       expr                = "motionsolve_expression" >
     | type                = "USERSUB" 
       usrsub_dll_name     = "valid_path_name"
       usrsub_param_string = "USER( [[par_1 [, ...][,par_n]] )"
       usrsub_fnc_name     = "custom_fnc_name" >     
     | type                = "USERSUB"
       script_name         =  valid_path_name
       interpreter         = "PYTHON" | "MATLAB"
       usrsub_param_string = "USER( [[par_1 [, ...][,par_n]] )"
       usrsub_fnc_name     = "custom_fnc_name" >
   }
</Motion_Marker>

Attributes

id

Element identification number (integer>0). This number is unique among all Motion_Marker elements.

label

The name of the Motion_Marker element.

i_marker_id

Specifies the Reference_Marker ID at which the motion input is applied.

j_marker_id

Specifies the Reference_Marker ID from which the motion input is applied.

direction

Specifies the direction of the input. Select one from "X", "Y", "Z", "B1", "B2", and "B3".

"X", "Y", and "Z" specify the direction for the translational motion.

"B1", "B2", "B3" specify the direction for the rotational motion.

val_type

Specifies whether the motion applies a displacement input (D), a velocity input (V), or an acceleration input (A). You must select one value from "D", "V" or "A".

ic_disp

Specifies the displacement initial condition that is required when val_type = "V" or val_type = "A".

ic_vel

Specifies the velocity initial condition that is required when val_type = "A".

type

Select from expression and USERSUB. Specifies how the motion expression is defined. The expression option specifies that the motion value is a MotionSolve expression that can be evaluated at run-time. The USERSUB option indicates that the value of the motion is specified in a user defined subroutine. The parameters "usrsub_param_string" and "usrsub_dll_name" are used to provide more information about the user defined subroutine.

expr

Defines an expression that defines the motion value. Use this parameter only when type = expression. Any valid run-time MotionSolve expression can be provided as input.

usrsub_param_string

The list of parameters that are passed from the data file to the user defined subroutine. Use this keyword only when type = USERSUB is selected.

usrsub_dll_name

Specifies the path and name of the DLL or shared library containing the user subroutine. MotionSolve uses this information to load the user subroutine in the DLL at run time.

usrsub_fnc_name

Specifies an alternative name for the user subroutine MOTSUB.

script_name

Specifies the path and name of the user written script that contains the routine specified by usrsub_fnc_name.

interpreter

Specifies the interpreted language that the user script is written in. Valid choices are MATLAB or PYTHON.

Example

The first example shows how experimental data may be fed into the system as motion input.

Automotive durability simulations are often performed using semi-analytical simulation techniques. A vehicle to be tested is instrumented with wheel force transducers to measure the acceleration at the spindle while it is being driven. The vehicle is driven on a proving ground and the acceleration data at the spindles is collected and saved in a file. Since all necessary data cannot be measured experimentally, a computer simulation is now performed to "recover" the full set of loads required to analyze component durability.

This simulation is done as follows. The experimental data is "cleaned" to remove noise and high frequency data. Next, a four-poster test rig model is created in MotionSolve. The vehicle is tethered to the test-rig. Actuators at each spindle replay the experimentally measured data. During the simulation, loads acting at each component are measured. These are passed on to finite element programs for component strength, damage, and life prediction.

One of the motions in the vertical direction might be as follows. Reference_Marker 301 defines a coordinate system at the front-right spindle of the vehicle. The measured motion in the global "z" direction is to be applied at this marker. The experimental data is contained in PARAM_SPLINE 301001. A cubic spline is used to interpolate through the data.

Since the data experimentally measured are accelerations, as a part of the "cleaning" process, it is numerically integrated to yield the desired velocity data.

The Motion_Marker modeling element for this scenario is:

<Motion_Marker
     id                  = "1"
     i_marker_id         = "301"
     j_marker_id         = "0"
     direction           = "Y"
     val_type            = "V"
     ic_disp             = "0." 
     type                = "EXPRESSION"
     expr                = "CUBSPL(301001, Time, 0)" >
</Motion_Marker>

The second example demonstrates how you may specify the motion of the end-effector of a robotic manipulator while it is executing a 3-D path through global space.

Reference_marker 314159 defines a coordinate system at the tip of the end-effector. Reference_Curve 3 defines the 3-D curve in global space. The X-, Y- and Z-coordinates of the end-effector are to be specified as a function of time. Motions in the X- and Y-directions are shown below.

<Motion_Marker
  id          = "101"
  i_marker_id = "314159"
  j_marker_id = "0"
  direction   = "X"
  type        = "EXPRESSION"
  expr        = "CURVE(3, Time, 1)"
  val_type    = "D" >
</Motion_Marker>

<Motion_Marker
  id          = "101"
  i_marker_id = "314159"
  j_marker_id = "0"
  direction   = "Y"
  type        = "EXPRESSION"
  expr        = "CURVE(3, Time, 2)"
  val_type    = "D" >
</Motion_Marker>

<Motion_Marker
  id          = "101"
  i_marker_id = "314159"
  j_marker_id = "0"
  direction   = "X"
  type        = "EXPRESSION"
  expr        = "CURVE(3, Time, 1)"
  val_type    = "D" >
</Motion_Marker>

<Motion_Marker
  id          = "101"
  I_marker_id = "314159"
  J_marker_id = "0"
  direction   = "Y"
  type        = "expression"
  expr        = "CURVE(3, Time, 2)"
  val_type    = "D" >
</Motion_Marker>

Comments

1. Three constraints are added for each Motion_Marker: the first in the displacement domain, the second in the velocity domain and the third in the acceleration domain.
   • When a displacement constraint is specified, the velocity and acceleration constraints are obtained by analytically differentiating the displacement constraints.
   • When you specify a velocity constraint, the displacement constraint is obtained by numerically integrating the velocity constraint and the acceleration constraint by analytically differentiating the velocity constraint.
   • When an acceleration constraint is specified, the velocity constraint is obtained by numerically integrating the acceleration constraint, and the displacement constraint by numerically integrating the velocity constraint.
2. Differentiation tends to amplify any noise in the input signal. It is therefore important to ensure that all expressions and experimental data provided as input be smooth. More precisely, they must have continuous first and second time derivatives. Avoid the AKIMA()interpolation method when interpolating through experimental data. AKIMA() does not calculate good first and second derivatives. Use CUBSPL()instead.
3. Integration tends to decrease the noise in an input signal. Therefore, it is a good idea to use velocity inputs when providing interpolated experimental or tabular data as motion input expressions.
4. Define your curve with as few points as possible. Excessively large number of interpolation points in a cubic curve makes its first derivative "jumpy", and its second derivative "extremely jumpy", even though the curve itself may look smooth.
5. Make sure that the initial velocity of the motion matches the initial velocities of the bodies that it affects. For example, if your mechanism simulation starts from an initial static state, then you should make sure that the input motion has zero initial velocity. The motion input overrides any conflicting body and joint initial velocities.
6. If you decide to use velocity inputs, be aware that the position is satisfied only to the integration error specified in the Param_Transient element. Likewise for acceleration inputs, the velocity and position are only satisfied to the integration error specified. Therefore, you may see some drift from the analytical solution. This is a limitation of any scheme based on numerical integration.
7. It is useful to take a look at the reaction force/torque time histories due to the motion constraint. It tells you how much force/torque is needed to achieve the given motion. You should ascertain whether or not this is realistic. Furthermore, it sometimes makes better physical sense to replace the motion with applied forces coupled with control laws. Remember that motion in a dynamic analysis is treated as a "hard" constraint with no room for compliance.
8. Motions may only be functions of time. You should try to avoid using functions of other system displacements, velocities, accelerations, reaction forces, and applied forces. MotionSolve may or may not be able to find a solution in such cases. If you find such a need, for example to implement a control law, then write a user subroutine to do so. However, you must apply a time lag to the system data you are requesting and then smooth it as discussed below.
   • Assume that a Motion_Joint is used to apply a displacement that is based on the sensed radial velocity between two Reference_Markers 100 and 200. Then, you must code the user subroutine to implement the following:

     EXPR(Tk+1) = VR(100,200)

     evaluated at T_k, where T_k+1- T_k is the sampling period for the system.

     Note that EXPR(T_n+1) is constant. However, it changes whenever the velocity VR() is sampled. This implementation is not adequate because the sampled values are not continuous. Now, you must fit a curve through the previously sampled values and extrapolate the curve to provide a smooth value. This is shown symbolically below:

     EXPR(Tk+1) = CUBIC(VR(100,200)|Tk, VR(100,200)|Tk-1, VR(100,200)|Tk-2)

9. Directions B1, B2, and B3 refer to first, second, and third angles of the 1, 2, and 3 Euler angles to orient the I marker relative to the J marker. The image below illustrates this sequence.

   
   
   Figure 1.

   • Start with a coordinate system X-Y-Z. Rotate the system about the X axis. This is the B1 rotation. Due to this rotation, Y will move to Y' and Z to Z'. The coordinate system obtained due to the B1 rotation is X-Y'-Z'.
   • Now rotate about the Y' axis by an angle B2. Due to this rotation, Z' will move to its final location, Z₁ and X to X''. The coordinate system obtained due to the B2 rotation is X''-Y'-Z₁.
   • The final rotation occurs about the Z₁ axis. Due to this rotation, B3, X'' moves to it final location, X₁ and Y' to its final location, Y₁. The original orientation is X-Y-Z, the final is X₁-Y₁-Z₁.