Kratos rotating frame

[SADPR]

Overview

This PR introduces a RotatingFrameProcess in the MeshMovingApplication to apply rigid-body rotational kinematics to model parts in ALE-type simulations, e.g., Sliding Mesh.

The process performs two operations:

• rotates a model part (rotating frame) and assigns the corresponding MESH_DISPLACEMENT
• assigns the corresponding rigid-body rotational VELOCITY to another model part (rotating object/skin)

Overview

This PR introduces a RotatingFrameProcess in the MeshMovingApplication to apply rigid-body rotational kinematics to model parts in ALE-type simulations.

The process performs two operations:

• rotates a model part and assigns the corresponding MESH_DISPLACEMENT
• assigns the corresponding rigid-body rotational VELOCITY to another model part

The rigid-body velocity is computed as

$$ \mathbf{v} = \boldsymbol{\omega} \times (\mathbf{x} - \mathbf{x}_c) $$

where

• $\boldsymbol{\omega}$ is the angular velocity
• $\mathbf{x}_c$ is the center of rotation.

The mesh rotation is applied as

$$ \mathbf{x} = \mathbf{R}(\theta)(\mathbf{x}_0 - \mathbf{x}_c) + \mathbf{x}_c $$

with the corresponding mesh displacement

$$ \mathbf{u}_{mesh} = \mathbf{x} - \mathbf{x}_0 $$

Angular acceleration

If an acceleration_time is specified, the angular velocity is ramped linearly until the target value is reached.

Let $\omega_t$ be the target angular velocity and $T_a$ the acceleration time.
The angular acceleration is

$$ \alpha = \frac{\omega_t}{T_a} $$

For $t \le T_a$:

$$ \omega(t) = \alpha t $$

$$ \theta(t) = \frac{1}{2}\alpha t^2 $$

For $t \text{greater than} T_a$:

$$ \omega(t) = \omega_t $$

$$ \theta(t) = \frac{1}{2}\alpha T_a^2 + \omega_t (t - T_a) $$

This allows smoothly ramping the rotational motion before reaching the final constant angular velocity.

---

Process Settings

The process requires two model parts:

• rotating_frame_model_part_name
  Model part whose nodes are rotated and assigned MESH_DISPLACEMENT.

• rotating_object_model_part_name
  Model part where the rigid-body rotational VELOCITY is imposed.

Example:

{
    "rotating_frame_model_part_name": "FluidModelPart.ALE",
    "rotating_object_model_part_name": "FluidModelPart.Slave",
    "center_of_rotation": [0.0, 0.0, 0.0],
    "axis_of_rotation": [0.0, 0.0, 1.0],
    "target_angular_velocity_radians": 5.0,
    "acceleration_time": 0.5
}

[loumalouomega]

I love the animation

[loumalouomega]

These operation in C++ (can be implemented in some utilities) may gain some important performance.

[loumalouomega]

My only comment is that some operations may be interesting to implement in some utilities and expose to python to avoid performance penalty

[SADPR]

@loumalouomega Those functions were in C++ at the beginning (slightly faster). But @RiccardoRossi convinced me to make everything in Python. See -> 102d1fb

[loumalouomega]

@loumalouomega Those functions were in C++ at the beginning (slightly faster). But @RiccardoRossi convinced me to make everything in Python. See -> 102d1fb

¯_(ツ)_/¯

[rubenzorrilla]

Can't we use the standard f(x,y,z,t) functions I/O we have for all the processes to define the angular velocity here? Besides being more similar to the rest of processes, it would allow to define any ramp up function.

[SADPR]

@rubenzorrilla done. RotatingFrameProcess now uses standard function input for angular velocity (angular_velocity_radians as constant or f(x,y,z,t)), with interval support. I removed target_angular_velocity_radians and acceleration_time to avoid duplicated APIs. Ramp-up can be defined directly in the function (e.g. -25.0*t if t<1.0 else -25.0). I also added regression tests for function input and interval behavior.

[SADPR]

@RiccardoRossi @rubenzorrilla any news here?