Skip to content

Rigid Body Motion

Rigid Body Motion

This section describes the grid motion capabilities available in the LAVA Unstructured solver, beginning with rigid-body motion. Rigid-body motion alters the position and orientation of the computational grid while preserving its original geometry. Although grid point coordinates vary over time, the relative distances, connectivity, and topology of the mesh remain unchanged. Consequently, geometric quantities such as cell volumes and face areas remain constant throughout the simulation.

Rigid-body motion can be prescribed as either translation or rotation. Each type can be specified as a constant motion (constant translational or angular velocity) or as a sinusoidal oscillation. This capability defines the movement of different grid domains and is essential for simulations involving moving components. It is also critical for stability analysis and unsteady aerodynamic simulations involving prescribed single-degree-of-freedom (1-DOF) motions, including forced-oscillation roll, pitch, yaw, surge, sway, and plunge.

Each grid file specified in the Grid File and Transformations section Grid File and Transformations is indexed sequentially starting from 1, based on its order in the grid definition list. Support for prescribed combined translation/rotation motions, as well as general six-degree-of-freedom (6-DOF) free-flight simulations, is currently under testing.

You can define multiple motion groups, each identified by a unique index (e.g., rigidbodymotion_1, rigidbodymotion_2). Each motion group is then assigned to one or more domains, though each domain may belong to only one motion group.

Below are four structured examples demonstrating how to configure rigid-body motion in the unst.input file:

Constant Speed Rotation

The following example configures a grid domain for a constant-rate rotational motion. This is typically used for a spinning rotor or propeller, or for a vehicle undergoing a constant-rate pitch ramp to change the angle of attack at equal intervals:

rigidbodymotion_1 {
    # List of domain IDs this motion applies to
    domains = [1]
    # Type of motion
    type = rotation
    # Rotation axis (will be normalized)
    axis = [0,1,0]
    # Center of rotation
    center = [0,0,0]
    # Angular speed in radians per second
    angular speed = 10.0
}

Sinusoidal Rotation

For oscillating motions, you can define a sinusoidal rotation. The angular speed parameter is replaced by amplitude and a rate given as either frequency or omega.

rigidbodymotion_1 {
    # List of domain IDs this motion applies to
    domains = [1]
    # Type of motion
    type = rotation
    # Kind of rotation
    kind = sinusoidal
    # Rotation axis (will be normalized)
    axis = [0,1,0]
    # Center of rotation
    center = [0,0,0]
    # Amplitude of oscillation in degrees
    amplitude = 10.0
    # Oscillation rate: frequency in Hz, or use "omega" in rad/s instead
    frequency = 5.0
}

Rotation Axis Definition

By default the axis is given directly by axis and center (axis definition = center_axis). Alternatively, you may define the axis by two points using axis definition = tail_head: the axis line runs from axis tail to axis head, with axis tail used as the pivot. Provide either axis/center or axis tail/axis head, not both.

rigidbodymotion_1 {
    domains = [1]
    type = rotation
    axis definition = tail_head
    # Pivot / start of the axis line
    axis tail = [0,0,0]
    # End of the axis line (direction = head - tail)
    axis head = [0,1,0]
    angular speed = 10.0
}

Constant Translation

A constant translation moves the domain at a fixed velocity vector.

rigidbodymotion_1 {
    domains = [1]
    type = translation
    # Constant velocity vector in m/s
    translation velocity = [0.5,0,0]
}

Sinusoidal Translation

A sinusoidal translation oscillates the domain about its initial position.

rigidbodymotion_1 {
    domains = [1]
    type = translation
    kind = sinusoidal
    # Per-axis peak displacement in meters
    amplitude = [0,0.1,0]
    # Oscillation rate: frequency in Hz, or use "omega" in rad/s instead
    frequency = 2.0
}

Motion Window

Any motion block can be limited to a time window. Before the window starts the domain holds its starting pose; after the window ends it holds the pose reached at the end. The phase of a sinusoidal motion is measured from the window start, so the oscillation always starts at zero. Without these keys the motion runs from t = 0 with no end.

rigidbodymotion_1 {
    domains = [1]
    type = rotation
    kind = sinusoidal
    axis = [0,1,0]
    center = [0.25,0,0]
    amplitude = 2.0
    frequency = 10.0
    # Hold still until t = 0.05 s (e.g. to develop the steady flow), then start oscillating
    motion start time = 0.05
    # Stop after 3 periods and hold that pose; omit for no end
    motion end time = 0.35
}

The window can also be given in convective time units, motion start ctu and motion end ctu, when the reference time is set. Use seconds or CTU for each end, not both.

Initial Attitude

If the body is meshed already turned, initial attitude tells the loads how it sits in the grid. The mesh and the motion are not changed. With alpha = 0 in the reference conditions, the aerofoil below, meshed 4° nose up, reports alpha_<group> = 4 plus the pitch motion, and the same body-axis and wind-axis loads as the unturned aerofoil at alpha = 4.

rigidbodymotion_1 {
    domains = [1]
    type = rotation
    kind = sinusoidal
    axis = [0,1,0]
    center = [0.25,0,0]
    amplitude = 2.0
    frequency = 10.0
    # [roll, pitch, yaw] in degrees: meshed 4 deg nose up; optional, default [0, 0, 0]
    initial attitude = [0, 4, 0]
}

Rotating Non-Inertial Frame

With noninertial = true, a rotation does not move the mesh: the domain is solved in a frame turning with it (multiple reference frame, MRF). Velocities stay absolute (laboratory frame), the convective flux is taken relative to the frame (Ω × r), and the momentum equation gets one source, −ρ Ω × u. Use it for a problem that is steady in the rotating frame, for example an isolated rotor in axial flow.

rigidbodymotion_1 {
    domains = [1]
    type = rotation
    axis = [1,0,0]
    center = [0,0,0]
    # rad/s (= 2000 rpm; or use "rpm")
    angular speed = 209.44
    # Solve in the rotating frame; the mesh does not move
    noninertial = true
}
  • Only type = rotation; anything else stops with an error. Both kind = constant and kind = sinusoidal (a frame oscillating about its axis) work, with or without a motion window: the absolute-velocity form needs no further source for a time-varying rate.
  • The far field is fixed in grid axes, so the freestream should be along the frame axis; otherwise a warning says the run models a freestream turning with the frame.
  • initial attitude is ignored for a frame (warning). Loads groups in a frame use the grid axes as body axes; see Loads on moving bodies.

The parameters are: - domains: A list of domain IDs that will be subjected to this motion. Each domain can only be assigned to one motion group.

  • zone: The name of a grid zone to move, as an alternative to domains (give one or the other, not both). The name is resolved to its domain once the grid is read.
  • type: The type of motion, rotation or translation.
  • kind: Kind of motion, constant or sinusoidal.
  • axis definition: How the rotation axis is specified, center_axis (default) or tail_head (rotation only).
  • axis: A 3D vector defining the axis of rotation (center_axis mode). This vector will be normalized by the solver.
  • center: A 3D vector specifying the center point of the rotation in meters (center_axis mode).
  • axis tail, axis head: Two 3D points in meters defining the rotation axis line (tail_head mode).
  • angular speed: The speed of rotation in radians per second (for constant speed rotation).
  • rpm: The constant rotation speed in revolutions per minute (signed), as an alternative to angular speed. Exactly one of the two must be given for a constant rotation.
  • amplitude: For sinusoidal rotation, the peak angular amplitude in degrees. For sinusoidal translation, a 3D vector of peak displacements in meters.
  • frequency: The oscillation frequency in Hz (for sinusoidal motion).
  • omega: The oscillation angular frequency in radians per second, as an alternative to frequency. Exactly one of frequency or omega must be given for a sinusoidal motion.
  • translation velocity: A 3D velocity vector in m/s (for constant translation).
  • motion start time, motion end time: Optional time window of the motion in seconds (or motion start ctu, motion end ctu in convective time units). See motion window.
  • noninertial: true to solve this rotation as a rotating reference frame instead of moving the mesh (default false). See rotating non-inertial frame.
  • initial attitude: [roll, pitch, yaw] in degrees (default [0, 0, 0]): how the body sits in the grid as meshed. It affects the loads only — the mesh is not moved and the motion is unchanged. The body axes of every loads group carried by this motion are the grid axes turned by yaw about z, then pitch about y, then roll about x, the same way the freestream is built from alpha and beta. A model meshed 4° nose up, run at alpha = 0, therefore reports alpha_<group> = 4 and the same body-axis and wind-axis loads as the unturned model at alpha = 4. The motion then carries the body from this attitude, so a sinusoidal pitch oscillates about the meshed angle. Ignored (with a warning) for a non-inertial frame and for a block that moves no mesh. See Loads on moving bodies.

For translation, the user-defined moment center follows the path of the moving body, ensuring that moment integration remains consistent with the body's current position.

Warning

Prescribed translation and rotation (both constant and sinusoidal) are supported. Combined translation/rotation motions, as well as general six-degree-of-freedom (6-DOF) free-flight simulations, are currently undergoing testing.

In progress

This documentation will be published with an upcoming release.