MF-SWIFT/MF-Tyre Integration with MotionSolve

MotionSolve Input Deck

This topic describes how to set up MotionSolve to use an MF-SWIFT/MF-Tyre tire model with a vehicle set up. The following assumptions are made:
  1. To begin, you have a vehicle model without tires.
  2. You have an MF-SWIFT/MF-Tyre tire file and a compatible road definition file.
  3. You have access to a license for running the MF-Tyre tire model (only required for MF-SWIFT).
There is a collection of solver entities required to enable a tire model. You can build up a vehicle model to utilize a tire model using the set of entities described below:
  1. A set of required markers.
  2. One wheel/tire body per tire.
  3. One revolute joint for wheel spin axis. Or, optionally, a bushing entity with very stiff rates in the non-spin direction and only damping in the spin direction.
  4. One force entity that acts on two bodies of type “user”.
  5. One array that contains properties relating to the tire.
  6. One string entity for referencing the tire property file.
  7. One string entity for referencing the road property file.
  8. One state equation entity and related arrays for interfacing the tire states and tire outputs with the MBD model.

1. Setting up the markers.

A marker is required, located at the wheel center and attached to the ground body. This is a floating marker that will stay superimposed on the marker used to define the tire force.
    id                  = "11001020"
    label               = "Front Tire J Marker-left"
    body_id             = "30101"
    body_type           = "RigidBody"
    pos_x               = "1000."
    pos_y               = "-750."
    pos_z               = "1000."
A road reference marker is required to define the height of the road. This marker is attached to ground.
    id                  = "11001010"
    label               = "Road Reference Marker Front-left"
    body_id             = "30101"
    body_type           = "RigidBody"
    pos_x               = "0."
    pos_y               = "0."
    pos_z               = "680.03"
A marker is required for the action-reaction tire force. It is attached to the wheel/tire body and oriented with the Y axis along the spin axis pointing to the left, the X axis in the plane of the wheel and oriented in the positive direction of travel, and the Z axis pointing up.
    id                  = "11003020"
    label               = "Front Tire Force Reference-left"
    body_id             = "10403"
    body_type           = "RigidBody"
    pos_x               = "1000."
    pos_y               = "-750."
    pos_z               = "1000."
    a00                 = "-1."
    a10                 = "0."
    a20                 = "0."
    a02                 = "0."
    a12                 = "0."
    a22                 = "1."

2. Setting up the wheel body and the constraints.

The model must contain a wheel body and a revolute joint between the wheel body and another part of the vehicle model. The revolute joint should be aligned to represent the spin axis of the tire (see the example below):
Note: A bushing can be used in place of the revolute joint; however, this is rarely used.
    id                  = "10403"
    label               = "Wheel-left"
    cg_id               = "10403010"
    im_id               = "10403010"
    lprf_id             = "10403001"
    mass                = "36."
    inertia_xx          = "1750000."
    inertia_yy          = "1750000."
    inertia_zz          = "1000000."
    v_ic_x              = "-24587.2"
    v_ic_y              = "0."
    v_ic_z              = "0."
    w_ic_x              = "0."
    w_ic_y              = "0."
    w_ic_z              = "-76.842204"
    v_ic_x_flag         = "TRUE"
    v_ic_y_flag         = "TRUE"
    v_ic_z_flag         = "TRUE"
    w_ic_flag           = "TRUE"
    id                  = "104002"
    label               = "Wheel spindle rj-left"
    type                = "REVOLUTE"
    i_marker_id         = "10404020"
    j_marker_id         = "10401020"

3. Setting up the force vector.

The input deck then requires a Force_Vector_TwoBody force (action-reaction force) of the type "User". The usrsub_dll_name must be “mbdtire” and the usrsub_fnc_name must be “GFOSUB” or “mbdtire”. The parameters for the "USER" arguments are:
  • par1: The routing ID (used only if the function name is GFOSUB).
  • par2: The ID of the Force_Vector_TwoBody.
  • par3: The ID of the Reference_Array used for the tire.
     id                  = "1"
     label               = "tire_handling_fr_AAAA_v05_0_swift.tir_wheel.force"
     type                = "ForceAndTorque"
     i_marker_id         = "1239"
     j_floating_marker_id= "1225"
     ref_marker_id       = "1223"
     usrsub_param_string = "USER(908,1,1078)"
     usrsub_dll_name     = "mbdtire"
     usrsub_fnc_name     = "GFOSUB"

4. Setting up the tire reference array.

Many of the required values for the tire are stored in the Reference_Array from par3:
     id                  = "1096"
     label               = "tire_handling_rr_AAAA_v05_0_swift.til_wheel.input_array"
     type                = "IC"
     num_element         = "15">
   1.0950000E+03   4.0000000E+00   0.0000000E+00   9.4000000E+01   9.9000000E+01
   1.0200000E+02   1.0000000E+02   1.0100000E+02   3.1350000E+02   0.0000000E+00
  -1.0000000E+00   1.0970000E+03   1.0980000E+03   0.0000000E+00   0.0000000E+00
Note: The array can contain up to 16 numbers; however, only the first seven parameters are required. The description of these numbers is given below.

The array must be of type “IC”.

Parameter Number Description
1 ID of <Reference_Array> holding tire states (that is, the X array of the GSE).
2 Number of time continuous state variables for the tire (this can be overridden later).
3 Number that indicates which side of the vehicle the tire is mounted on (0 = left, 1 = right).
4 ID of <Reference_String> that lists the axle name (for example, front, rear, trailer).
5 ID of <Reference_String> that lists the path and name of the tire property file.
6 ID of <Reference_String> that lists the simulation type (currently unused).
7 ID of <Reference_String> that lists the path and name of the road property file.
8 ID of <Reference_String> that lists the contact type (currently unused).
9 Rig radius (used for suspension analysis tire).
10 ID of <Control_Diff> element used for steady-state analysis.
11 Tydex ISWITCH setting (this is overridden by the USE_MODE specified in the tire property file).
12 ID of <Reference_Array> holding scaling and drift factors.
13 ID of <Reference_Array> holding user parameters.
14 ID of JPRIM to lock wheel rotation (for steady state analysis).
15 Rig Stiffness (suspension analysis tire).
16 Smoothing time.

5. Setting up the property files for road and tire.

Element 5 above lists the ID of the string that contains the tire property file:
     id                  = "86"
     label               = "tire_handling_fr_AAAA_v05_0_swift.tir_wheel.tpf_file"
     string              = "TNO_car205_60R15_swift_sin.tir"
Note: To enable MotionSolve to recognize the tire property file as an MF-Tyre, you must ensure the following:
  1. In the [MODEL] section, the attribute “PROPERTY_FILE_FORMAT” must be set to ‘SWIFT-TYRE’.
  2. In the [MODEL] section, the attribute “FUNCTION_NAME” must be set to 'tnodelft::DTYRE'.
  3. In the [MODEL] section, the attribute “ROAD_SOURCE” must be set to ‘TNO’. The attribute “ROAD_SOURCE” can have three valid options:
    • ROAD_SOURCE = ‘TNO’ – use MF-Tyre/MF-SWIFT internal road definition.
    • ROAD_SOURCE = ‘MBS’ – use road definition of MotionSolve.
    • ROAD_SOURCE = ‘USER’ – use user-written road.
Element 7 above lists the ID of the string that contains the road property file:
     id                  = "87"
     label               = "tire_handling_fr_AAAA_v05_0_swift.tir_wheel.rpf_file"
     string              = "2d_flat_TNO.rdf"

6. Setting up the GSE.

In addition to the above elements, a GSE (of type “USERSUB”) is required to interface the tire model with the MBD model. For example:
     id                  = "3"
     label               = "tir_wheel.tire_gse"
     type                = "USERSUB"
     x_array_id          = "1077"
     y_array_id          = "1076"
     u_array_id          = "1075"
     num_state           = "5"
     num_output          = "0"
     usrsub_param_string = "USER(908,1,1078)"
     usrsub_dll_name     = "mbdtire"
     usrsub_fnc_name     = "gsesub"
     usrsub_der1_name    = "GSEXX"
     usrsub_der2_name    = "GSEXU"
     usrsub_der3_name    = "GSEYX"
     usrsub_der4_name    = "GSEYU"
     is_static_hold      = "FALSE"
  1. The Control_StateEqn must be of type “USERSUB”.
  2. The usrsub_param_string is of type USER (908, xxx, yyy) where xxx is the ID of the tire, yyy is the ID of the tire reference array. This must be consistent with the USER() string specified in the Force_Vector_TwoBody for each tire.
  3. The usrsub_dll_name must be “mbdTire”.
  4. The usrsub_fnc_name must be “gsesub”.
  5. x_array_id points to the ID of an array that holds the tire states.
  6. y_array_id points to the ID of an array that holds the outputs from the GSE (forces and moments).
  7. u_array_id points to the ID of an array that holds the values of the input variables.
  8. num_state lists the number of states for the tire. This is overridden internally.
  9. num_output lists the number of outputs from the tire. This is also overridden internally if not equal to 6 (Fx, Fy, Fz, Mx, My, Mz).
The input variables are used to compute tire rim states. They are defined according to the following table:
Variable Name U array Description Formula
Time U[0] Simulation time TIME
Rim dx/dy/dz U[1/2/3] WC displacements in earth axis system DX/Y/Z(tire i marker, rm, rm)
Rim X dot X/Y/Z U[4/5/6] Direction cosines of wheel X axis along global X/Y/Z axis SYSARY(UVX/Y/Z)
Rim Y dot X/Y/Z U[7/8/9] Direction cosines of wheel Y axis along global X/Y/Z axis SYSARY(UVX/Y/Z)
Rim VX/Y/Z U[10/11/12] Wheel Center translational velocities SYSFNC(VX/Y/Z, i, rm, rm…)
Rim WX/Y/Z U[13/14/15] Wheel Center rotational velocities SYSFNC(WX/Y/Z, i, rm, rm…)

7. Running MF-Tyre versus MF-SWIFT.

The difference between MF-Tyre and MF-SWIFT tire models is that the latter uses rigid ring dynamics while calculating the tire forces, moments and other kinematic quantities. You can switch between the two tire models by manipulating the property “USE_MODE” in the tire property file.

USE_MODE specifies the type of calculation performed:
0: Fz only, no Magic Formula evaluation
1: Fx,My only
2: Fy,Mx,Mz only
3: Fx,Fy,Mx,My,Mz uncombined force/moment calculation
4: Fx,Fy,Mx,My,Mz combined force/moment calculation
5: Fx,Fy,Mx,My,Mz combined force/moment calculation + turnslip
+0: steady state behavior
+10: including relaxation behavior
+20: including relaxation behavior (nonlinear)
+30: including rigid ring dynamics
+100: smooth road contact
+200: smooth road contact (circular cross section, motorcycles)
+400: road contact for 2D roads (using traveled distance)
+500: road contact for 3D roads
To use the MF-SWIFT tyre, you need to add “30” to the USE_MODE. For example, USE_MODE = 434 implies:
  • combined slip
  • rigid ring dynamics
  • road contact for 2D roads

8. Tire requests from MF-SWIFT/MF-Tyre

In addition to the regular tire requests that can be extracted in mbdTire, the TNO MF-Tyre/MF-SWIFT includes a few other requests that can be extracted using an mbdTire REQSUB with the following syntax:
     id                  = "759"
     comment             = "road_contact_point_location_rear_LH"
     type                = "USERSUB"
     usrsub_param_string = "USER(902,reqType,tireId)"
     usrsub_dll_name     = "NULL"
     usrsub_fnc_name     = "REQSUB"
     cname2              = "X_rear"
     cname3              = "Y_rear"
     cname4              = "Z_rear"
     cname6              = "tire_radial_penetration_rear"
     cname7              = "tire_radial_penetration_velocity_rear"
     cunit1              = "no_units"
     cunit2              = "length"
     cunit3              = "length"
     cunit4              = "length"
     cunit5              = "no_units"
     cunit6              = "length"
     cunit7              = "velocity"
     cunit8              = "no_units"
In the request element above, reqType can be:
1 Tire rolling states.
2 Tire kinematic properties (Tydex-W/ISO).
3 Tire contact patch forces (Tydex-W/ISO).
4 Tire contact patch forces (SAE).
5 Tire kinematic properties (SAE).
6 Tire hub forces (Tydex-C).
7 Miscellaneous tire states
  • Longitudinal coefficient of friction MUXCNT
  • Lateral coefficient of friction MUYCNT
8 Miscellaneous tire states:
  • Pneumatic trail
  • Longitudinal relaxation length
  • Lateral relaxation length
9 N/A
10 Contact patch locations along the plane of the tire in GFORCE rm marker frame.
11 Hub velocities of tire in GFORCE rm marker frame.
14 Miscellaneous tire states:
  • Distance traveled
  • Effective plane height
  • Effective plane angle
  • Effective plane curvature
  • Contact length