7#include <deal.II/base/patterns.h>
8#include <deal.II/base/point.h>
9#include <deal.II/base/tensor.h>
11#include <deal.II/grid/grid_in.h>
23 deprecated_distribution_weighting_type_names = {
30 deprecated_rolling_resistance_method_names = {
40 const std::vector<ParticleParticleContactForceModel>
41 allowed_particle_particle_contact_force_models = {
53 const std::vector<ParticleWallContactForceModel>
54 allowed_particle_wall_contact_force_models = {
63 ParameterHandler &prm)
const
65 prm.enter_subsection(
"lagrangian physical properties");
67 prm.declare_entry(
"g",
68 Patterns::Tools::Convert<Tensor<1, 3>>::to_string(
g),
69 Patterns::List(Patterns::Double(), 2, 3),
70 "Gravitational acceleration vector");
72 prm.declare_entry(
"number of particle types",
73 Patterns::Tools::Convert<unsigned int>::to_string(
76 "Number of particle types");
81 prm.enter_subsection(
"particle type " +
82 Utilities::int_to_string(counter, 1));
86 prm.leave_subsection();
89 prm.declare_entry(
"young modulus wall",
90 Patterns::Tools::Convert<double>::to_string(
93 "Young's modulus of wall");
94 prm.declare_entry(
"poisson ratio wall",
95 Patterns::Tools::Convert<double>::to_string(
98 "Poisson's ratio of wall");
99 prm.declare_entry(
"restitution coefficient wall",
100 Patterns::Tools::Convert<double>::to_string(
103 "Coefficient of restitution of wall");
104 prm.declare_entry(
"friction coefficient wall",
105 Patterns::Tools::Convert<double>::to_string(
108 "Friction coefficient of wall");
109 prm.declare_entry(
"rolling friction wall",
110 Patterns::Tools::Convert<double>::to_string(
113 "Rolling friction coefficient of wall");
114 prm.declare_entry(
"rolling viscous damping wall",
115 Patterns::Tools::Convert<double>::to_string(
118 "Rolling viscous damping wall");
119 prm.declare_entry(
"surface energy wall",
120 Patterns::Tools::Convert<double>::to_string(
123 "Surface energy of wall");
124 prm.declare_entry(
"hamaker constant wall",
125 Patterns::Tools::Convert<double>::to_string(
128 "Hamaker constant of wall");
129 prm.declare_entry(
"thermal conductivity wall",
130 Patterns::Tools::Convert<double>::to_string(
133 "Thermal conductivity of wall");
134 prm.declare_entry(
"microhardness wall",
135 Patterns::Tools::Convert<double>::to_string(
138 "Microhardness of wall");
139 prm.declare_entry(
"surface slope wall",
140 Patterns::Tools::Convert<double>::to_string(
143 "Surface slope of wall");
144 prm.declare_entry(
"surface roughness wall",
145 Patterns::Tools::Convert<double>::to_string(
148 "Surface roughness of wall");
149 prm.declare_entry(
"thermal accommodation wall",
150 Patterns::Tools::Convert<double>::to_string(
153 "Thermal accommodation of wall");
154 prm.declare_entry(
"real young modulus wall",
155 Patterns::Tools::Convert<double>::to_string(
158 "Real Young's modulus of wall");
160 prm.declare_entry(
"thermal conductivity gas",
161 Patterns::Tools::Convert<double>::to_string(
164 "Thermal conductivity of interstitial gas");
165 prm.declare_entry(
"specific heat gas",
166 Patterns::Tools::Convert<double>::to_string(
169 "Specific heat of interstitial gas");
170 prm.declare_entry(
"dynamic viscosity gas",
171 Patterns::Tools::Convert<double>::to_string(
174 "Dynamic viscosity of interstitial gas");
175 prm.declare_entry(
"specific heats ratio gas",
176 Patterns::Tools::Convert<double>::to_string(
179 "Specific heats ratio of interstitial gas");
180 prm.declare_entry(
"molecular mean free path gas",
181 Patterns::Tools::Convert<double>::to_string(
184 "Molecular mean free path of interstitial gas");
186 prm.leave_subsection();
192 prm.enter_subsection(
"lagrangian physical properties");
224 std::vector<std::string> vector_of_string(
225 Utilities::split_string_list(prm.get(
"g")));
226 std::vector<double> vector_of_double =
227 Utilities::string_to_double(vector_of_string);
229 if (vector_of_double.size() == 2)
230 vector_of_double.push_back(0.);
232 for (
unsigned int i = 0; i < 3; ++i)
233 g[i] = vector_of_double[i];
239 prm.enter_subsection(
"particle type " +
240 Utilities::int_to_string(
id, 1));
242 prm.leave_subsection();
248 prm.get_double(
"restitution coefficient wall");
252 prm.get_double(
"rolling viscous damping wall");
271 prm.get_double(
"molecular mean free path gas");
273 prm.leave_subsection();
281 "size distribution type",
283 "Particle size distribution.");
286 prm.declare_entry(
"average diameter",
288 Patterns::Double(0.),
289 "Particle diameter.");
291 prm.declare_alias(
"average diameter",
"diameter",
false);
292 prm.declare_entry(
"standard deviation",
294 Patterns::Double(0.),
295 "Particle size standard deviation.");
298 prm.declare_entry(
"custom distribution from file",
301 "Indicates whether the diameter and probability "
302 "values are extracted from a file.");
303 prm.declare_entry(
"custom distribution filename",
304 "custom_distribution.txt",
305 Patterns::FileName(),
306 "Indicates the file where the custom distribution "
307 "values should be read from.");
309 "custom distribution probability function type",
311 "Particle size distribution.");
312 prm.declare_entry(
"custom distribution interpolation",
315 "Indicates whether the sampling using the custom "
316 "distribution should be interpolated.");
318 prm.declare_entry(
"custom distribution diameters values",
320 Patterns::List(Patterns::Double(0.)),
321 "Diameter values for a custom distribution");
322 prm.declare_alias(
"custom distribution diameters values",
326 "custom distribution diameters probabilities",
328 Patterns::List(Patterns::Double(0.)),
329 "Probabilities associated with each diameter values for "
330 "a custom distribution. ");
334 "distribution weighting basis",
336 "Weighting basis for the size distribution.",
337 deprecated_distribution_weighting_type_names);
338 prm.declare_entry(
"distribution prn seed",
341 "Seed for generation of random numbers"
342 " for the size distribution");
343 prm.declare_alias(
"distribution prn seed",
344 "random seed distribution",
346 prm.declare_entry(
"minimum diameter cutoff",
349 "Minimum cutoff value when sampling a distribution. "
350 "If equal to -1., the cutoff will be fixed at "
351 "0.1% of the cumulative density function of the "
353 prm.declare_entry(
"maximum diameter cutoff",
356 "Maximum cutoff value when sampling a distribution. "
357 "If equal to -1., the cutoff will be fixed at "
358 "99.9% of the cumulative density function of the "
362 prm.declare_entry(
"number of particles",
364 Patterns::Integer(0),
365 "Number of particles of this type");
366 prm.declare_entry(
"density particles",
370 prm.declare_entry(
"young modulus particles",
373 "Particle Young's modulus");
374 prm.declare_entry(
"poisson ratio particles",
376 Patterns::Double(0.),
377 "Particle Poisson ratio");
378 prm.declare_entry(
"restitution coefficient particles",
380 Patterns::Double(0., 1.),
381 "Particle restitution coefficient");
382 prm.declare_entry(
"friction coefficient particles",
384 Patterns::Double(0.),
385 "Particle friction coefficient");
386 prm.declare_entry(
"rolling viscous damping particles",
388 Patterns::Double(0.),
389 "Particle rolling viscous damping");
390 prm.declare_entry(
"rolling friction particles",
392 Patterns::Double(0.),
393 "Particle rolling friction");
394 prm.declare_entry(
"surface energy particles",
396 Patterns::Double(0.),
397 "Particle surface energy");
398 prm.declare_entry(
"hamaker constant particles",
400 Patterns::Double(0.),
401 "Material Hamaker constant");
402 prm.declare_entry(
"thermal conductivity particles",
405 "Particle thermal conductivity");
406 prm.declare_entry(
"specific heat particles",
409 "Particle specific heat");
410 prm.declare_entry(
"microhardness particles",
413 "Particle microhardness");
414 prm.declare_entry(
"surface slope particles",
417 "Particle surface slope");
418 prm.declare_entry(
"surface roughness particles",
421 "Particle surface roughness");
422 prm.declare_entry(
"thermal accommodation particles",
425 "Particle thermal accommodation");
426 prm.declare_entry(
"real young modulus particles",
429 "Particle real Young's modulus");
434 const unsigned int &particle_type,
435 const ParameterHandler &prm)
439 prm.get(
"size distribution type")));
447 prm.get_bool(
"custom distribution from file"));
449 prm.get(
"custom distribution filename"));
453 prm.get(
"custom distribution probability function type")));
456 prm.get_bool(
"custom distribution interpolation"));
459 prm,
"custom distribution diameters values"));
462 prm,
"custom distribution diameters probabilities"));
467 prm.get(
"distribution weighting basis"),
468 deprecated_distribution_weighting_type_names,
469 "distribution weighting basis"));
472 prm.get_integer(
"distribution prn seed"));
477 number.push_back(prm.get_integer(
"number of particles"));
480 prm.get_double(
"young modulus particles"));
482 prm.get_double(
"poisson ratio particles"));
484 prm.get_double(
"restitution coefficient particles"));
486 prm.get_double(
"friction coefficient particles"));
488 prm.get_double(
"rolling viscous damping particles"));
490 prm.get_double(
"rolling friction particles"));
492 prm.get_double(
"surface energy particles"));
494 prm.get_double(
"hamaker constant particles"));
496 prm.get_double(
"thermal conductivity particles"));
498 prm.get_double(
"specific heat particles"));
500 prm.get_double(
"microhardness particles"));
502 prm.get_double(
"surface slope particles"));
504 prm.get_double(
"surface roughness particles"));
506 prm.get_double(
"thermal accommodation particles"));
508 prm.get_double(
"real young modulus particles"));
523 std::vector<SizeDistributionType> &dist_types,
524 std::vector<double> &p_average_diameter,
525 std::vector<double> &p_size_std,
526 std::vector<bool> &custom_dist_read_from_file,
527 std::vector<std::string> &custom_dist_file_names,
528 std::vector<ProbabilityFunctionType> &custom_function_type,
529 std::vector<bool> &custom_interpolation,
530 std::vector<std::vector<double>> &custom_diameter_values,
531 std::vector<std::vector<double>> &custom_probabilities_values,
532 std::vector<DistributionWeightingType> &distribution_weighting_basis_type,
533 std::vector<unsigned int> &seed_for_dist,
534 std::vector<double> &dia_min_cutoff,
535 std::vector<double> &dia_max_cutoff,
536 std::vector<int> &p_number,
537 std::vector<double> &p_density,
538 std::vector<double> &p_youngs_modulus,
539 std::vector<double> &p_poisson_ratio,
540 std::vector<double> &p_restitution_coefficient,
541 std::vector<double> &p_friction_coefficient,
542 std::vector<double> &p_rolling_viscous_damping_coefficient,
543 std::vector<double> &p_rolling_friction_coefficient,
544 std::vector<double> &p_surface_energy,
545 std::vector<double> &p_hamaker_constant,
546 std::vector<double> &p_thermal_conductivity,
547 std::vector<double> &p_specific_heat,
548 std::vector<double> &p_microhardness,
549 std::vector<double> &p_surface_slope,
550 std::vector<double> &p_surface_roughness,
551 std::vector<double> &p_thermal_accommodation,
552 std::vector<double> &p_real_youngs_modulus)
const
573 p_rolling_viscous_damping_coefficient.reserve(
592 prm.enter_subsection(
"insertion info");
597 "Choosing insertion method.");
598 prm.declare_entry(
"inserted number of particles at each time step",
599 Patterns::Tools::Convert<unsigned int>::to_string(
602 "Inserted number of particles at each time step");
603 prm.declare_entry(
"insertion frequency",
604 Patterns::Tools::Convert<int>::to_string(
607 "Insertion frequency");
612 Patterns::Tools::Convert<bool>::to_string(
615 "State whether particles should be cleared on insertion.");
618 "removal box points coordinates",
619 Patterns::Tools::Convert<Point<3>>::to_string(
622 Patterns::Tools::Convert<Point<3>>::to_string(
625 Patterns::List(Patterns::Double(), 2, 3,
","), 2, 2,
":"),
626 "Coordinates of two points for the removal box (x1, y1, z1 : x2, y2, z2)");
630 "list of input files",
631 Patterns::Tools::Convert<std::vector<std::string>>::to_string(
633 Patterns::List(Patterns::FileName()),
634 "The file name from which we load the particles");
637 prm.declare_entry(
"insertion plane point",
638 Patterns::Tools::Convert<Point<3>>::to_string(
640 Patterns::List(Patterns::Double()),
641 "Insertion plane point location");
642 prm.declare_entry(
"insertion plane normal vector",
643 Patterns::Tools::Convert<Tensor<1, 3>>::to_string(
645 Patterns::List(Patterns::Double()),
646 "Insertion plane normal vector");
651 Patterns::Tools::Convert<std::vector<double>>::to_string(
653 Patterns::List(Patterns::Double()),
654 "List of particles x positions");
657 Patterns::Tools::Convert<std::vector<double>>::to_string(
659 Patterns::List(Patterns::Double()),
660 "List of particles y positions");
663 Patterns::Tools::Convert<std::vector<double>>::to_string(
665 Patterns::List(Patterns::Double()),
666 "List of particles z positions");
669 Patterns::Tools::Convert<std::vector<double>>::to_string(
671 Patterns::List(Patterns::Double()),
672 "List of initial velocities x");
675 Patterns::Tools::Convert<std::vector<double>>::to_string(
677 Patterns::List(Patterns::Double()),
678 "List of initial velocities y");
681 Patterns::Tools::Convert<std::vector<double>>::to_string(
683 Patterns::List(Patterns::Double()),
684 "List of initial velocities z");
687 Patterns::Tools::Convert<std::vector<double>>::to_string(
689 Patterns::List(Patterns::Double()),
690 "List of initial omega x");
693 Patterns::Tools::Convert<std::vector<double>>::to_string(
695 Patterns::List(Patterns::Double()),
696 "List of initial omega y");
699 Patterns::Tools::Convert<std::vector<double>>::to_string(
701 Patterns::List(Patterns::Double()),
702 "List of initial omega z");
705 Patterns::Tools::Convert<std::vector<double>>::to_string(
707 Patterns::List(Patterns::Double()),
708 "List of diameters");
711 Patterns::Tools::Convert<std::vector<double>>::to_string(
713 Patterns::List(Patterns::Double()),
714 "List of initial temperatures");
717 "insertion direction sequence",
718 Patterns::Tools::Convert<std::vector<unsigned int>>::to_string(
720 Patterns::List(Patterns::Integer(0, dim - 1), dim, dim),
721 "Direction of particle insertion for the volume "
722 "insertion method.");
724 "insertion box points coordinates",
725 Patterns::Tools::Convert<Point<3>>::to_string(
728 Patterns::Tools::Convert<Point<3>>::to_string(
731 Patterns::List(Patterns::Double(), 2, 3,
","), 2, 2,
":"),
732 "Coordinates of two points for the insertion box (x1, y1, z1 : x2, y2, z2)");
733 prm.declare_entry(
"insertion distance threshold",
734 Patterns::Tools::Convert<double>::to_string(
737 "Distance threshold");
742 auto insertion_acceptance_function_parsed =
743 std::make_shared<Functions::ParsedFunction<dim>>(1);
744 prm.enter_subsection(
"insertion acceptance function");
746 insertion_acceptance_function_parsed->declare_parameters(prm, 1,
"1");
748 prm.leave_subsection();
752 "insertion maximum offset",
753 Patterns::Tools::Convert<double>::to_string(
756 "Maximum position offset when insertion of particles");
759 "insertion prn seed",
762 "Pseudo-random number seed used to generate the position offsets");
763 prm.declare_entry(
"initial velocity",
764 Patterns::Tools::Convert<Tensor<1, 3>>::to_string(
766 Patterns::List(Patterns::Double()),
767 "Initial velocity (x, y, z)");
768 prm.declare_entry(
"initial angular velocity",
769 Patterns::Tools::Convert<Tensor<1, 3>>::to_string(
771 Patterns::List(Patterns::Double()),
772 "Initial angular velocity (x, y, z)");
775 auto initial_temperature_function_parsed =
776 std::make_shared<Functions::ParsedFunction<dim>>(1);
777 prm.enter_subsection(
"initial temperature function");
779 initial_temperature_function_parsed->declare_parameters(prm, 1);
781 prm.leave_subsection();
783 prm.leave_subsection();
790 prm.enter_subsection(
"insertion info");
795 prm.get_integer(
"inserted number of particles at each time step");
801 const std::vector<std::string> removal_box_point_coordinates_list(
802 Utilities::split_string_list(
803 prm.get(
"removal box points coordinates"),
":"));
805 std::vector<double> removal_point_coord_temp_1 =
806 Utilities::string_to_double(Utilities::split_string_list(
807 removal_box_point_coordinates_list.at(0)));
808 std::vector<double> removal_point_coord_temp_2 =
809 Utilities::string_to_double(Utilities::split_string_list(
810 removal_box_point_coordinates_list.at(1)));
812 if (removal_point_coord_temp_1.size() == 2 &&
813 removal_point_coord_temp_2.size() == 2)
815 removal_point_coord_temp_1.push_back(0.);
816 removal_point_coord_temp_2.push_back(0.);
819 for (
unsigned int i = 0; i < 3; ++i)
888 const std::vector<int> axis_order =
895 std::array<bool, dim> axis_seen{};
897 for (
int d = 0; d < dim; ++d)
904 "Invalid insertion directions: axis index out of range for the volume insertion box."));
909 "Invalid insertion directions: an axis is present more than once"));
911 axis_seen[axis] =
true;
914 const std::vector<std::string> point_coordinates_list(
915 Utilities::split_string_list(
916 prm.get(
"insertion box points coordinates"),
":"));
918 std::vector<double> point_coord_temp_1 = Utilities::string_to_double(
919 Utilities::split_string_list(point_coordinates_list.at(0)));
920 std::vector<double> point_coord_temp_2 = Utilities::string_to_double(
921 Utilities::split_string_list(point_coordinates_list.at(1)));
923 if (point_coord_temp_1.size() == 2 && point_coord_temp_2.size() == 2)
925 point_coord_temp_1.push_back(0.);
926 point_coord_temp_2.push_back(0.);
928 for (
int i = 0; i < 3; ++i)
941 auto initial_temperature_function_parsed =
942 std::make_shared<Functions::ParsedFunction<dim>>(1);
943 prm.enter_subsection(
"initial temperature function");
945 initial_temperature_function_parsed->parse_parameters(prm);
948 prm.leave_subsection();
950 auto insertion_acceptance_function =
951 std::make_shared<Functions::ParsedFunction<dim>>(1);
953 prm.enter_subsection(
"insertion acceptance function");
955 insertion_acceptance_function->parse_parameters(prm);
957 prm.leave_subsection();
960 prm.leave_subsection();
968 prm.enter_subsection(
"model parameters");
970 prm.enter_subsection(
"load balancing");
973 "load balance method",
975 "Choosing load-balance method.");
979 Patterns::Tools::Convert<unsigned int>::to_string(
982 "Step at which the triangulation is repartitioned "
983 "and load is balanced for single-step load-balancing");
987 Patterns::Tools::Convert<unsigned int>::to_string(
990 "Frequency at which the triangulation is repartitioned "
991 "and load is balanced for frequent load-balancing");
993 prm.declare_entry(
"threshold",
994 Patterns::Tools::Convert<double>::to_string(
997 "Threshold for dynamic load-balancing");
999 prm.declare_entry(
"dynamic check frequency",
1000 Patterns::Tools::Convert<unsigned int>::to_string(
1002 Patterns::Integer(),
1003 "Checking frequency for dynamic load-balancing");
1006 auto cell_weight_function_parsed =
1007 std::make_shared<Functions::ParsedFunction<dim>>(1);
1008 prm.enter_subsection(
"cell weight function");
1010 cell_weight_function_parsed->declare_parameters(prm, 1,
"1000");
1012 prm.leave_subsection();
1016 Patterns::Tools::Convert<unsigned int>::to_string(
1018 Patterns::Integer(),
1019 "The particle weight based on a default cell weight of 1000");
1022 "active weight factor",
1023 Patterns::Tools::Convert<double>::to_string(
1026 "Factor applied on the particle weight in load balancing if the cell is active");
1029 "inactive weight factor",
1030 Patterns::Tools::Convert<double>::to_string(
1033 "Factor applied on the particle weight in load balancing if the cell is inactive");
1035 prm.leave_subsection();
1037 prm.enter_subsection(
"contact detection");
1040 "contact detection method",
1042 "Choosing contact detection method.");
1044 prm.declare_entry(
"frequency",
1045 Patterns::Tools::Convert<unsigned int>::to_string(
1047 Patterns::Integer(),
1048 "Particle-particle contact list");
1051 "dynamic contact search size coefficient",
1052 Patterns::Tools::Convert<double>::to_string(
1055 "Security coefficient for dynamic contact detection");
1058 "neighborhood threshold",
1059 Patterns::Tools::Convert<double>::to_string(
1062 "Contact search zone diameter to particle diameter ratio");
1064 prm.leave_subsection();
1067 "particle particle contact force method",
1069 "Choosing particle-particle contact force model.",
1071 allowed_particle_particle_contact_force_models);
1074 "particle wall contact force method",
1076 "Choosing particle-wall contact force model.",
1078 allowed_particle_wall_contact_force_models);
1081 "dmt cut-off threshold",
1082 Patterns::Tools::Convert<double>::to_string(
1085 "Cut-off threshold above which the Van der Waal forces are "
1086 "ignored for the DMT model relative to the pull-off force");
1089 "rolling resistance torque method",
1091 "Choosing rolling resistance torque model.",
1092 deprecated_rolling_resistance_method_names);
1096 Patterns::Tools::Convert<double>::to_string(
1099 "Model parameter for the EPSD rolling resistance model.");
1102 "integration method",
1104 "Choosing integration method.");
1109 "Choosing solver type.");
1111 prm.enter_subsection(
"adaptive sparse contacts");
1114 "enable adaptive sparse contacts",
1115 Patterns::Tools::Convert<bool>::to_string(
1118 "Enable the dynamic search for sparse particle contacts. "
1119 "Choices are <true|false>.");
1122 "enable particle advection",
1123 Patterns::Tools::Convert<bool>::to_string(
1126 "Enable the advection of particles with hydrodynamic forces. "
1127 "Choices are <true|false>.");
1130 "granular temperature threshold",
1131 Patterns::Tools::Convert<double>::to_string(
1134 "Minimum granular temperature where particle contacts are considered");
1137 "solid fraction threshold",
1138 Patterns::Tools::Convert<double>::to_string(
1141 "Maximum solid fraction where particle contacts are considered "
1142 "no matter the granular temperature");
1144 prm.leave_subsection();
1146 prm.declare_entry(
"disable position integration",
1147 Patterns::Tools::Convert<bool>::to_string(
1150 "Disable the integration of position and velocity. "
1151 "Choices are <true|false>.");
1153 prm.leave_subsection();
1160 prm.enter_subsection(
"model parameters");
1162 prm.enter_subsection(
"adaptive sparse contacts");
1165 prm.get_bool(
"enable adaptive sparse contacts");
1170 prm.get_double(
"granular temperature threshold");
1173 prm.leave_subsection();
1175 prm.enter_subsection(
"load balancing");
1187 "The load balance method dynamic_with_sparse_contacts requires "
1188 "adaptive sparse contacts to be enabled. Enable adaptive sparse "
1189 "contacts or use the dynamic load balance method instead."));
1195 prm.get_integer(
"dynamic check frequency");
1200 prm.get_double(
"inactive weight factor");
1201 auto cell_weight_function_parsed =
1202 std::make_shared<Functions::ParsedFunction<dim>>(1);
1204 prm.enter_subsection(
"cell weight function");
1206 cell_weight_function_parsed->parse_parameters(prm);
1210 prm.leave_subsection();
1213 prm.leave_subsection();
1215 prm.enter_subsection(
"contact detection");
1219 prm.get_double(
"dynamic contact search size coefficient");
1223 prm.get(
"contact detection method"));
1225 prm.leave_subsection();
1229 prm.get(
"particle particle contact force method"));
1233 prm.get(
"particle wall contact force method"));
1238 prm.get(
"rolling resistance torque method"),
1239 deprecated_rolling_resistance_method_names,
1240 "rolling resistance torque method");
1252 prm.get_bool(
"disable position integration");
1254 prm.leave_subsection();
1261 prm.enter_subsection(
"boundary forces");
1262 prm.declare_entry(
"calculation",
1263 Patterns::Tools::Convert<bool>::to_string(
1266 "Enable calculation of forces");
1271 "State whether output from solver runs should be printed.",
1274 prm.declare_entry(
"filename",
1276 Patterns::FileName(),
1277 "File output force prefix");
1278 prm.declare_entry(
"output frequency",
1279 Patterns::Tools::Convert<unsigned int>::to_string(
1281 Patterns::Integer(),
1282 "Output frequency");
1283 prm.enter_subsection(
"center of mass coordinate");
1284 prm.declare_entry(
"x",
1285 Patterns::Tools::Convert<double>::to_string(
1288 "X coordinate of center of mass");
1289 prm.declare_entry(
"y",
1290 Patterns::Tools::Convert<double>::to_string(
1293 "Y coordinate of center of mass");
1294 prm.declare_entry(
"z",
1295 Patterns::Tools::Convert<double>::to_string(
1298 "Z coordinate of center of mass");
1299 prm.leave_subsection();
1301 prm.leave_subsection();
1308 prm.enter_subsection(
"boundary forces");
1316 prm.enter_subsection(
"center of mass coordinate");
1320 prm.leave_subsection();
1321 prm.leave_subsection();
1328 prm.enter_subsection(
"floating walls");
1330 prm.declare_entry(
"number of floating walls",
1331 Patterns::Tools::Convert<unsigned int>::to_string(
1333 Patterns::Integer(),
1334 "Number of floating walls");
1339 prm.enter_subsection(
"wall " +
1340 Utilities::int_to_string(counter, 1));
1344 prm.leave_subsection();
1347 prm.leave_subsection();
1354 prm.enter_subsection(
"floating walls");
1360 prm.enter_subsection(
"wall 0");
1364 prm.leave_subsection();
1368 prm.enter_subsection(
"wall 1");
1372 prm.leave_subsection();
1376 prm.enter_subsection(
"wall 2");
1380 prm.leave_subsection();
1384 prm.enter_subsection(
"wall 3");
1388 prm.leave_subsection();
1392 prm.enter_subsection(
"wall 4");
1396 prm.leave_subsection();
1400 prm.enter_subsection(
"wall 5");
1404 prm.leave_subsection();
1408 prm.enter_subsection(
"wall 6");
1412 prm.leave_subsection();
1416 prm.enter_subsection(
"wall 7");
1420 prm.leave_subsection();
1424 prm.enter_subsection(
"wall 8");
1428 prm.leave_subsection();
1432 prm.enter_subsection(
"wall 9");
1436 prm.leave_subsection();
1439 prm.leave_subsection();
1446 prm.declare_entry(
"point on wall",
1448 Patterns::List(Patterns::Double(), 2, 3),
1450 prm.declare_entry(
"normal vector",
1452 Patterns::List(Patterns::Double(), 2, 3),
1453 "Normal vector of the wall");
1455 prm.enter_subsection(
"point on wall");
1456 prm.declare_entry(
"x",
"0.", Patterns::Double(),
"X Point on wall");
1457 prm.declare_entry(
"y",
"0.", Patterns::Double(),
"Y Point on wall");
1458 prm.declare_entry(
"z",
"0.", Patterns::Double(),
"Z Point on wall");
1459 prm.mark_as_deprecated(
"x");
1460 prm.mark_as_deprecated(
"y");
1461 prm.mark_as_deprecated(
"z");
1462 prm.leave_subsection();
1464 prm.enter_subsection(
"normal vector");
1465 prm.declare_entry(
"nx",
"0.", Patterns::Double(),
"X Normal vector wall");
1466 prm.declare_entry(
"ny",
"0.", Patterns::Double(),
"Y Normal vector wall");
1467 prm.declare_entry(
"nz",
"0.", Patterns::Double(),
"Z Normal vector wall");
1468 prm.mark_as_deprecated(
"nx");
1469 prm.mark_as_deprecated(
"ny");
1470 prm.mark_as_deprecated(
"nz");
1471 prm.leave_subsection();
1473 prm.declare_entry(
"start time",
"0.", Patterns::Double(),
"Start time");
1475 prm.declare_entry(
"end time",
"0.", Patterns::Double(),
"End time");
1483 Point<dim> wall_point(
1488 Tensor<1, dim> wall_normal(
1490 wall_normal = wall_normal / wall_normal.norm();
1494 time_start.push_back(prm.get_double(
"start time"));
1495 time_end.push_back(prm.get_double(
"end time"));
1501 prm.enter_subsection(
"DEM boundary conditions");
1503 prm.declare_entry(
"number of boundary conditions",
1504 Patterns::Tools::Convert<unsigned int>::to_string(
1506 Patterns::Integer(),
1507 "Number of boundary conditions");
1509 for (
unsigned int counter = 0;
1513 prm.enter_subsection(
"boundary condition " +
1514 Utilities::int_to_string(counter, 1));
1518 prm.leave_subsection();
1521 prm.leave_subsection();
1527 prm.enter_subsection(
"DEM boundary conditions");
1530 prm.get_integer(
"number of boundary conditions");
1532 for (
unsigned int counter = 0;
1536 prm.enter_subsection(
"boundary condition " +
1537 Utilities::int_to_string(counter, 1));
1541 prm.leave_subsection();
1543 prm.leave_subsection();
1548 const types::boundary_id default_boundary_id)
1550 prm.declare_entry(
"boundary id",
1551 Utilities::to_string(default_boundary_id, 1),
1552 Patterns::List(Patterns::Integer()),
1557 Patterns::Selection(
1558 "fixed_wall|outlet|translational|rotational|periodic"),
1559 "Type of boundary condition. "
1560 "Choices are <fixed_wall|outlet|translational|rotational|periodic>.");
1562 prm.declare_entry(
"speed x",
1565 "Translational boundary speed in x direction");
1566 prm.declare_entry(
"speed y",
1569 "Translational boundary speed in y direction");
1570 prm.declare_entry(
"speed z",
1573 "Translational boundary speed in z direction");
1575 prm.declare_entry(
"rotational speed",
1578 "Rotational boundary speed");
1580 prm.declare_entry(
"rotational vector",
1582 Patterns::List(Patterns::Double()),
1583 "Rotational vector elements");
1585 prm.declare_entry(
"periodic id 0",
1587 Patterns::Integer(),
1588 "Periodic boundary ID 0");
1589 prm.declare_entry(
"periodic id 1",
1591 Patterns::Integer(),
1592 "Periodic boundary ID 1");
1594 prm.declare_entry(
"point on rotational vector",
1596 Patterns::List(Patterns::Double()),
1597 "Point on the rotational vector");
1600 "periodic direction",
1602 Patterns::Integer(),
1603 "Periodic direction or normal direction of periodic boundary");
1607 "thermal boundary type",
1609 "Thermal boundary type used in multiphysic DEM.");
1611 auto wall_temperature_function_parsed =
1612 std::make_shared<Functions::ParsedFunction<3>>(1);
1613 prm.enter_subsection(
"wall temperature");
1615 wall_temperature_function_parsed->declare_parameters(prm, 1);
1617 prm.leave_subsection();
1623 std::vector<types::boundary_id> boundary_ids =
1625 const std::string boundary_type = prm.get(
"type");
1627 for (
const auto boundary_id : boundary_ids)
1629 if (boundary_type ==
"outlet")
1633 else if (boundary_type ==
"translational")
1635 Tensor<1, 3> translational_velocity;
1636 translational_velocity[0] = prm.get_double(
"speed x");
1637 translational_velocity[1] = prm.get_double(
"speed y");
1638 translational_velocity[2] = prm.get_double(
"speed z");
1641 translational_velocity;
1643 else if (boundary_type ==
"rotational")
1645 double rotational_speed = prm.get_double(
"rotational speed");
1648 Tensor<1, 3> rotational_vector =
1651 rotational_vector.norm() != 0.,
1653 "Invalid rotational vector. Its norm cannot be equal to zero."));
1655 Tensor<1, 3> point_on_rotation_axis_tensor =
1657 prm.get(
"point on rotational vector"));
1661 rotational_vector / rotational_vector.norm();
1663 point_on_rotation_axis_tensor;
1665 else if (boundary_type ==
"fixed_wall")
1670 else if (boundary_type ==
"periodic")
1675 const types::boundary_id periodic_id_0 =
1676 prm.get_integer(
"periodic id 0");
1678 .neighbor_id =
static_cast<types::boundary_id
>(
1679 prm.get_integer(
"periodic id 1")),
1680 .direction =
static_cast<unsigned int>(
1681 prm.get_integer(
"periodic direction"))};
1686 ExcMessage(
"Invalid DEM boundary condition type"));
1691 const bool is_wall = boundary_type ==
"fixed_wall" ||
1692 boundary_type ==
"translational" ||
1693 boundary_type ==
"rotational";
1696 prm.get(
"thermal boundary type"));
1705 auto wall_temperature_function_parsed =
1706 std::make_shared<Functions::ParsedFunction<3>>(1);
1707 prm.enter_subsection(
"wall temperature");
1708 wall_temperature_function_parsed->parse_parameters(prm);
1709 prm.leave_subsection();
1712 wall_temperature_function_parsed;
1723 "Invalid DEM boundary condition with an imposed temperature. Only "
1724 "the fixed_wall, translational and rotational boundary types can "
1725 "have the temperature thermal boundary type."));
1735 prm.enter_subsection(
"grid motion");
1740 "Choosing grid motion type.");
1742 prm.declare_entry(
"grid translational velocity x",
1743 Patterns::Tools::Convert<double>::to_string(
1746 "grid translational velocity x");
1747 prm.declare_entry(
"grid translational velocity y",
1748 Patterns::Tools::Convert<double>::to_string(
1751 "grid translational velocity y");
1752 prm.declare_entry(
"grid translational velocity z",
1754 Patterns::Tools::Convert<double>::to_string(
1758 "grid translational velocity z");
1760 prm.declare_entry(
"grid rotational speed",
1761 Patterns::Tools::Convert<double>::to_string(
1764 "grid rotational speed");
1766 prm.declare_entry(
"grid rotational axis",
1767 Patterns::Tools::Convert<unsigned int>::to_string(
1769 Patterns::Integer(),
1770 "grid rotational axis");
1772 prm.leave_subsection();
1779 prm.enter_subsection(
"grid motion");
1787 prm.get_double(
"grid translational velocity x");
1789 prm.get_double(
"grid translational velocity y");
1792 prm.get_double(
"grid translational velocity z");
1794 prm.leave_subsection();
1801 prm.enter_subsection(
"post-processing");
1804 "lagrangian post-processing",
1805 Patterns::Tools::Convert<bool>::to_string(
1808 "State whether lagrangian post-processing should be performed.");
1811 Patterns::Tools::Convert<bool>::to_string(defaults.
force_chains),
1813 "State whether force chains visualization should be performed.");
1814 prm.enter_subsection(
"particle wall collision statistics");
1817 "enable particle wall collision statistics",
1818 Patterns::Tools::Convert<bool>::to_string(
1821 "Enable the logging of particle-wall collision statistics. "
1822 "Choices are <true|false>.");
1824 "log collisions with all walls",
1825 Patterns::Tools::Convert<bool>::to_string(
1828 "State whether collisions with all walls should be logged. "
1829 "Choices are <true|false>.");
1831 "wall boundary ids",
1832 Patterns::Tools::Convert<std::vector<int>>::to_string(
1834 Patterns::List(Patterns::Integer()),
1835 "Boundary ids of the walls to log collisions with");
1837 "collision statistics file",
1839 Patterns::FileName(),
1840 "Exported particle-wall collision results filename");
1846 "State whether collision starts and ends should be printed.",
1850 prm.leave_subsection();
1852 prm.leave_subsection();
1858 prm.enter_subsection(
"post-processing");
1861 prm.get_bool(
"lagrangian post-processing");
1863 prm.enter_subsection(
"particle wall collision statistics");
1866 prm.get_bool(
"enable particle wall collision statistics");
1868 prm.get_bool(
"log collisions with all walls");
1877 prm.leave_subsection();
1879 prm.leave_subsection();
1885 prm.enter_subsection(
"floating grid");
1887 mesh.declare_parameters(prm);
1888 motion.declare_parameters(prm);
1889 prm.declare_entry(
"start time",
1890 Patterns::Tools::Convert<double>::to_string(
1894 prm.declare_entry(
"end time",
1895 Patterns::Tools::Convert<double>::to_string(
time_end),
1900 prm.leave_subsection();
1907 prm.enter_subsection(
"floating grid");
1909 mesh.parse_parameters(prm);
1910 motion.parse_parameters(prm);
1912 time_end = prm.get_double(
"end time");
1915 prm.leave_subsection();
1924 prm.enter_subsection(
"particle ray tracing");
1927 prm.declare_entry(
"starting photon insertion position",
1928 Patterns::Tools::Convert<Point<3>>::to_string(
1930 Patterns::List(Patterns::Double()),
1931 "Location of the first photon being inserted.");
1937 const Patterns::List insertion_unit_tensors_pattern(
1938 Patterns::List(Patterns::Double(), 3, 3,
","), 3, 3,
":");
1940 "insertion unit tensors",
1941 Patterns::Tools::Convert<std::vector<Tensor<1, 3>>>::to_string(
1943 insertion_unit_tensors_pattern),
1944 insertion_unit_tensors_pattern,
1945 "Directions used to insert photons.");
1948 const Patterns::List n_photons_pattern(Patterns::Integer(), 3, 3,
":");
1950 "number of inserted photons per direction",
1951 Patterns::Tools::Convert<std::vector<unsigned int>>::to_string(
1954 "Number of inserted photon in each direction.");
1958 const Patterns::List step_between_photons_pattern(Patterns::Double(),
1963 "distance between photons on insertion per direction",
1964 Patterns::Tools::Convert<std::vector<double>>::to_string(
1966 step_between_photons_pattern),
1967 step_between_photons_pattern,
1968 "Distance between inserted photons in each direction.");
1972 prm.declare_entry(
"reference displacement vector",
1973 Patterns::Tools::Convert<Tensor<1, 3>>::to_string(
1975 Patterns::List(Patterns::Double()),
1976 "Reference displacement vector of each photons.");
1980 "photon insertion maximum offset",
1981 Patterns::Tools::Convert<double>::to_string(
1984 "Set the maximum offset applied on each photon position during their "
1985 "insertion, respectively to the insertion unit tensors. If set to 0., "
1986 "photons will be perfectly aligned.");
1989 "photon insertion prn seed",
1990 Patterns::Tools::Convert<unsigned int>::to_string(
1992 Patterns::Integer(),
1993 "Pseudo random seed used to generate the offset for each photon "
1994 "insertion location.");
1998 "photon maximum angular offset",
1999 Patterns::Tools::Convert<double>::to_string(
2002 "Used to introduce randomness in the displacement direction of each "
2003 "photon. This parameter defines the maximum angle between a given "
2004 "photon displacement vector and the prescribed displacement vector "
2005 "parameter. If set to zero, every photon will move in the same "
2006 "direction defined by the prescribed displacement vector parameter. "
2007 "Otherwise, the offset is applied in a random orientation relative to "
2008 "the reference displacement vector parameter.");
2010 prm.declare_entry(
"photon angular offset prn seed",
2011 Patterns::Tools::Convert<unsigned int>::to_string(
2013 Patterns::Integer(),
2014 "Pseudo random seed used to generated the angle "
2015 "offset and the random orientation.");
2017 prm.leave_subsection();
2024 prm.enter_subsection(
"particle ray tracing");
2028 prm.get(
"starting photon insertion position"))));
2031 const std::vector<std::string> insertion_unit_tensors_string(
2032 Utilities::split_string_list(prm.get(
"insertion unit tensors"),
":"));
2033 const std::vector<std::string> n_photons_per_directions_strings(
2034 Utilities::split_string_list(
2035 prm.get(
"number of inserted photons per direction"),
":"));
2036 const std::vector<std::string>
2037 step_between_photon_per_direction_strings(
2038 Utilities::split_string_list(
2039 prm.get(
"distance between photons on insertion per direction"),
2046 insertion_unit_tensors_string.size() == dim &&
2047 n_photons_per_directions_strings.size() == dim &&
2048 step_between_photon_per_direction_strings.size() == dim,
2050 "The \"insertion unit tensors\", \"distance between photons on"
2051 " insertion per direction\" and \"number of inserted photons per "
2052 "direction\" all need to have a number of dimension equal to the "
2053 "\"dimension\" parameter."));
2064 for (
int i = 0; i < dim; i++)
2066 Tensor<1, dim> temp_direction_tensor =
2068 temp_direction_tensor =
2069 temp_direction_tensor / temp_direction_tensor.norm();
2074 Utilities::string_to_int(n_photons_per_directions_strings.at(i)));
2077 Utilities::string_to_double(
2078 step_between_photon_per_direction_strings.at(i)));
2083 prm.get(
"reference displacement vector")));
2089 prm.get_double(
"photon insertion maximum offset");
2091 prm.get_integer(
"photon insertion prn seed");
2096 prm.get_integer(
"photon angular offset prn seed");
2098 prm.leave_subsection();
Parameters for a floating grid in DEM simulations.
Parameters::Mesh< dim > mesh
Mesh parameters for the floating grid.
void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
Parameters::Lagrangian::GridMotion< dim > motion
Motion parameters for the floating grid.
double time_start
Activation time of the floating grid.
double time_end
Deactivation time of the floating grid.
Parameters for floating walls in DEM simulations.
std::vector< double > time_end
Deactivation time of each floating wall.
static void declare_default_entry(ParameterHandler &prm)
Declare default parameter entries for a single floating wall.
std::vector< Point< dim > > points_on_walls
A point on each floating wall surface.
unsigned int max_number_floating_walls
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
std::vector< Tensor< 1, dim > > floating_walls_normal_vectors
Outward normal vector of each floating wall.
void parse_floating_wall(const ParameterHandler &prm)
Parse parameters for a single floating wall.
void declare_parameters(ParameterHandler &prm) const
Declare the parameters in the parameter handler.
unsigned int floating_walls_number
Number of floating walls.
std::vector< double > time_start
Activation time of each floating wall.
ForceTorqueOnWall - Defines the parameters for the force and torques calculation on boundaries of the...
Parameters::Verbosity force_torque_verbosity
Verbosity level for force and torque output.
unsigned int output_frequency
Output frequency (in time steps).
Point< 3 > point_center_mass
Center of mass used for torque computation.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
std::string force_torque_output_name
File name prefix for force and torque output.
bool calculate_force_torque
Enable force and torque post-processing on wall boundaries.
Parameters for grid (mesh) motion in DEM simulations.
double grid_rotational_speed
Rotational speed of the rotating grid (rad/s).
unsigned int grid_rotational_axis
Rotational axis of the rotating grid (0=x, 1=y, 2=z).
enum Parameters::Lagrangian::GridMotion::MotionType motion_type
Type of grid motion.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
Tensor< 1, dim > grid_translational_velocity
Translational velocity of the moving grid.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
Parameters controlling particle insertion in DEM simulations.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
std::vector< double > list_vy
y-velocity for list insertion.
Point< 3 > insertion_box_point_1
First corner of the insertion box (volume method).
std::shared_ptr< Function< dim > > initial_temperature_function
std::vector< double > list_vx
x-velocity for list insertion.
std::shared_ptr< Function< dim > > insertion_acceptance_fct
Point< 3 > clear_box_point_1
First corner of the particle removal box.
std::vector< double > list_z
z-position for list insertion.
unsigned int inserted_this_step
Number of particles inserted at each insertion step.
std::vector< double > list_wz
z-angular velocity for list insertion.
Point< 3 > clear_box_point_2
Second corner of the particle removal box.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
std::vector< double > list_x
x-position for list insertion.
std::vector< double > list_T
Temperature for list insertion.
double insertion_maximum_offset
Maximum random offset applied to insertion positions.
Point< 3 > insertion_plane_point
Point on the insertion plane (plane method).
std::vector< double > list_wy
y-angular velocity for list insertion.
std::vector< double > list_vz
z-velocity for list insertion.
int insertion_frequency
Frequency of insertion (in time steps).
double distance_threshold
Minimum distance threshold between inserted particles.
std::vector< unsigned int > direction_sequence
Direction sequence for particle insertion (1st, 2nd, 3rd).
std::vector< double > list_y
y-position for list insertion.
Tensor< 1, 3 > initial_omega
Initial angular velocity of inserted particles.
std::vector< std::string > list_of_input_files
List of input files for the file insertion method.
bool removing_particles_in_region
Enable removal of particles in a specified region.
Tensor< 1, 3 > initial_vel
Initial translational velocity of inserted particles.
int seed_for_insertion
Random seed for particle insertion.
enum Parameters::Lagrangian::InsertionInfo::InsertionMethod insertion_method
Point< 3 > insertion_box_point_2
Second corner of the insertion box (volume method).
std::vector< double > list_wx
x-angular velocity for list insertion.
std::vector< double > list_d
Diameter for list insertion.
Tensor< 1, 3 > insertion_plane_normal_vector
Normal vector of the insertion plane (plane method).
Numerical model parameters for DEM simulations.
unsigned int dynamic_load_balance_check_frequency
Check frequency for dynamic load balancing.
double granular_temperature_threshold
double f_coefficient_epsd
Model parameter for the EPSD rolling resistance model.
std::shared_ptr< Function< dim > > cell_weight_function
enum Parameters::Lagrangian::ModelParameters::ContactDetectionMethod contact_detection_method
@ dynamic_with_sparse_contacts
DEM::SolverType solver_type
Solver type (DEM, CFD-DEM, or DEM multiphysics).
RollingResistanceMethod rolling_resistance_method
Rolling resistance torque method.
double active_load_balancing_factor
unsigned int load_balance_particle_weight
Particle weight used for load balancing.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
enum Parameters::Lagrangian::ModelParameters::LoadBalanceMethod load_balance_method
double dynamic_contact_search_factor
Safety factor for dynamic contact search.
unsigned int contact_detection_frequency
Frequency of particle-particle and particle-wall contact detection.
enum Parameters::Lagrangian::ModelParameters::IntegrationMethod integration_method
bool disable_position_integration
Disable position integration for particles.
double inactive_load_balancing_factor
unsigned int load_balance_frequency
Load balance frequency (in time steps).
double dmt_cut_off_threshold
Cut-off threshold beyond which Van der Waals forces are ignored.
bool sparse_particle_contacts
Enable sparse particle contacts to optimize performance.
double load_balance_threshold
Load balance threshold (for dynamic load balancing).
ParticleParticleContactForceModel particle_particle_contact_force_model
Particle-particle contact force model.
ParticleWallContactForceModel particle_wall_contact_force_method
Particle-wall contact force model.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
double solid_fraction_threshold
double neighborhood_threshold
unsigned int load_balance_step
Load balance step (for single-step load balancing).
Tensor< 1, spacedim > value_string_to_tensor(const std::string &value_string)
Return the tensor corresponding to the value_string. If the dimension correspondence of the value_str...
std::vector< std::pair< std::string, EnumType > > DeprecatedEnumNames
Deprecated strings of an enum parameter, each paired with the enumerator it stands for....
std::vector< T > convert_string_to_vector(const ParameterHandler &prm, const std::string &entry_string)
Return the vector of size N of entry @entry_string. If the entry is specified in the ....
EnumType string_to_enum(const std::string &name)
Return the enumerator whose identifier is name, e.g. to parse the value of a parameter entry into its...
void declare_enum_entry(ParameterHandler &prm, const std::string &entry_name, const EnumType default_value, const std::string &description, const DeprecatedEnumNames< EnumType > &deprecated_names={}, const std::vector< EnumType > &allowed_values={})
Declare a parameter entry whose value is an enumerator. The default value, the accepted values and th...
@ hertz_JKR
Hertz model with Johnson-Kendall-Roberts cohesive force.
@ hertz_mindlin_limit_overlap
Hertz-Mindlin model with a limitation on tangential overlap.
@ hertz_mindlin_limit_force
Hertz-Mindlin model with a limitation on tangential force.
@ DMT
Derjaguin-Muller-Toporov model.
@ uniform
Uniform distribution.
WallThermalBoundaryType
Thermal boundary type of the grid in multiphysic DEM. It is used to define the thermal boundary condi...
@ adiabatic
No heat flux through the wall.
@ temperature
Temperature imposed on the wall. It can vary in space and time.
@ volume_based
Volume-based distribution weighting.
@ number_based
Number-based distribution weighting.
@ JKR
Johnson-Kendall-Roberts model.
@ DMT
Derjaguin-Muller-Toporov model.
@ PDF
Probability density function.
@ epsd
Elastic-plastic spring-dashpot.
@ viscous
Viscous rolling resistance.
@ constant
Constant rolling resistance.
@ none
No rolling resistance.
const std::vector< Verbosity > & quiet_or_verbose()
Return the verbosity levels accepted by the parameters which do not support Verbosity::extra_verbose.
const DeprecatedEnumNames< Verbosity > & deprecated_verbosity_names()
Return the deprecated strings of the parameters parsed into a Verbosity, which remain accepted in par...
Parameter structures for Lagrangian (DEM) particle simulations.
void parse_boundary_conditions(ParameterHandler &prm)
Parse boundary condition parameters for a single boundary.
std::map< types::boundary_id, double > boundary_rotational_speed
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
std::map< types::boundary_id, Tensor< 1, 3 > > boundary_translational_velocity
PeriodicBoundaries periodic_boundaries
void declare_parameters(ParameterHandler &prm) const
Declare the parameters in the parameter handler.
static void declare_default_entry(ParameterHandler &prm, const types::boundary_id default_boundary_id)
Declare default parameter entries for a single boundary condition.
std::set< types::boundary_id > outlet_boundaries
std::map< types::boundary_id, std::shared_ptr< Function< 3 > > > boundary_temperature
unsigned int number_of_dem_boundary_conditions
Number of DEM boundary conditions.
std::map< types::boundary_id, WallThermalBoundaryType > thermal_boundary_type
std::map< types::boundary_id, Tensor< 1, 3 > > boundary_rotational_vector
std::map< types::boundary_id, Point< 3 > > point_on_rotation_axis
static constexpr unsigned int max_number_of_dem_boundary_conditions
double specific_heats_ratio_gas
Specific heats ratio of the interstitial gas.
double molecular_mean_free_path_gas
Molecular mean free path of the interstitial gas.
std::vector< double > friction_coefficient_particle
Friction coefficient of each particle type.
double thermal_accommodation_wall
Thermal accommodation coefficient of the wall.
double dynamic_viscosity_gas
Dynamic viscosity of the interstitial gas.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
std::vector< ProbabilityFunctionType > custom_probability_function_type
Custom distribution function type (PDF or CDF).
void parse_particle_properties(const unsigned int &particle_type, const ParameterHandler &prm)
Parse the physical properties for a given particle type.
double surface_slope_wall
Surface slope of the wall.
std::vector< DistributionWeightingType > distribution_weighting_type
double thermal_conductivity_wall
Thermal conductivity of the wall.
Tensor< 1, 3 > g
Gravitational acceleration vector.
std::vector< double > rolling_friction_coefficient_particle
Rolling friction coefficient of each particle type.
std::vector< double > surface_energy_particle
Surface energy of each particle type.
std::vector< bool > custom_distribution_from_file
Indicate if the custom distribution is read from file.
double hamaker_constant_wall
Hamaker constant of the wall.
std::vector< double > youngs_modulus_particle
Young's modulus of each particle type.
std::vector< std::vector< double > > particle_custom_probability
std::vector< double > thermal_conductivity_particle
Thermal conductivity of each particle type.
std::vector< SizeDistributionType > distribution_type
std::vector< double > hamaker_constant_particle
Hamaker constant of each particle type.
std::vector< double > particle_size_std
Size standard deviation of each particle type.
std::vector< double > surface_roughness_particle
Surface roughness of each particle type.
void declare_parameters(ParameterHandler &prm) const
Declare the parameters in the parameter handler.
double surface_energy_wall
Surface energy of the wall.
double real_youngs_modulus_wall
Real Young's modulus of the wall.
std::vector< double > specific_heat_particle
Specific heat of each particle type.
std::vector< double > diameter_min_cutoff
Minimum diameter cutoff for lognormal distribution.
double friction_coefficient_wall
Friction coefficient of the wall.
std::vector< double > rolling_viscous_damping_coefficient_particle
Rolling viscous damping coefficient of each particle type.
std::vector< double > real_youngs_modulus_particle
Real Young's modulus of each particle type.
void initialize_containers(std::vector< SizeDistributionType > &dist_types, std::vector< double > &p_average_diameter, std::vector< double > &p_size_std, std::vector< bool > &custom_dist_read_from_file, std::vector< std::string > &custom_dist_file_names, std::vector< ProbabilityFunctionType > &custom_function_type, std::vector< bool > &custom_interpolation, std::vector< std::vector< double > > &custom_diameter_values, std::vector< std::vector< double > > &custom_probabilities_values, std::vector< DistributionWeightingType > &distribution_weighting_basis_type, std::vector< unsigned int > &seed_for_dist, std::vector< double > &dia_min_cutoff, std::vector< double > &dia_max_cutoff, std::vector< int > &p_number, std::vector< double > &p_density, std::vector< double > &p_youngs_modulus, std::vector< double > &p_poisson_ratio, std::vector< double > &p_restitution_coefficient, std::vector< double > &p_friction_coefficient, std::vector< double > &p_rolling_viscous_damping_coefficient, std::vector< double > &p_rolling_friction_coefficient, std::vector< double > &p_surface_energy, std::vector< double > &p_hamaker_constant, std::vector< double > &p_thermal_conductivity, std::vector< double > &p_specific_heat, std::vector< double > &p_microhardness, std::vector< double > &p_surface_slope, std::vector< double > &p_surface_roughness, std::vector< double > &p_thermal_accommodation, std::vector< double > &p_real_youngs_modulus) const
initialize_containers - Initialize the containers used to store the particle size distribution and ph...
std::vector< double > poisson_ratio_particle
Poisson's ratio of each particle type.
double youngs_modulus_wall
Young's modulus of the wall.
static void declare_default_entry(ParameterHandler &prm)
Declare default parameter entries for a single particle type.
std::vector< double > diameter_max_cutoff
Maximum diameter cutoff for lognormal distribution.
std::vector< std::string > custom_distribution_filenames
Filename for the custom distribution for each particle type.
std::vector< double > density_particle
Density of each particle type.
std::vector< double > surface_slope_particle
Surface slope of each particle type.
double microhardness_wall
Microhardness of the wall.
std::vector< std::vector< double > > particle_custom_diameter
List of diameters for the custom distribution for each particle type.
std::vector< double > particle_average_diameter
Average diameter of each particle type.
std::vector< double > microhardness_particle
Microhardness of each particle type.
unsigned int particle_type_maximum_number
unsigned int particle_type_number
Number of particle types.
double specific_heat_gas
Specific heat of the interstitial gas.
double rolling_friction_wall
Rolling friction coefficient of the wall.
std::vector< double > thermal_accommodation_particle
Thermal accommodation coefficient of each particle type.
double thermal_conductivity_gas
Thermal conductivity of the interstitial gas.
double rolling_viscous_damping_wall
Rolling viscous damping coefficient of the wall.
std::vector< bool > custom_distribution_interpolation
double poisson_ratio_wall
Poisson's ratio of the wall.
double restitution_coefficient_wall
Coefficient of restitution of the wall.
std::vector< unsigned int > seed_for_distributions
Random seed for the size distribution.
std::vector< double > restitution_coefficient_particle
Coefficients of restitution of each particle type.
std::vector< int > number
Number particles of each particle type.
double surface_roughness_wall
Surface roughness of the wall.
Lagrangian Postprocessing - Defines the parameters for the Lagrangian post-processing.
Parameters::Verbosity collision_verbosity
Verbosity level for collision statistics output.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
bool lagrangian_post_processing_enabled
Enable Lagrangian post-processing.
std::vector< int > particle_wall_collision_boundary_ids
Boundary IDs of the walls for which collisions are logged.
bool particle_wall_collision_statistics
Enable logging of particle-wall contact statistics.
std::string collision_stats_file_name
File name for exporting collision statistics (CSV format).
bool force_chains
Enable force chains visualization.
bool log_collisions_with_all_walls
Log collisions with all walls (if false, only selected boundaries).
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
Defines parameters used to construct particle ray tracing class.
double max_angular_offset
Maximum angular offset applied to the photon displacement direction.
unsigned int prn_seed_photon_displacement
Random seed for photon displacement angular offset.
static void declare_parameters(ParameterHandler &prm)
Declare the parameters in the parameter handler.
void parse_parameters(ParameterHandler &prm)
Parse the parameters from the parameter handler.
double max_insertion_offset
Maximum random offset applied to the photon insertion position.
std::vector< Tensor< 1, 3 > > insertion_directions_units_vector
std::vector< double > step_between_photons_each_directions
std::vector< unsigned int > n_photons_each_directions
Number of photons to insert along each direction.
Point< 3 > starting_point
Location of the first photon to be inserted.
unsigned int prn_seed_photon_insertion
Random seed for photon insertion position offset.
Tensor< 1, 3 > ref_displacement_tensor_unit
Reference unit tensor defining the photon displacement direction.
Tensor< 1, 3 > tensor_nd_to_3d(const Tensor< 1, dim > &tensor)
Point< 3 > point_nd_to_3d(const Point< dim > &point)