4#ifndef lethe_particle_particle_contact_force_h
5#define lethe_particle_particle_contact_force_h
17#include <boost/range/adaptor/map.hpp>
20#include <unordered_map>
36template <
int dim,
typename PropertiesIndex>
64 &local_adjacent_particles,
66 &ghost_adjacent_particles,
68 &local_local_periodic_adjacent_particles,
70 &local_ghost_periodic_adjacent_particles,
72 &ghost_local_periodic_adjacent_particles,
87 const types::boundary_id boundary_id)
141 typename PropertiesIndex,
176 &local_adjacent_particles,
178 &ghost_adjacent_particles,
180 &local_local_periodic_adjacent_particles,
182 &local_ghost_periodic_adjacent_particles,
184 &ghost_local_periodic_adjacent_particles,
208 Tensor<1, 3> &tangential_relative_velocity,
209 double &normal_relative_velocity_value,
210 Tensor<1, 3> &normal_unit_vector,
211 const ArrayView<const double> &particle_one_properties,
212 const ArrayView<const double> &particle_two_properties,
213 const Point<3> &particle_one_location,
214 const Point<3> &particle_two_location,
218 auto contact_vector = particle_two_location - particle_one_location;
221 normal_unit_vector = contact_vector / contact_vector.norm();
225 Tensor<1, 3> particle_one_omega, particle_two_omega;
228 Tensor<1, 3> contact_relative_velocity;
231 contact_relative_velocity[0] =
232 particle_one_properties[PropertiesIndex::v_x] -
233 particle_two_properties[PropertiesIndex::v_x];
234 contact_relative_velocity[1] =
235 particle_one_properties[PropertiesIndex::v_y] -
236 particle_two_properties[PropertiesIndex::v_y];
237 contact_relative_velocity[2] =
238 particle_one_properties[PropertiesIndex::v_z] -
239 particle_two_properties[PropertiesIndex::v_z];
241 particle_one_omega[0] = particle_one_properties[PropertiesIndex::omega_x];
242 particle_one_omega[1] = particle_one_properties[PropertiesIndex::omega_y];
243 particle_one_omega[2] = particle_one_properties[PropertiesIndex::omega_z];
245 particle_two_omega[0] = particle_two_properties[PropertiesIndex::omega_x];
246 particle_two_omega[1] = particle_two_properties[PropertiesIndex::omega_y];
247 particle_two_omega[2] = particle_two_properties[PropertiesIndex::omega_z];
251 contact_relative_velocity += (cross_product_3d(
252 0.5 * (particle_one_properties[PropertiesIndex::dp] * particle_one_omega +
253 particle_two_properties[PropertiesIndex::dp] * particle_two_omega),
254 normal_unit_vector));
260 normal_relative_velocity_value =
261 contact_relative_velocity * normal_unit_vector;
265 tangential_relative_velocity =
266 contact_relative_velocity -
267 (normal_relative_velocity_value * normal_unit_vector);
292 if constexpr (dim == 3)
293 return particle->get_location();
295 if constexpr (dim == 2)
310 const Tensor<1, dim> &periodic_offset) &
312 if constexpr (dim == 3)
313 return (particle->get_location() + periodic_offset);
315 if constexpr (dim == 2)
316 return point_nd_to_3d(particle->get_location() + periodic_offset);
344 const Tensor<1, 3> &tangential_relative_velocity,
345 const double normal_relative_velocity_value,
346 const Tensor<1, 3> &normal_unit_vector,
347 const double normal_overlap,
349 const ArrayView<const double> &particle_one_properties,
350 const ArrayView<const double> &particle_two_properties,
351 Tensor<1, 3> &normal_force,
352 Tensor<1, 3> &tangential_force,
353 Tensor<1, 3> &particle_one_tangential_torque,
354 Tensor<1, 3> &particle_two_tangential_torque,
355 Tensor<1, 3> &rolling_resistance_torque)
362 tangential_relative_velocity,
363 normal_relative_velocity_value,
367 particle_one_properties,
368 particle_two_properties,
371 particle_one_tangential_torque,
372 particle_two_tangential_torque,
373 rolling_resistance_torque);
379 tangential_relative_velocity,
380 normal_relative_velocity_value,
384 particle_one_properties,
385 particle_two_properties,
388 particle_one_tangential_torque,
389 particle_two_tangential_torque,
390 rolling_resistance_torque);
393 if constexpr (contact_model ==
398 tangential_relative_velocity,
399 normal_relative_velocity_value,
403 particle_one_properties,
404 particle_two_properties,
407 particle_one_tangential_torque,
408 particle_two_tangential_torque,
409 rolling_resistance_torque);
412 if constexpr (contact_model == ParticleParticleContactForceModel::
413 hertz_mindlin_limit_overlap)
417 tangential_relative_velocity,
418 normal_relative_velocity_value,
422 particle_one_properties,
423 particle_two_properties,
426 particle_one_tangential_torque,
427 particle_two_tangential_torque,
428 rolling_resistance_torque);
435 tangential_relative_velocity,
436 normal_relative_velocity_value,
440 particle_one_properties,
441 particle_two_properties,
444 particle_one_tangential_torque,
445 particle_two_tangential_torque,
446 rolling_resistance_torque);
452 tangential_relative_velocity,
453 normal_relative_velocity_value,
457 particle_one_properties,
458 particle_two_properties,
461 particle_one_tangential_torque,
462 particle_two_tangential_torque,
463 rolling_resistance_torque);
473 particle_one_properties,
474 particle_two_properties,
488 if constexpr (contact_model == Parameters::Lagrangian::
489 ParticleParticleContactForceModel::DMT)
496 const double max_effective_hamaker_constant =
498 const double min_effective_surface_energy =
504 max_effective_hamaker_constant /
529 const Tensor<1, 3> &normal_force,
530 const Tensor<1, 3> &tangential_force,
531 const Tensor<1, 3> &particle_one_tangential_torque,
532 const Tensor<1, 3> &particle_two_tangential_torque,
533 const Tensor<1, 3> &rolling_resistance_torque,
534 Tensor<1, 3> &particle_one_torque,
535 Tensor<1, 3> &particle_two_torque,
536 Tensor<1, 3> &particle_one_force,
537 Tensor<1, 3> &particle_two_force)
540 Tensor<1, 3> total_force = normal_force + tangential_force;
543 particle_one_force -= total_force;
544 particle_two_force += total_force;
545 particle_one_torque +=
546 -particle_one_tangential_torque + rolling_resistance_torque;
547 particle_two_torque +=
548 -particle_two_tangential_torque - rolling_resistance_torque;
564 const Tensor<1, 3> &normal_force,
565 const Tensor<1, 3> &tangential_force,
566 const Tensor<1, 3> &particle_one_tangential_torque,
567 const Tensor<1, 3> &rolling_resistance_torque,
568 Tensor<1, 3> &particle_one_torque,
569 Tensor<1, 3> &particle_one_force)
572 particle_one_force -= normal_force + tangential_force;
573 particle_one_torque +=
574 -particle_one_tangential_torque + rolling_resistance_torque;
584 inline std::tuple<double, double>
586 const ArrayView<const double> &particle_one_properties,
587 const ArrayView<const double> &particle_two_properties)
590 const double diameter_one = particle_one_properties[PropertiesIndex::dp];
591 const double diameter_two = particle_two_properties[PropertiesIndex::dp];
592 double effective_radius =
593 (diameter_one * diameter_two) / (2 * (diameter_one + diameter_two));
596 const double mass_one = particle_one_properties[PropertiesIndex::mass];
597 const double mass_two = particle_two_properties[PropertiesIndex::mass];
598 double effective_mass = (mass_one * mass_two) / (mass_one + mass_two);
600 return std::make_tuple(effective_radius, effective_mass);
624 [[maybe_unused]]
const double effective_radius,
625 [[maybe_unused]]
const ArrayView<const double> &particle_one_properties,
626 [[maybe_unused]]
const ArrayView<const double> &particle_two_properties,
627 [[maybe_unused]]
const double rolling_friction_coeff,
628 [[maybe_unused]]
const double rolling_viscous_damping_coeff,
629 [[maybe_unused]]
const double dt,
630 [[maybe_unused]]
const double normal_spring_constant,
631 [[maybe_unused]]
const double normal_force_norm,
632 [[maybe_unused]]
const Tensor<1, 3> &normal_unit_vector,
633 Tensor<1, 3> &cumulative_rolling_resistance_spring_torque)
637 if constexpr (rolling_friction_model ==
none)
642 if constexpr (rolling_friction_model ==
constant)
646 particle_one_properties,
647 particle_two_properties,
648 rolling_friction_coeff,
652 if constexpr (rolling_friction_model ==
viscous)
656 particle_one_properties,
657 particle_two_properties,
658 rolling_friction_coeff,
662 if constexpr (rolling_friction_model ==
epsd)
666 particle_one_properties,
667 particle_two_properties,
668 rolling_friction_coeff,
669 rolling_viscous_damping_coeff,
673 normal_spring_constant,
675 cumulative_rolling_resistance_spring_torque);
705 const Tensor<1, 3> &tangential_relative_velocity,
706 const double normal_relative_velocity_value,
707 const Tensor<1, 3> &normal_unit_vector,
708 const double normal_overlap,
710 const ArrayView<const double> &particle_one_properties,
711 const ArrayView<const double> &particle_two_properties,
712 Tensor<1, 3> &normal_force,
713 Tensor<1, 3> &tangential_force,
714 Tensor<1, 3> &particle_one_tangential_torque,
715 Tensor<1, 3> &particle_two_tangential_torque,
716 Tensor<1, 3> &rolling_resistance_torque)
719 auto [effective_radius, effective_mass] =
721 particle_two_properties);
725 const unsigned int particle_one_type =
726 static_cast<unsigned int>(particle_one_properties[PropertiesIndex::type]);
727 const unsigned int particle_two_type =
728 static_cast<unsigned int>(particle_two_properties[PropertiesIndex::type]);
729 const unsigned int pair_index =
734 const double rolling_viscous_damping_coeff =
736 const double friction_coeff =
738 const double rolling_friction_coeff =
742 const double &diameter_one = particle_one_properties[PropertiesIndex::dp];
743 const double &diameter_two = particle_two_properties[PropertiesIndex::dp];
747 constexpr double characteristic_velocity = 1.0;
751 double normal_spring_constant =
752 1.0667 * sqrt(effective_radius) * youngs_modulus *
753 pow((0.9375 * effective_mass * characteristic_velocity *
754 characteristic_velocity / (sqrt(effective_radius) * youngs_modulus)),
761 double tangential_spring_constant = normal_spring_constant * 0.4;
765 double normal_damping_constant =
766 -2 * beta * sqrt(effective_mass * normal_spring_constant);
769 double tangential_damping_constant =
770 normal_damping_constant * 0.6324555320336759;
773 const double normal_force_value =
774 normal_spring_constant * normal_overlap +
775 normal_damping_constant * normal_relative_velocity_value;
776 normal_force = normal_force_value * normal_unit_vector;
780 Tensor<1, 3> damping_tangential_force =
781 tangential_damping_constant * tangential_relative_velocity;
785 damping_tangential_force;
787 double coulomb_threshold = friction_coeff * normal_force_value;
790 if (tangential_force.norm() > coulomb_threshold)
794 const Tensor<1, 3> limited_tangential_force =
796 (tangential_force / (tangential_force.norm() + DBL_MIN));
802 (limited_tangential_force - damping_tangential_force) /
803 (tangential_spring_constant + DBL_MIN);
809 damping_tangential_force;
813 particle_one_tangential_torque =
814 cross_product_3d(normal_unit_vector,
815 tangential_force * diameter_one * 0.5);
816 particle_two_tangential_torque =
817 particle_one_tangential_torque * diameter_two / diameter_one;
822 particle_one_properties,
823 particle_two_properties,
824 rolling_viscous_damping_coeff,
825 rolling_friction_coeff,
827 normal_spring_constant,
861 const Tensor<1, 3> &tangential_relative_velocity,
862 const double normal_relative_velocity_value,
863 const Tensor<1, 3> &normal_unit_vector,
864 const double normal_overlap,
866 const ArrayView<const double> &particle_one_properties,
867 const ArrayView<const double> &particle_two_properties,
868 Tensor<1, 3> &normal_force,
869 Tensor<1, 3> &tangential_force,
870 Tensor<1, 3> &particle_one_tangential_torque,
871 Tensor<1, 3> &particle_two_tangential_torque,
872 Tensor<1, 3> &rolling_resistance_torque)
875 auto [effective_radius, effective_mass] =
877 particle_two_properties);
879 const unsigned int particle_one_type =
880 static_cast<unsigned int>(particle_one_properties[PropertiesIndex::type]);
881 const unsigned int particle_two_type =
882 static_cast<unsigned int>(particle_two_properties[PropertiesIndex::type]);
883 const unsigned int pair_index =
889 const double friction_coeff =
891 const double rolling_viscous_damping_coeff =
893 const double rolling_friction_coeff =
897 const double &diameter_one = particle_one_properties[PropertiesIndex::dp];
898 const double &diameter_two = particle_two_properties[PropertiesIndex::dp];
901 const double radius_times_overlap_sqrt =
902 sqrt(effective_radius * normal_overlap);
903 const double model_parameter_sn =
904 2.0 * youngs_modulus * radius_times_overlap_sqrt;
905 double model_parameter_st = 8.0 * shear_modulus * radius_times_overlap_sqrt;
913 double normal_spring_constant = 0.66665 * model_parameter_sn;
917 double normal_damping_constant =
918 -1.8257 * beta * sqrt(model_parameter_sn * effective_mass);
922 double tangential_spring_constant =
923 8.0 * shear_modulus * radius_times_overlap_sqrt;
928 double tangential_damping_constant =
929 normal_damping_constant * sqrt(model_parameter_st / model_parameter_sn);
932 const double normal_force_value =
933 normal_spring_constant * normal_overlap +
934 normal_damping_constant * normal_relative_velocity_value;
935 normal_force = normal_force_value * normal_unit_vector;
939 Tensor<1, 3> damping_tangential_force =
940 tangential_damping_constant * tangential_relative_velocity;
943 damping_tangential_force;
945 double coulomb_threshold = friction_coeff * normal_force_value;
948 if (tangential_force.norm() > coulomb_threshold)
952 const Tensor<1, 3> limited_tangential_force =
954 (tangential_force / (tangential_force.norm() + DBL_MIN));
960 (limited_tangential_force - damping_tangential_force) /
961 (tangential_spring_constant + DBL_MIN);
967 damping_tangential_force;
971 particle_one_tangential_torque =
972 cross_product_3d(normal_unit_vector,
973 tangential_force * diameter_one * 0.5);
974 particle_two_tangential_torque =
975 particle_one_tangential_torque * diameter_two / diameter_one;
980 particle_one_properties,
981 particle_two_properties,
982 rolling_friction_coeff,
983 rolling_viscous_damping_coeff,
985 normal_spring_constant,
1018 const Tensor<1, 3> &tangential_relative_velocity,
1019 const double normal_relative_velocity_value,
1020 const Tensor<1, 3> &normal_unit_vector,
1021 const double normal_overlap,
1023 const ArrayView<const double> &particle_one_properties,
1024 const ArrayView<const double> &particle_two_properties,
1025 Tensor<1, 3> &normal_force,
1026 Tensor<1, 3> &tangential_force,
1027 Tensor<1, 3> &particle_one_tangential_torque,
1028 Tensor<1, 3> &particle_two_tangential_torque,
1029 Tensor<1, 3> &rolling_resistance_torque)
1032 auto [effective_radius, effective_mass] =
1034 particle_two_properties);
1036 const unsigned int particle_one_type =
1037 static_cast<unsigned int>(particle_one_properties[PropertiesIndex::type]);
1038 const unsigned int particle_two_type =
1039 static_cast<unsigned int>(particle_two_properties[PropertiesIndex::type]);
1040 const unsigned int pair_index =
1046 const double friction_coeff =
1048 const double rolling_viscous_damping_coeff =
1050 const double rolling_friction_coeff =
1054 const double &diameter_one = particle_one_properties[PropertiesIndex::dp];
1055 const double &diameter_two = particle_two_properties[PropertiesIndex::dp];
1058 const double radius_times_overlap_sqrt =
1059 sqrt(effective_radius * normal_overlap);
1060 const double model_parameter_sn =
1061 2.0 * youngs_modulus * radius_times_overlap_sqrt;
1062 double model_parameter_st = 8.0 * shear_modulus * radius_times_overlap_sqrt;
1067 double normal_spring_constant = 0.66665 * model_parameter_sn;
1071 double normal_damping_constant =
1072 -1.8257 * beta * sqrt(model_parameter_sn * effective_mass);
1076 double tangential_spring_constant =
1077 8.0 * shear_modulus * radius_times_overlap_sqrt;
1082 double tangential_damping_constant =
1083 normal_damping_constant * sqrt(model_parameter_st / model_parameter_sn);
1086 const double normal_force_value =
1087 normal_spring_constant * normal_overlap +
1088 normal_damping_constant * normal_relative_velocity_value;
1089 normal_force = normal_force_value * normal_unit_vector;
1093 Tensor<1, 3> damping_tangential_force =
1094 tangential_damping_constant * tangential_relative_velocity;
1097 damping_tangential_force;
1099 double coulomb_threshold = friction_coeff * normal_force_value;
1102 if (tangential_force.norm() > coulomb_threshold)
1108 (tangential_force / (tangential_force.norm() + DBL_MIN));
1112 particle_one_tangential_torque =
1113 cross_product_3d(normal_unit_vector,
1114 tangential_force * diameter_one * 0.5);
1115 particle_two_tangential_torque =
1116 particle_one_tangential_torque * diameter_two / diameter_one;
1121 particle_one_properties,
1122 particle_two_properties,
1123 rolling_friction_coeff,
1124 rolling_viscous_damping_coeff,
1126 normal_spring_constant,
1127 normal_force.norm(),
1158 const Tensor<1, 3> & ,
1159 const double normal_relative_velocity_value,
1160 const Tensor<1, 3> &normal_unit_vector,
1161 const double normal_overlap,
1163 const ArrayView<const double> &particle_one_properties,
1164 const ArrayView<const double> &particle_two_properties,
1165 Tensor<1, 3> &normal_force,
1166 Tensor<1, 3> &tangential_force,
1167 Tensor<1, 3> &particle_one_tangential_torque,
1168 Tensor<1, 3> &particle_two_tangential_torque,
1169 Tensor<1, 3> &rolling_resistance_torque)
1172 auto [effective_radius, effective_mass] =
1174 particle_two_properties);
1176 const unsigned int particle_one_type =
1177 static_cast<unsigned int>(particle_one_properties[PropertiesIndex::type]);
1178 const unsigned int particle_two_type =
1179 static_cast<unsigned int>(particle_two_properties[PropertiesIndex::type]);
1180 const unsigned int pair_index =
1186 const double friction_coeff =
1188 const double rolling_viscous_damping_coeff =
1190 const double rolling_friction_coeff =
1194 const double &diameter_one = particle_one_properties[PropertiesIndex::dp];
1195 const double &diameter_two = particle_two_properties[PropertiesIndex::dp];
1198 const double radius_times_overlap_sqrt =
1199 sqrt(effective_radius * normal_overlap);
1200 const double model_parameter_sn =
1201 2.0 * youngs_modulus * radius_times_overlap_sqrt;
1206 double normal_spring_constant = 0.66665 * model_parameter_sn;
1210 double normal_damping_constant =
1211 -1.8257 * beta * sqrt(model_parameter_sn * effective_mass);
1215 double tangential_spring_constant =
1216 8.0 * shear_modulus * radius_times_overlap_sqrt;
1219 const double normal_force_value =
1220 normal_spring_constant * normal_overlap +
1221 normal_damping_constant * normal_relative_velocity_value;
1222 normal_force = normal_force_value * normal_unit_vector;
1228 double coulomb_threshold = friction_coeff * normal_force_value;
1231 if (tangential_force.norm() > coulomb_threshold)
1237 (tangential_force / (tangential_force.norm() + DBL_MIN));
1241 particle_one_tangential_torque =
1242 cross_product_3d(normal_unit_vector,
1243 tangential_force * diameter_one * 0.5);
1244 particle_two_tangential_torque =
1245 particle_one_tangential_torque * diameter_two / diameter_one;
1250 particle_one_properties,
1251 particle_two_properties,
1252 rolling_friction_coeff,
1253 rolling_viscous_damping_coeff,
1255 normal_spring_constant,
1256 normal_force.norm(),
1286 const Tensor<1, 3> &tangential_relative_velocity,
1287 const double normal_relative_velocity_value,
1288 const Tensor<1, 3> &normal_unit_vector,
1289 const double normal_overlap,
1291 const ArrayView<const double> &particle_one_properties,
1292 const ArrayView<const double> &particle_two_properties,
1293 Tensor<1, 3> &normal_force,
1294 Tensor<1, 3> &tangential_force,
1295 Tensor<1, 3> &particle_one_tangential_torque,
1296 Tensor<1, 3> &particle_two_tangential_torque,
1297 Tensor<1, 3> &rolling_resistance_torque)
1300 auto [effective_radius, effective_mass] =
1302 particle_two_properties);
1304 const unsigned int particle_one_type =
1305 static_cast<unsigned int>(particle_one_properties[PropertiesIndex::type]);
1306 const unsigned int particle_two_type =
1307 static_cast<unsigned int>(particle_two_properties[PropertiesIndex::type]);
1308 const unsigned int pair_index =
1314 const double friction_coeff =
1316 const double rolling_viscous_damping_coeff =
1318 const double rolling_friction_coeff =
1323 const double &diameter_one = particle_one_properties[PropertiesIndex::dp];
1324 const double &diameter_two = particle_two_properties[PropertiesIndex::dp];
1327 const double radius_times_overlap_sqrt =
1328 sqrt(effective_radius * normal_overlap);
1329 const double model_parameter_sn =
1330 2.0 * youngs_modulus * radius_times_overlap_sqrt;
1331 double model_parameter_st = 8.0 * shear_modulus * radius_times_overlap_sqrt;
1336 Utilities::fixed_power<2>(effective_radius * normal_overlap);
1337 const double c1 = -2. * Utilities::fixed_power<2>(effective_radius) * M_PI *
1338 surface_energy / youngs_modulus;
1340 const double c2 = -2. * normal_overlap * effective_radius;
1341 const double P = -Utilities::fixed_power<2>(c2) / 12. - c0;
1342 const double Q = -Utilities::fixed_power<3>(c2) / 108. + c0 * c2 / 3. -
1343 Utilities::fixed_power<2>(c1) * 0.125;
1344 const double root1 =
1345 0.25 * Utilities::fixed_power<2>(Q) + Utilities::fixed_power<3>(P) / 27.;
1346 const double U = std::cbrt(-0.5 * Q + std::sqrt(root1));
1347 const double s = -c2 * (5. / 6.) + U - P / (3. * U);
1348 const double w = std::sqrt(std::max(1e-16, c2 + 2. * s));
1349 const double lambda = 0.5 * c1 / w;
1350 const double root2 = std::max(1e-16, w * w - 4. * (c2 + s + lambda));
1351 const double a = 0.5 * (w + std::sqrt(root2));
1354 const double normal_damping_constant =
1355 -1.8257 * beta * sqrt(model_parameter_sn * effective_mass);
1358 const double tangential_spring_constant =
1359 8.0 * radius_times_overlap_sqrt * shear_modulus;
1361 const double tangential_damping_constant =
1362 normal_damping_constant * sqrt(model_parameter_st / model_parameter_sn);
1365 const double normal_force_coefficient =
1366 4. * Utilities::fixed_power<3>(a) / (3. * effective_radius) *
1368 std::sqrt(8. * M_PI * surface_energy * youngs_modulus *
1369 Utilities::fixed_power<3>(a));
1372 normal_force = (normal_force_coefficient +
1373 normal_damping_constant * normal_relative_velocity_value) *
1378 tangential_damping_constant * tangential_relative_velocity;
1382 const double two_pull_off_force =
1383 3. * M_PI * surface_energy * effective_radius;
1385 const double modified_coulomb_threshold =
1386 (normal_force_coefficient + two_pull_off_force) * friction_coeff;
1388 if (tangential_force.norm() > modified_coulomb_threshold)
1393 modified_coulomb_threshold *
1394 (tangential_force / (tangential_force.norm() + DBL_MIN));
1398 particle_one_tangential_torque =
1399 cross_product_3d(normal_unit_vector,
1400 tangential_force * diameter_one * 0.5);
1401 particle_two_tangential_torque =
1402 particle_one_tangential_torque * diameter_two / diameter_one;
1406 double normal_spring_constant = 0.66665 * model_parameter_sn;
1411 particle_one_properties,
1412 particle_two_properties,
1413 rolling_friction_coeff,
1414 rolling_viscous_damping_coeff,
1416 normal_spring_constant,
1417 normal_force.norm(),
1446 const Tensor<1, 3> &tangential_relative_velocity,
1447 const double normal_relative_velocity_value,
1448 const Tensor<1, 3> &normal_unit_vector,
1449 const double normal_overlap,
1451 const ArrayView<const double> &particle_one_properties,
1452 const ArrayView<const double> &particle_two_properties,
1453 Tensor<1, 3> &normal_force,
1454 Tensor<1, 3> &tangential_force,
1455 Tensor<1, 3> &particle_one_tangential_torque,
1456 Tensor<1, 3> &particle_two_tangential_torque,
1457 Tensor<1, 3> &rolling_resistance_torque)
1459 constexpr double M_2PI = 2. * M_PI;
1462 auto [effective_radius, effective_mass] =
1464 particle_two_properties);
1466 const unsigned int particle_one_type =
1467 static_cast<unsigned int>(particle_one_properties[PropertiesIndex::type]);
1468 const unsigned int particle_two_type =
1469 static_cast<unsigned int>(particle_two_properties[PropertiesIndex::type]);
1470 const unsigned int pair_index =
1474 const double hamaker_constant =
1477 const double F_po = M_2PI * effective_radius * surface_energy;
1479 const double delta_0 =
1480 -std::sqrt(hamaker_constant * effective_radius / (6. * F_po));
1484 double cohesive_term;
1487 if (normal_overlap > 0.)
1489 cohesive_term = -F_po;
1493 tangential_relative_velocity,
1494 normal_relative_velocity_value,
1498 particle_one_properties,
1499 particle_two_properties,
1502 particle_one_tangential_torque,
1503 particle_two_tangential_torque,
1504 rolling_resistance_torque);
1507 else if (normal_overlap > delta_0)
1509 cohesive_term = -F_po;
1517 cohesive_term = -hamaker_constant * effective_radius /
1518 (6. * Utilities::fixed_power<2>(normal_overlap));
1522 normal_force += cohesive_term * normal_unit_vector;
1542 const Tensor<1, 3> &normal_unit_vector,
1543 const double normal_overlap,
1544 const ArrayView<const double> &particle_one_properties,
1545 const ArrayView<const double> &particle_two_properties,
1546 Tensor<1, 3> &normal_displacement)
1548 const double mean_diameter =
1549 0.5 * (particle_one_properties[PropertiesIndex::dp] +
1550 particle_two_properties[PropertiesIndex::dp]);
1554 normal_displacement =
1555 (0.501 * normal_overlap + 0.01 * mean_diameter) * normal_unit_vector;
1602 const double youngs_modulus_i =
1603 properties.youngs_modulus_particle.at(i);
1604 const double poisson_ratio_i = properties.poisson_ratio_particle.at(i);
1605 const double restitution_coefficient_i =
1606 properties.restitution_coefficient_particle.at(i);
1607 const double friction_coefficient_i =
1608 properties.friction_coefficient_particle.at(i);
1609 const double rolling_viscous_damping_coefficient_i =
1610 properties.rolling_viscous_damping_coefficient_particle.at(i);
1611 const double rolling_friction_coefficient_i =
1612 properties.rolling_friction_coefficient_particle.at(i);
1613 const double surface_energy_i =
1614 properties.surface_energy_particle.at(i);
1615 const double hamaker_constant_i =
1616 properties.hamaker_constant_particle.at(i);
1622 const double youngs_modulus_j =
1623 properties.youngs_modulus_particle.at(j);
1624 const double poisson_ratio_j =
1625 properties.poisson_ratio_particle.at(j);
1626 const double restitution_coefficient_j =
1627 properties.restitution_coefficient_particle.at(j);
1628 const double friction_coefficient_j =
1629 properties.friction_coefficient_particle.at(j);
1630 const double rolling_viscous_damping_coefficient_j =
1631 properties.rolling_viscous_damping_coefficient_particle.at(j);
1632 const double rolling_friction_coefficient_j =
1633 properties.rolling_friction_coefficient_particle.at(j);
1634 const double surface_energy_j =
1635 properties.surface_energy_particle.at(j);
1636 const double hamaker_constant_j =
1637 properties.hamaker_constant_particle.at(j);
1640 (youngs_modulus_i * youngs_modulus_j) /
1641 ((youngs_modulus_j * (1.0 - poisson_ratio_i * poisson_ratio_i)) +
1642 (youngs_modulus_i * (1.0 - poisson_ratio_j * poisson_ratio_j)) +
1646 (youngs_modulus_i * youngs_modulus_j) /
1647 (2.0 * ((youngs_modulus_j * (2.0 - poisson_ratio_i) *
1648 (1.0 + poisson_ratio_i)) +
1649 (youngs_modulus_i * (2.0 - poisson_ratio_j) *
1650 (1.0 + poisson_ratio_j))) +
1655 restitution_coefficient_j);
1658 harmonic_mean(friction_coefficient_i, friction_coefficient_j);
1662 rolling_viscous_damping_coefficient_j);
1666 rolling_friction_coefficient_j);
1669 surface_energy_i + surface_energy_j -
1670 std::pow(std::sqrt(surface_energy_i) -
1671 std::sqrt(surface_energy_j),
1675 0.5 * (hamaker_constant_i + hamaker_constant_j);
1677 double restitution_coefficient_particle_log =
1681 restitution_coefficient_particle_log /
1682 sqrt(restitution_coefficient_particle_log *
1683 restitution_coefficient_particle_log +
1712 const double real_youngs_modulus_i =
1713 properties.real_youngs_modulus_particle.at(i);
1714 const double poisson_ratio_i = properties.poisson_ratio_particle.at(i);
1715 const double surface_roughness_i =
1716 properties.surface_roughness_particle.at(i);
1717 const double surface_slope_i = properties.surface_slope_particle.at(i);
1718 const double microhardness_i = properties.microhardness_particle.at(i);
1719 const double thermal_accommodation_i =
1720 properties.thermal_accommodation_particle.at(i);
1724 properties.thermal_conductivity_particle.at(i);
1730 const double real_youngs_modulus_j =
1731 properties.real_youngs_modulus_particle.at(j);
1732 const double poisson_ratio_j =
1733 properties.poisson_ratio_particle.at(j);
1734 const double surface_roughness_j =
1735 properties.surface_roughness_particle.at(j);
1736 const double surface_slope_j =
1737 properties.surface_slope_particle.at(j);
1738 const double microhardness_j =
1739 properties.microhardness_particle.at(j);
1740 const double thermal_accommodation_j =
1741 properties.thermal_accommodation_particle.at(j);
1744 (real_youngs_modulus_i * real_youngs_modulus_j) /
1745 ((real_youngs_modulus_j *
1746 (1.0 - poisson_ratio_i * poisson_ratio_i)) +
1747 (real_youngs_modulus_i *
1748 (1.0 - poisson_ratio_j * poisson_ratio_j)) +
1751 sqrt(surface_roughness_i * surface_roughness_i +
1752 surface_roughness_j * surface_roughness_j);
1754 sqrt(surface_slope_i * surface_slope_i +
1755 surface_slope_j * surface_slope_j);
1759 ((2. - thermal_accommodation_i) / thermal_accommodation_i +
1760 (2. - thermal_accommodation_j) / thermal_accommodation_j) *
1761 (2. * properties.specific_heats_ratio_gas) /
1762 (1. + properties.specific_heats_ratio_gas) *
1763 properties.molecular_mean_free_path_gas /
1764 (properties.dynamic_viscosity_gas * properties.specific_heat_gas /
1765 properties.thermal_conductivity_gas);
1779 template <ContactType contact_type,
typename ContactInfoContainer>
1782 ContactInfoContainer &adjacent_particles_list,
1787 if (adjacent_particles_list.second_particles.empty())
1791 Tensor<1, 3> normal_unit_vector;
1792 Tensor<1, 3> normal_force;
1793 Tensor<1, 3> tangential_force;
1794 Tensor<1, 3> particle_one_tangential_torque;
1795 Tensor<1, 3> particle_two_tangential_torque;
1796 Tensor<1, 3> rolling_resistance_torque;
1797 double normal_relative_velocity_value;
1798 Tensor<1, 3> tangential_relative_velocity;
1803 auto particle_one = adjacent_particles_list.particle_one;
1804 auto particle_one_properties = particle_one->get_properties();
1806 types::particle_index particle_one_id = particle_one->get_local_index();
1807 Tensor<1, 3> &particle_one_torque = contact_outcome.
torque[particle_one_id];
1808 Tensor<1, 3> &particle_one_force = contact_outcome.
force[particle_one_id];
1811 Point<3> particle_one_location =
get_location(particle_one);
1813 for (
auto &&contact_info :
1814 adjacent_particles_list.second_particles | boost::adaptors::map_values)
1818 auto particle_two = contact_info.particle_two;
1819 auto particle_two_properties = particle_two->get_properties();
1822 Point<3> particle_two_location;
1830 if constexpr (contact_type ==
1837 particle_two_location =
1842 double normal_overlap =
1843 0.5 * (particle_one_properties[PropertiesIndex::dp] +
1844 particle_two_properties[PropertiesIndex::dp]) -
1845 particle_one_location.distance(particle_two_location);
1849 const double force_calculation_threshold_distance =
1852 if (normal_overlap > force_calculation_threshold_distance)
1859 if constexpr (contact_type ==
1870 tangential_relative_velocity,
1871 normal_relative_velocity_value,
1873 particle_one_properties,
1874 particle_two_properties,
1875 particle_one_location,
1876 particle_two_location,
1881 tangential_relative_velocity,
1882 normal_relative_velocity_value,
1886 particle_one_properties,
1887 particle_two_properties,
1890 particle_one_tangential_torque,
1891 particle_two_tangential_torque,
1892 rolling_resistance_torque);
1895 if constexpr (contact_type ==
1907 tangential_relative_velocity,
1908 normal_relative_velocity_value,
1910 particle_two_properties,
1911 particle_one_properties,
1912 particle_two_location,
1913 particle_one_location,
1918 tangential_relative_velocity,
1919 normal_relative_velocity_value,
1923 particle_two_properties,
1924 particle_one_properties,
1927 particle_two_tangential_torque,
1928 particle_one_tangential_torque,
1929 rolling_resistance_torque);
1934 if constexpr (contact_type ==
1939 types::particle_index particle_two_id =
1940 particle_two->get_local_index();
1942 Tensor<1, 3> &particle_two_torque =
1943 contact_outcome.
torque[particle_two_id];
1944 Tensor<1, 3> &particle_two_force =
1945 contact_outcome.
force[particle_two_id];
1950 particle_one_tangential_torque,
1951 particle_two_tangential_torque,
1952 rolling_resistance_torque,
1953 particle_one_torque,
1954 particle_two_torque,
1956 particle_two_force);
1961 if constexpr (contact_type ==
1968 particle_one_tangential_torque,
1969 rolling_resistance_torque,
1970 particle_one_torque,
1971 particle_one_force);
1976 if constexpr (contact_type ==
1979 types::particle_index particle_two_id =
1980 particle_two->get_local_index();
1982 Tensor<1, 3> &particle_two_torque =
1983 contact_outcome.
torque[particle_two_id];
1984 Tensor<1, 3> &particle_two_force =
1985 contact_outcome.
force[particle_two_id];
1990 particle_two_tangential_torque,
1991 rolling_resistance_torque,
1992 particle_two_torque,
1993 particle_two_force);
2000 contact_info.tangential_displacement.clear();
2001 contact_info.rolling_resistance_spring_torque.clear();
2006 if (normal_overlap > 0)
2008 const unsigned int particle_one_type =
2009 static_cast<unsigned int>(
2010 particle_one_properties[PropertiesIndex::type]);
2011 const unsigned int particle_two_type =
2012 static_cast<unsigned int>(
2013 particle_two_properties[PropertiesIndex::type]);
2014 const unsigned int pair_index =
2016 const double temperature_one =
2017 particle_one_properties[PropertiesIndex::T];
2018 const double temperature_two =
2019 particle_two_properties[PropertiesIndex::T];
2020 types::particle_index particle_two_id =
2021 particle_two->get_local_index();
2022 double &particle_one_heat_transfer_rate =
2024 double &particle_two_heat_transfer_rate =
2027 double thermal_conductance;
2029 0.5 * particle_one_properties[PropertiesIndex::dp],
2030 0.5 * particle_two_properties[PropertiesIndex::dp],
2041 normal_force.norm(),
2042 thermal_conductance);
2046 if constexpr (contact_type ==
2054 thermal_conductance,
2055 particle_one_heat_transfer_rate,
2056 particle_two_heat_transfer_rate);
2061 if constexpr (contact_type ==
2069 thermal_conductance,
2070 particle_one_heat_transfer_rate);
2075 if constexpr (contact_type ==
2077 ghost_local_periodic_particle_particle)
2082 thermal_conductance,
2083 particle_two_heat_transfer_rate);
double harmonic_mean(const double &value_one, const double &value_two)
Handles all the parameters declared in the parameter handler file.
Parameters::Lagrangian::LagrangianPhysicalProperties lagrangian_physical_properties
Class where the outcomes of particle-particle interactions are stored.
std::vector< double > heat_transfer_rate
std::vector< Tensor< 1, 3 > > force
std::vector< Tensor< 1, 3 > > torque
Base class for the particle-particle contact force models This class does not implement any of the mo...
unsigned int get_number_of_contacts() const
Return the number of contacts that occurred in the present pseudo-time step when using the packed ins...
void reset_number_of_contacts()
Reset the counter of number of contacts for the next pseudo-time step.
void set_periodic_offset(const Tensor< 1, dim > &offset, const types::boundary_id boundary_id)
Set the distance between a principal periodic boundary pb0 (with mesh ID boundary_id) and its associa...
virtual void calculate_particle_particle_contact(typename DEM::dem_data_structures< dim >::adjacent_particle_pairs &local_adjacent_particles, typename DEM::dem_data_structures< dim >::adjacent_particle_pairs &ghost_adjacent_particles, typename DEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs &local_local_periodic_adjacent_particles, typename DEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs &local_ghost_periodic_adjacent_particles, typename DEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs &ghost_local_periodic_adjacent_particles, const double dt, ParticleInteractionOutcomes< PropertiesIndex > &contact_outcome)=0
Calculate the contact outcomes using the contact pair information obtained in the fine search and phy...
std::unordered_map< types::boundary_id, Tensor< 1, dim > > periodic_offsets
Map storing offset distance between periodic boundaries, keyed by the boundary ID (pb0)....
std::vector< double > effective_coefficient_of_rolling_friction
Point< 3 > get_periodic_location(const Particles::ParticleIterator< dim > &particle, const Tensor< 1, dim > &periodic_offset) &
Get the shifted location of a particle on a periodic boundary.
std::vector< double > effective_youngs_modulus
void calculate_hertz_mindlin_limit_force_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &tangential_relative_velocity, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle non-linear contact force and torque based on the updated values in co...
void execute_contact_calculation(ContactInfoContainer &adjacent_particles_list, const double dt, ParticleInteractionOutcomes< PropertiesIndex > &contact_outcome)
Execute the contact calculation step for the particle-particle contact according to the contact type.
void calculate_DMT_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &tangential_relative_velocity, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle contact and cohesive forces and contact torque based on the updated v...
double thermal_conductivity_gas
void calculate_hertz_JKR_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &tangential_relative_velocity, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle contact and cohesive forces and contact torque based on the updated v...
unsigned int n_particle_types
std::vector< double > equivalent_surface_slope
void calculate_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &tangential_relative_velocity, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle contact force and torque according to the contact model.
std::vector< double > effective_shear_modulus
double get_force_calculation_threshold_distance()
Calculate the minimum overlap at which particle-particle forces are computed.
std::vector< double > effective_surface_energy
void set_multiphysic_properties(const DEMSolverParameters< dim > &dem_parameters)
Set every container needed to carry the heat transfer rate calculation.
std::tuple< double, double > find_effective_radius_and_mass(const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties)
Calculate the effective mass and the effective radius of the particle pair.
void calculate_hertz_mindlin_limit_overlap_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &tangential_relative_velocity, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle non-linear contact force and torque based on the updated values in co...
const double f_coefficient_epsd
std::vector< double > thermal_conductivity_particle
std::vector< double > model_parameter_beta
Point< 3 > get_location(const Particles::ParticleIterator< dim > &particle) &
Get the location of the particle.
void calculate_linear_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &tangential_relative_velocity, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle linear contact force and torque based on the updated values in contac...
virtual void calculate_particle_particle_contact(typename DEM::dem_data_structures< dim >::adjacent_particle_pairs &local_adjacent_particles, typename DEM::dem_data_structures< dim >::adjacent_particle_pairs &ghost_adjacent_particles, typename DEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs &local_local_periodic_adjacent_particles, typename DEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs &local_ghost_periodic_adjacent_particles, typename DEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs &ghost_local_periodic_adjacent_particles, const double dt, ParticleInteractionOutcomes< PropertiesIndex > &contact_outcome) override
Calculate the contact outcomes using the contact pair information obtained in the fine search and phy...
void calculate_hertz_contact(particle_particle_contact_info< dim > &contact_info, const Tensor< 1, 3 > &, const double normal_relative_velocity_value, const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const double dt, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_force, Tensor< 1, 3 > &tangential_force, Tensor< 1, 3 > &particle_one_tangential_torque, Tensor< 1, 3 > &particle_two_tangential_torque, Tensor< 1, 3 > &rolling_resistance_torque)
Calculate the particle-particle non-linear contact force and torque based on the updated values in co...
std::vector< double > gas_parameter_m
void calculate_shift_displacement(const Tensor< 1, 3 > &normal_unit_vector, const double normal_overlap, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, Tensor< 1, 3 > &normal_displacement)
Calculate the displacement that separates two overlapping particles. This "contact force" model is us...
std::vector< double > effective_rolling_viscous_damping_coefficient
std::vector< double > effective_microhardness
void update_contact_information(particle_particle_contact_info< dim > &contact_info, Tensor< 1, 3 > &tangential_relative_velocity, double &normal_relative_velocity_value, Tensor< 1, 3 > &normal_unit_vector, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, const Point< 3 > &particle_one_location, const Point< 3 > &particle_two_location, const double dt)
Update the contact pair information for all contact force calculations.
std::vector< double > effective_real_youngs_modulus
std::vector< double > equivalent_surface_roughness
ParticleParticleContactForce(const DEMSolverParameters< dim > &dem_parameters)
Tensor< 1, 3 > calculate_rolling_resistance_torque(const double effective_radius, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, const double rolling_friction_coeff, const double rolling_viscous_damping_coeff, const double dt, const double normal_spring_constant, const double normal_force_norm, const Tensor< 1, 3 > &normal_unit_vector, Tensor< 1, 3 > &cumulative_rolling_resistance_spring_torque)
Calculate the rolling resistance torque acting on the particles according to the rolling resistance m...
unsigned int vec_particle_type_index(const unsigned int i, const unsigned int j) const
Return the index to access the property vectors for a given combination of particle types.
void set_effective_properties(const DEMSolverParameters< dim > &dem_parameters)
Set every container needed to carry the particle-particle force calculation.
std::vector< double > effective_hamaker_constant
void apply_force_and_torque_on_local_particles(const Tensor< 1, 3 > &normal_force, const Tensor< 1, 3 > &tangential_force, const Tensor< 1, 3 > &particle_one_tangential_torque, const Tensor< 1, 3 > &particle_two_tangential_torque, const Tensor< 1, 3 > &rolling_resistance_torque, Tensor< 1, 3 > &particle_one_torque, Tensor< 1, 3 > &particle_two_torque, Tensor< 1, 3 > &particle_one_force, Tensor< 1, 3 > &particle_two_force)
Apply the calculated force and torque on the local-local particle pair in contact.
virtual ~ParticleParticleContactForce()=default
const double dmt_cut_off_threshold
std::vector< double > effective_coefficient_of_restitution
void apply_force_and_torque_on_single_local_particle(const Tensor< 1, 3 > &normal_force, const Tensor< 1, 3 > &tangential_force, const Tensor< 1, 3 > &particle_one_tangential_torque, const Tensor< 1, 3 > &rolling_resistance_torque, Tensor< 1, 3 > &particle_one_torque, Tensor< 1, 3 > &particle_one_force)
Apply the calculated force and torque on the local-ghost particle pair in contact....
std::vector< double > effective_coefficient_of_friction
constexpr bool has_thermal_properties
Whether a properties index set carries thermal properties.
ParticleParticleContactForceModel
Contact force model for particle-particle interactions.
@ hertz_JKR
Hertz model with Johnson-Kendall-Roberts cohesive force.
@ hertz_mindlin_limit_force
Hertz-Mindlin model with a limitation on tangential force.
@ DMT
Derjaguin-Muller-Toporov model.
RollingResistanceMethod
Method used to compute the rolling resistance torque.
@ epsd
Elastic-plastic spring-dashpot.
@ viscous
Viscous rolling resistance.
@ constant
Constant rolling resistance.
@ none
No rolling resistance.
void apply_heat_transfer_on_local_particles(const double temperature_one, const double temperature_two, const double thermal_conductance, double &particle_one_heat_transfer_rate, double &particle_two_heat_transfer_rate)
Apply the heat transfer to a local-local particle pair in contact.
void calculate_contact_thermal_conductance(const double radius_one, const double radius_two, const double effective_youngs_modulus, const double effective_real_youngs_modulus, const double equivalent_surface_roughness, const double equivalent_surface_slope, const double effective_microhardness, const double thermal_conductivity_one, const double thermal_conductivity_two, const double thermal_conductivity_gas, const double gas_parameter_m, const double normal_overlap, const double normal_force_norm, double &thermal_conductance)
Calculate the total thermal conductance for particle-particle or particle-wall contacts.
void apply_heat_transfer_on_single_local_particle(const double temperature_one, const double temperature_two, const double thermal_conductance, double &particle_one_heat_transfer_rate)
Apply the heat transfer to a local particle. This function is used for local-ghost particle pairs or ...
Tensor< 1, 3 > viscous_rolling_resistance_torque(const double effective_r, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, const double effective_rolling_friction_coefficient, const double normal_force_norm, const Tensor< 1, 3 > &normal_unit_vector)
Calculation of the viscous rolling resistance torque model using the information obtained from the fi...
Tensor< 1, 3 > epsd_rolling_resistance_torque(const double effective_r, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, const double effective_rolling_friction_coefficient, const double effective_rolling_viscous_damping_coefficient, const double f_coefficient, const double normal_force_norm, const double dt, const double normal_spring_constant, const Tensor< 1, 3 > &normal_unit_vector, Tensor< 1, 3 > &cumulative_rolling_resistance_spring_torque)
Tensor< 1, 3 > constant_rolling_resistance_torque(const double effective_r, const ArrayView< const double > &particle_one_properties, const ArrayView< const double > &particle_two_properties, const double effective_rolling_friction_coefficient, const double normal_force_norm)
Calculation of the constant rolling resistance torque model using the information obtained from the f...
Tensor< 1, 3 > no_rolling_resistance_torque()
No rolling resistance torque model. No calculation is being done with this model.
ankerl::unordered_dense::map< types::particle_index, periodic_adjacent_particle_pairs_value > periodic_adjacent_particle_pairs
ankerl::unordered_dense::map< types::particle_index, adjacent_particle_pairs_value > adjacent_particle_pairs
Handle the information related to the calculation of the particle-particle contact force....
Tensor< 1, 3 > tangential_displacement
Tensor< 1, 3 > rolling_resistance_spring_torque
Point< 3 > point_nd_to_3d(const Point< dim > &point)