SphericalParticleContactForce< dim, number, ObstacleType > Class Template Reference
|
Developer Documentation
|
#include <contact_forces.hpp>
Classes | |
| struct | ContactConfiguration |
Public Member Functions | |
| SphericalParticleContactForce (const SphericalParticleContactData< number > &contact_data, const MeltPoolDG::TimeIntegration::TimeIterator< number > &time_iterator) | |
| void | attach_wall (std::unique_ptr< dealii::Function< dim > > &&wall_signed_distance_function) |
| void | add_load_to_obstacles (ObstacleField< dim, number, ObstacleType > &obstacle_field) const |
Private Member Functions | |
| dealii::Tensor< 1, dim, number > | normal_contact_force (const ContactConfiguration &contact_configuration) const |
| dealii::Tensor< 1, dim, number > | tangential_contact_force (const ContactConfiguration &contact_configuration, const dealii::Tensor< 1, dim, number > &normal_force, dealii::Tensor< 1, dim, number > &tangential_gap) const |
| dealii::Tensor< 1, axial_dim< dim >, number > | tangential_contact_torque (const ContactConfiguration &contact_configuration, const dealii::Tensor< 1, dim, number > &tangential_force, const number particle_radius) const |
| dealii::Tensor< 1, axial_dim< dim >, number > | rolling_resistance_torque (const ContactConfiguration &contact_configuration, const dealii::Tensor< 1, dim, number > &contact_normal_force) const |
| number | compute_damping_prefactor (const number restitution_coefficient) const |
Private Attributes | |
| const SphericalParticleContactData< number > & | contact_data |
| Contact data for the spherical particle contact force model. | |
| const number | damping_prefactor |
| Damping prefactor computed from the restitution coefficient. This is cached for efficiency. | |
| std::map< int, std::map< int, dealii::Tensor< 1, dim, number > > > | tangential_gaps |
| std::map< int, std::map< int, dealii::Tensor< 1, dim, number > > > | tangential_gaps_with_walls |
| const MeltPoolDG::TimeIntegration::TimeIterator< number > & | time_iterator |
| std::map< int, std::unique_ptr< dealii::Function< dim > > > | wall_signed_distance_functions |
Constructor & Destructor Documentation
◆ SphericalParticleContactForce()
|
explicit |
Constructor for the spherical particle contact force model.
- Parameters
-
contact_data Contact data defining the material and contact properties. time_iterator Time iterator used in the DEM simulation for which the contact force is applied.
Member Function Documentation
◆ add_load_to_obstacles()
| void MeltPoolDG::SphericalParticleContactForce< dim, number, ObstacleType >::add_load_to_obstacles | ( | ObstacleField< dim, number, ObstacleType > & | obstacle_field | ) | const |
Compute the contact forces and add them to the obstacles in the given obstacle field. This algorithm consists of two steps, first finding contacting particles, then computing and adding the contact forces.
For finding contacting particles, a brute-force approach is used where each particle is checked against all other particles in the global particle data structure.
For the contact force computation, a nonlinear spring-dashpot model (Hertz contact theory) is used to compute normal contact forces between spherical particles. Currently only normal contact forces are computed; tangential forces and friction are not yet implemented. For details on the implemented model, see e.g. Gaboriault et al. (DOI:10.48550/arXiv.2509.26402).
- Parameters
-
obstacle_field The obstacle field containing the particles for which contact forces are to be computed. The resulting forces are added directly to the particles in this field.
◆ attach_wall()
| void MeltPoolDG::SphericalParticleContactForce< dim, number, ObstacleType >::attach_wall | ( | std::unique_ptr< dealii::Function< dim > > && | wall_signed_distance_function | ) |
This function adds a wall defined by a signed distance function to the contact force computation. The wall is represented by a function that returns the signed distance from any point in space to the wall surface. The normal vector at any point on the wall is obtained from the gradient of this function and must point outward from the wall surface.
- Parameters
-
wall_signed_distance_function A unique pointer to a function representing the signed distance to the wall.
- Note
- The wall function should return negative values inside the wall and positive values outside the wall. It is not possible to use a single wall function for a two-sided wall; if both sides of the wall should be considered, two separate wall functions must be added with different normal orientations.
◆ compute_damping_prefactor()
|
private |
Function which computes the damping prefactor from the restitution coefficient
\[ \eta_t = 2 \sqrt{\frac{5}{6}}\frac{\ln(e_r)}{\sqrt{\ln^2(e_r) + \pi^2}}, \]
with \(e_r\) being the coefficient of restitution.
- Parameters
-
restitution_coefficient The coefficient of restitution.
- Returns
- The computed damping prefactor.
◆ normal_contact_force()
|
private |
Computes the normal contact force for a given particle–particle contact. The formulation follows Gaboriault et al. (DOI:10.48550/arXiv.2509.26402).
The normal contact force is defined as
\[ \boldsymbol{F}_n = k_n\delta_n\boldsymbol{n} + \eta_n\boldsymbol{v}_n, \]
where \(k_n\) is the normal stiffness, \(\delta_n\) the normal overlap, \(\boldsymbol{n}\) the unit normal vector at the contact, \(\eta_n\) the normal damping coefficient, and \(v_n\) the normal component of the relative velocity.
The normal stiffness is computed as
\[ k_n = \frac{4}{3} Y_e \sqrt{R_e \delta_n}, \]
where \(Y_e\) is the effective Young's modulus and \(R_e\) the effective radius. The normal damping coefficient is given by
\[ \eta_n = c_d \sqrt{\frac{3}{2} k_n m_e}, \]
with \(c_d\) being a damping prefactor derived from the coefficient of restitution (see compute_damping_prefactor()) and \(m_e\) the effective mass.
- Parameters
-
contact_configuration Configuration of the contact between two particles.
- Returns
- The computed normal contact force vector.
◆ rolling_resistance_torque()
|
private |
Computes the rolling resistance torque at a particle–particle or particle-wall contact based on a viscous rolling resistance model. The model used in this function follows the formulation presented by Meier et al. (DOI:10.1016/j.powtec.2018.11.072).
The rolling resistance torque is defined as
\[ \boldsymbol{M}_r = \mu_r |\boldsymbol{F}_n| R_e \boldsymbol{\omega}_c, \]
where \(\mu_r\) is the rolling resistance coefficient, \(\boldsymbol{F}_n\) the normal contact force, \(R_e\) the effective radius, and \(\boldsymbol{\omega}_c\) the relative angular velocity projected onto the contact plane.
The relative angular velocity projected onto the contact plane is computed as
\[ \boldsymbol{\omega}_c = \boldsymbol{\omega}_r - (\boldsymbol{\omega}_r \cdot \boldsymbol{n}) \boldsymbol{n}, \]
where \(\boldsymbol{\omega}_r\) is the relative angular velocity between the two particles (or particle and wall) and \(\boldsymbol{n}\) the contact normal vector.
◆ tangential_contact_force()
|
private |
Computes the tangential contact force for a given particle–particle contact. The formulation follows Golshan et al. (https://doi.org/10.1007/s40571-022-00478-6).
The tangential contact force is defined as
\[ \boldsymbol{F}_t = -k_t \boldsymbol{\delta}_t - \eta_t \boldsymbol{v}_{rt}, \]
where \(k_t\) is the tangential stiffness, \(\boldsymbol{\delta}_t\) the tangential gap vector, \(\eta_t\) the tangential damping coefficient, and \(\boldsymbol{v}_{rt}\) the tangential component of the relative velocity.
The tangential stiffness is computed as
\[ k_t = 8 G_e \sqrt{R_e \delta_n}, \]
with \(G_e\) denoting the effective shear modulus, \(R_e\) the effective radius, and \(\delta_n\) the normal gap.
The tangential damping coefficient is given by
\[ \eta_t = -2 \sqrt{\frac{5}{6}}\frac{\ln(e_r)}{\sqrt{\ln^2(e_r) + \pi^2}} \sqrt{k_t m_e}, \]
where \(e_r\) is the coefficient of restitution and \(m_e\) the effective mass.
If the magnitude of the tangential force exceeds the Coulomb friction limit, i.e.,
\[ |\boldsymbol{F}_t| > \mu |\boldsymbol{F}_n|, \]
with \(\mu\) being the sliding friction coefficient and \(\boldsymbol{F}_n\) the normal contact force, the tangential gap is adjusted and the tangential force is recomputed such that the Coulomb limit is exactly satisfied.
- Parameters
-
contact_configuration Contact configuration between the two particles. normal_force Normal contact force vector for the contact. tangential_gap Tangential gap vector from the previous time step; updated by this function.
- Returns
- Tangential contact force vector.
◆ tangential_contact_torque()
|
private |
Given the tangential contact force at a particle–particle contact, this function calculates the resulting torque about the particle center as the cross product of the contact lever arm and the tangential force (M = (r*N) × F) with r being the particle radius, N is the contact normal vector pointing from the particle center to the point of contact, and F the tangential contact force acting at the contact point.
- Parameters
-
contact_configuration Geometric contact configuration between the two particles. tangential_force Tangential contact force vector at the contact point. particle_radius Radius of the particle for which the torque is computed.
- Returns
- Tangential contact torque vector acting on the particle.
Member Data Documentation
◆ contact_data
|
private |
Contact data for the spherical particle contact force model.
◆ damping_prefactor
|
private |
Damping prefactor computed from the restitution coefficient. This is cached for efficiency.
◆ tangential_gaps
|
mutableprivate |
Tangential gap vectors between particles. The key of the outer map identifies the particle of consideration (self), the inner map the other particle in contact.
◆ tangential_gaps_with_walls
|
mutableprivate |
Same as above, but for particle–wall contacts. The outer key corresponds to the particle id, while the inner key corresponds to the wall id. The stored tangential gap represents the tangential displacement between the particle and the wall associated with the respective ids.
◆ time_iterator
|
private |
Time iterator which is used in the DEM simulation. This is needed to get the current time step size.
◆ wall_signed_distance_functions
|
private |
Map of wall signed distance functions added to the contact model. The key is a unique wall id to identify each wall.
The documentation for this class was generated from the following files:
- include/meltpooldg/particles/contact_forces.hpp
- source/particles/contact_forces.cpp
Generated by
1.9.8