Lethe Open-Source Library version 1.2.0
Developer Guide
Loading...
Searching...
No Matches
vans_assemblers.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) 2021-2026 The Lethe Authors
2// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
3
4#ifndef lethe_vans_assemblers_h
5#define lethe_vans_assemblers_h
6
8
9#include <solvers/copy_data.h>
12
14
15#include <deal.II/particles/particle_handler.h>
16
17
18/**
19 * @file vans_assemblers.h
20 * @brief Assemblers for the Volume-Averaged Navier-Stokes (VANS) equations.
21 *
22 * This file contains the assemblers used to build the matrix and right-hand
23 * side contributions for the VANS equations in CFD-DEM simulations. It
24 * includes the core equation assemblers (Model A and Model B), various drag
25 * models (Di Felice, Rong, Dallavalle, Koch-Hill, Beetstra, Gidaspow), lift
26 * force models (Saffman-Mei, Magnus), torque models (viscous, vortical),
27 * buoyancy, pressure and shear force assemblers, and the fluid-particle
28 * interaction assemblers.
29 */
30
31/**
32 * @brief Interface for all assemblers of particle-fluid interactions in the
33 * VANS equations.
34 *
35 * @tparam dim An integer that denotes the number of spatial dimensions.
36 * @tparam PropertiesIndex Index of the properties used within the
37 * ParticleHandler.
38 *
39 * @ingroup assemblers
40 */
41template <int dim, typename PropertiesIndex>
43{
44public:
45 /**
46 * @brief Calculate the particle-fluid interaction for all particles in a
47 * cell.
48 *
49 * The forces calculated on the particles are stored within the
50 * @p fem_force field. The overall \f$ \beta \f$ coefficient for the cell,
51 * which is defined as the drag coefficient divided by the cell volume, is
52 * also calculated within this function.
53 *
54 * @param[in,out] scratch_data Scratch data containing the Navier-Stokes
55 * information. The scratch data must have been re-initialized before calling
56 * this function.
57 */
58 virtual void
60 NavierStokesScratchData<dim> &scratch_data) = 0;
61
62 /**
63 * @brief Default destructor.
64 */
65 virtual ~ParticleFluidAssemblerBase() = default;
66};
67
68
69/**
70 * @brief Assembler for the core of Model B of the Volume-Averaged
71 * Navier-Stokes (VANS) equations.
72 *
73 * @tparam dim An integer that denotes the number of spatial dimensions.
74 *
75 * @ingroup assemblers
76 */
77template <int dim>
79{
80public:
81 /**
82 * @brief Construct a VANSAssemblerCoreModelB object.
83 *
84 * @param[in] simulation_control Shared pointer to the simulation control
85 * object used to retrieve time-stepping information.
86 * @param[in] cfd_dem CFD-DEM simulation parameters.
87 */
89 const std::shared_ptr<SimulationControl> &simulation_control,
93 {}
94
95 /**
96 * @brief Assemble the matrix.
97 *
98 * @param[in] scratch_data (see base class)
99 * @param[in,out] copy_data (see base class)
100 */
101 virtual void
103 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
104
105 /**
106 * @brief Assemble the right-hand side.
107 *
108 * @param[in] scratch_data (see base class)
109 * @param[in,out] copy_data (see base class)
110 */
111 virtual void
112 assemble_rhs(const NavierStokesScratchData<dim> &scratch_data,
113 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
114
115 /// Flag indicating whether SUPG stabilization is used.
116 const bool SUPG = true;
117
118 /// Shared pointer to the simulation control object.
119 const std::shared_ptr<SimulationControl> simulation_control;
120
121 /// CFD-DEM simulation parameters.
123};
124
125/**
126 * @brief Assembler for the core of Model A of the Volume-Averaged
127 * Navier-Stokes (VANS) equations.
128 *
129 * @tparam dim An integer that denotes the number of spatial dimensions.
130 *
131 * @ingroup assemblers
132 */
133template <int dim>
135{
136public:
137 /**
138 * @brief Construct a VANSAssemblerCoreModelA object.
139 *
140 * @param[in] simulation_control Shared pointer to the simulation control
141 * object used to retrieve time-stepping information.
142 * @param[in] cfd_dem CFD-DEM simulation parameters.
143 */
145 const std::shared_ptr<SimulationControl> &simulation_control,
149 {}
150
151 /**
152 * @brief Assemble the matrix.
153 *
154 * @param[in] scratch_data (see base class)
155 * @param[in,out] copy_data (see base class)
156 */
157 virtual void
159 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
160
161 /**
162 * @brief Assemble the right-hand side.
163 *
164 * @param[in] scratch_data (see base class)
165 * @param[in,out] copy_data (see base class)
166 */
167 virtual void
168 assemble_rhs(const NavierStokesScratchData<dim> &scratch_data,
169 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
170
171 /// Flag indicating whether SUPG stabilization is used.
172 const bool SUPG = true;
173
174 /// Shared pointer to the simulation control object.
175 const std::shared_ptr<SimulationControl> simulation_control;
176
177 /// CFD-DEM simulation parameters.
179};
180
181/**
182 * @brief Assembler for the transient term arising from BDF time integration
183 * for the VANS equations.
184 *
185 * For example, if a BDF1 scheme is chosen, the following is assembled:
186 * \f[
187 * \frac{(\mathbf{u})^{t+\Delta t} - (\mathbf{u})^{t}}{\Delta t}
188 * \f]
189 *
190 * @tparam dim An integer that denotes the number of spatial dimensions.
191 *
192 * @ingroup assemblers
193 */
194template <int dim>
196{
197public:
198 /**
199 * @brief Construct a VANSAssemblerBDF object.
200 *
201 * @param[in] simulation_control Shared pointer to the simulation control
202 * object used to retrieve time-stepping information.
203 * @param[in] cfd_dem CFD-DEM simulation parameters.
204 */
205 VANSAssemblerBDF(const std::shared_ptr<SimulationControl> &simulation_control,
209 {}
210
211 /**
212 * @brief Assemble the matrix.
213 *
214 * @param[in] scratch_data (see base class)
215 * @param[in,out] copy_data (see base class)
216 */
217 virtual void
219 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
220
221 /**
222 * @brief Assemble the right-hand side.
223 *
224 * @param[in] scratch_data (see base class)
225 * @param[in,out] copy_data (see base class)
226 */
227 virtual void
228 assemble_rhs(const NavierStokesScratchData<dim> &scratch_data,
229 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
230
231 /// Shared pointer to the simulation control object.
232 const std::shared_ptr<SimulationControl> simulation_control;
233
234 /// CFD-DEM simulation parameters.
236};
237
238
239/**
240 * @brief Assembler for the drag force using the Di Felice model.
241 *
242 * The drag coefficient is computed as:
243 * \f[
244 * C_d = \left(0.63 + \frac{4.8}{\sqrt{\text{Re}_p}}\right)^2
245 * \varepsilon^{-(3.7 - 0.65
246 * \exp(-(1.5 - \log_{10} \text{Re}_p)^2 / 2))}
247 * \f]
248 *
249 * and the momentum exchange coefficient for each particle is:
250 * \f[
251 * \beta = \frac{1}{2} C_d \frac{\pi d_p^2}{4} \|\mathbf{u}_r\|
252 * \f]
253 *
254 * where \f$ \varepsilon \f$ is the cell void fraction, \f$ \text{Re}_p \f$ is
255 * the particle Reynolds number, \f$ d_p \f$ is the particle diameter, and
256 * \f$ \mathbf{u}_r \f$ is the relative velocity between the fluid and the
257 * particle.
258 *
259 * @tparam dim An integer that denotes the number of spatial dimensions.
260 * @tparam PropertiesIndex Index of the properties used within the
261 * ParticleHandler.
262 *
263 * @ingroup assemblers
264 */
265template <int dim, typename PropertiesIndex>
267 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
268{
269public:
270 /**
271 * @brief Construct a VANSAssemblerDiFelice object.
272 *
273 * @param[in] cfd_dem CFD-DEM simulation parameters.
274 */
278
279 /**
280 * @brief Calculate the particle-fluid interactions resulting from drag, using
281 * the Di Felice model.
282 *
283 * @param[in,out] scratch_data (see base class)
284 */
285 virtual void
287 NavierStokesScratchData<dim> &scratch_data) override;
288
289 /// CFD-DEM simulation parameters.
291};
292
293/**
294 * @brief Assembler for the drag force using the Rong model.
295 *
296 * The drag coefficient is computed as:
297 * \f[
298 * C_d = \left(0.63 + \frac{4.8}{\sqrt{\text{Re}_p}}\right)^2
299 * \varepsilon^{-(2.65(\varepsilon + 1) -
300 * (5.3 - 3.5\varepsilon)\varepsilon^2
301 * \exp(-(1.5 - \log_{10}\text{Re}_p)^2 / 2))}
302 * \f]
303 *
304 * and the momentum exchange coefficient for each particle is:
305 * \f[
306 * \beta = \frac{1}{2} C_d \frac{\pi d_p^2}{4} \|\mathbf{u}_r\|
307 * \f]
308 *
309 * where \f$ \varepsilon \f$ is the cell void fraction, \f$ \text{Re}_p \f$ is
310 * the particle Reynolds number, \f$ d_p \f$ is the particle diameter, and
311 * \f$ \mathbf{u}_r \f$ is the relative velocity between the fluid and the
312 * particle.
313 *
314 * @tparam dim An integer that denotes the number of spatial dimensions.
315 * @tparam PropertiesIndex Index of the properties used within the
316 * ParticleHandler.
317 *
318 * @ingroup assemblers
319 */
320template <int dim, typename PropertiesIndex>
322 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
323{
324public:
325 /**
326 * @brief Construct a VANSAssemblerRong object.
327 *
328 * @param[in] cfd_dem CFD-DEM simulation parameters.
329 */
333
334 /**
335 * @brief Calculate the particle-fluid interactions resulting from drag, using
336 * the Rong model.
337 *
338 * @param[in,out] scratch_data (see base class)
339 */
340 virtual void
342 NavierStokesScratchData<dim> &scratch_data) override;
343
344 /// CFD-DEM simulation parameters.
346};
347
348/**
349 * @brief Assembler for the drag force using the Dallavalle model.
350 *
351 * The drag coefficient is computed as:
352 * \f[
353 * C_d = \left(0.63 + \frac{4.8}{\sqrt{\text{Re}_p}}\right)^2
354 * \f]
355 *
356 * and the momentum exchange coefficient for each particle is:
357 * \f[
358 * \beta = \frac{1}{2} C_d \frac{\pi d_p^2}{4} \|\mathbf{u}_r\|
359 * \f]
360 *
361 * where \f$ \text{Re}_p \f$ is the particle Reynolds number, \f$ d_p \f$ is
362 * the particle diameter, and \f$ \mathbf{u}_r \f$ is the relative velocity
363 * between the fluid and the particle.
364 *
365 * @tparam dim An integer that denotes the number of spatial dimensions.
366 * @tparam PropertiesIndex Index of the properties used within the
367 * ParticleHandler.
368 *
369 * @ingroup assemblers
370 */
371template <int dim, typename PropertiesIndex>
373 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
374{
375public:
376 /**
377 * @brief Construct a VANSAssemblerDallavalle object.
378 *
379 * @param[in] cfd_dem CFD-DEM simulation parameters.
380 */
384
385 /**
386 * @brief Calculate the particle-fluid interactions resulting from drag, using
387 * the Dallavalle model.
388 *
389 * @param[in,out] scratch_data (see base class)
390 */
391 virtual void
393 NavierStokesScratchData<dim> &scratch_data) override;
394
395 /// CFD-DEM simulation parameters.
397};
398
399/**
400 * @brief Assembler for the drag force using the Koch and Hill drag model.
401 *
402 * The momentum exchange coefficient is computed as:
403 * \f[
404 * \beta = \frac{18 \mu \varepsilon^2 (1 - \varepsilon)}{d_p^2}
405 * \left(F_0 + \frac{1}{2} F_3 \varepsilon \text{Re}_p\right)
406 * \frac{V_p}{1 - \varepsilon}
407 * \f]
408 *
409 * where \f$ F_0 \f$ and \f$ F_3 \f$ are defined as:
410 *
411 * For \f$ (1 - \varepsilon) < 0.4 \f$:
412 * \f[
413 * F_0 = \frac{1 + 3\sqrt{(1-\varepsilon)/2}
414 * + \frac{135}{64}(1-\varepsilon)\ln(1-\varepsilon)
415 * + 16.14(1-\varepsilon)}
416 * {1 + 0.681(1-\varepsilon)
417 * - 8.48(1-\varepsilon)^2
418 * + 8.14(1-\varepsilon)^3}
419 * \f]
420 *
421 * For \f$ (1 - \varepsilon) \geq 0.4 \f$:
422 * \f[
423 * F_0 = \frac{10(1-\varepsilon)}{\varepsilon^3}
424 * \f]
425 *
426 * and:
427 * \f[
428 * F_3 = 0.0673 + 0.212(1-\varepsilon) + \frac{0.0232}{\varepsilon^5}
429 * \f]
430 *
431 * where \f$ \varepsilon \f$ is the cell void fraction, \f$ \mu \f$ is the
432 * dynamic viscosity, \f$ d_p \f$ is the particle diameter, \f$ V_p \f$ is the
433 * particle volume, and \f$ \text{Re}_p \f$ is the particle Reynolds number.
434 *
435 * @tparam dim An integer that denotes the number of spatial dimensions.
436 * @tparam PropertiesIndex Index of the properties used within the
437 * ParticleHandler.
438 *
439 * @ingroup assemblers
440 */
441template <int dim, typename PropertiesIndex>
443 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
444{
445public:
446 /**
447 * @brief Construct a VANSAssemblerKochHill object.
448 *
449 * @param[in] cfd_dem CFD-DEM simulation parameters.
450 */
454
455 /**
456 * @brief Calculate the particle-fluid interactions resulting from drag, using
457 * the Koch-Hill model.
458 *
459 * @param[in,out] scratch_data (see base class)
460 */
461 virtual void
463 NavierStokesScratchData<dim> &scratch_data) override;
464
465 /// CFD-DEM simulation parameters.
467};
468
469/**
470 * @brief Assembler for the drag force using the Beetstra model.
471 *
472 * The normalized drag force is computed as:
473 * \f[
474 * F_{\text{norm}} = \frac{10(1-\varepsilon)}{\varepsilon^2}
475 * + \varepsilon^2 \left(1 + 1.5\sqrt{1-\varepsilon}\right)
476 * + \frac{0.413\,\text{Re}_p}{24\varepsilon^2}
477 * \frac{\frac{1}{\varepsilon}
478 * + 3(1-\varepsilon)\varepsilon
479 * + 8.4\,\text{Re}_p^{-0.343}}
480 * {1 + 10^{3(1-\varepsilon)}
481 * \text{Re}_p^{-0.5(1 + 4(1-\varepsilon))}}
482 * \f]
483 *
484 * The drag coefficient is then:
485 * \f[
486 * C_d = \frac{24\,F_{\text{norm}}}{\text{Re}_p}
487 * \f]
488 *
489 * where \f$ \varepsilon \f$ is the cell void fraction and \f$ \text{Re}_p \f$
490 * is the particle Reynolds number.
491 *
492 * Reference: Beetstra, R., Martin Anton van der Hoef, and J. A. M. Kuipers.
493 * "Drag force of intermediate Reynolds number flow past mono‐and bidisperse
494 * arrays of spheres." AIChE journal 53.2 (2007): 489-501.
495 *
496 * @tparam dim An integer that denotes the number of spatial dimensions.
497 * @tparam PropertiesIndex Index of the properties used within the
498 * ParticleHandler.
499 *
500 * @ingroup assemblers
501 */
502template <int dim, typename PropertiesIndex>
504 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
505{
506public:
507 /**
508 * @brief Construct a VANSAssemblerBeetstra object.
509 *
510 * @param[in] cfd_dem CFD-DEM simulation parameters.
511 */
515
516 /**
517 * @brief Calculate the particle-fluid interactions resulting from drag, using
518 * the Beetstra model..
519 *
520 * @param[in,out] scratch_data (see base class)
521 */
522 virtual void
524 NavierStokesScratchData<dim> &scratch_data) override;
525
526 /// CFD-DEM simulation parameters.
528};
529
530/**
531 * @brief Assembler for the drag force using the Gidaspow model.
532 *
533 * The momentum transfer coefficient is calculated following Marchelli et al.
534 * (2020). For \f$ \varepsilon > 0.8 \f$:
535 * \f[
536 * \beta = 18 \varepsilon^{-3.65}
537 * \left(1 + 0.15\,\text{Re}_p^{0.687}\right)
538 * \frac{m_p \mu}{d_p^2 \rho_p}
539 * \f]
540 *
541 * For \f$ \varepsilon \leq 0.8 \f$ (assuming spherical particles):
542 * \f[
543 * \beta = \left(\frac{150(1-\varepsilon)}{\varepsilon^2}
544 * + \frac{1.75\,\text{Re}_p}{\varepsilon^2}\right)
545 * \frac{m_p \mu}{d_p^2 \rho_p}
546 * \f]
547 *
548 * where \f$ \varepsilon \f$ is the cell void fraction, \f$ \text{Re}_p \f$ is
549 * the particle Reynolds number, \f$ m_p \f$ is the particle mass, \f$ \mu \f$
550 * is the dynamic viscosity, \f$ d_p \f$ is the particle diameter, and
551 * \f$ \rho_p \f$ is the particle density.
552 *
553 * @tparam dim An integer that denotes the number of spatial dimensions.
554 * @tparam PropertiesIndex Index of the properties used within the
555 * ParticleHandler.
556 *
557 * @ingroup assemblers
558 */
559template <int dim, typename PropertiesIndex>
561 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
562{
563public:
564 /**
565 * @brief Construct a VANSAssemblerGidaspow object.
566 *
567 * @param[in] cfd_dem CFD-DEM simulation parameters.
568 */
572
573 /**
574 * @brief Calculate the particle-fluid interactions resulting from drag, using
575 * the Gidaspow model.
576 *
577 * @param[in,out] scratch_data (see base class)
578 */
579 virtual void
581 NavierStokesScratchData<dim> &scratch_data) override;
582
583 /// CFD-DEM simulation parameters.
585};
586
587/**
588 * @brief Assembler for the lift force using the Saffman-Mei model.
589 *
590 * This implementation follows the formulation in the book "Multiphase Flows
591 * with Droplets and Particles" by Crowe et al. (2011) and the brief
592 * communication article "An approximate expression for the shear lift force
593 * on a spherical particle at finite Reynolds number" by Mei (1992).
594 *
595 * The lift force is computed as:
596 * \f[
597 * \mathbf{F}_L = 1.61 \, C_s \, d_p^2 \, \rho_f
598 * \frac{\sqrt{\nu}}{\sqrt{\|\boldsymbol{\omega}_f\|}}
599 * \left(\mathbf{u}_r \times \boldsymbol{\omega}_f\right)
600 * \f]
601 *
602 * where the parameter \f$ \alpha \f$ is defined as:
603 * \f[
604 * \alpha = \frac{d_p}{2 \|\mathbf{u}_r\|} \|\boldsymbol{\omega}_f\|
605 * \f]
606 *
607 * and the Saffman-Mei correction coefficient \f$ C_s \f$ is:
608 *
609 * For \f$ \text{Re}_p \leq 40 \f$:
610 * \f[
611 * C_s = (1 - 0.3314\sqrt{\alpha}) \exp(-0.1\,\text{Re}_p)
612 * + 0.3314\sqrt{\alpha}
613 * \f]
614 *
615 * For \f$ \text{Re}_p > 40 \f$:
616 * \f[
617 * C_s = 0.0524\sqrt{\alpha \, \text{Re}_p}
618 * \f]
619 *
620 * where \f$ d_p \f$ is the particle diameter, \f$ \rho_f \f$ is the fluid
621 * density, \f$ \nu \f$ is the kinematic viscosity, \f$ \boldsymbol{\omega}_f
622 * \f$ is the fluid vorticity, \f$ \mathbf{u}_r \f$ is the relative velocity
623 * between the fluid and the particle, and \f$ \text{Re}_p \f$ is the particle
624 * Reynolds number.
625 *
626 * @tparam dim An integer that denotes the number of spatial dimensions.
627 * @tparam PropertiesIndex Index of the properties used within the
628 * ParticleHandler.
629 *
630 * @ingroup assemblers
631 */
632template <int dim, typename PropertiesIndex>
634 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
635{
636public:
637 /**
638 * @brief Default constructor.
639 */
641
642 /**
643 * @brief Calculate the Saffman-Mei lift force on particles.
644 *
645 * @param[in,out] scratch_data (see base class)
646 */
647 virtual void
649 NavierStokesScratchData<dim> &scratch_data) override;
650};
651
652/**
653 * @brief Assembler for the lift force using the Magnus model.
654 *
655 * This implementation follows the formulation in the book "Multiphase Flows
656 * with Droplets and Particles" by Crowe et al. (2011).
657 *
658 * The Magnus lift force is computed as:
659 * \f[
660 * \mathbf{F}_L = \frac{\pi}{8} d_p^2 \, C_m \, \rho_f \,
661 * \|\mathbf{u}_r\| \left(\hat{\boldsymbol{\omega}}_p \times
662 * \mathbf{u}_r\right)
663 * \f]
664 *
665 * where \f$ \hat{\boldsymbol{\omega}}_p =
666 * \boldsymbol{\omega}_p / \|\boldsymbol{\omega}_p\| \f$ is the unit rotational
667 * vector. The spin parameter is defined as:
668 * \f[
669 * \Omega_s = \frac{d_p \|\boldsymbol{\omega}_p\|}{2 \|\mathbf{u}_r\|}
670 * \f]
671 *
672 * The Magnus lift coefficient \f$ C_m \f$ is computed as:
673 *
674 * For \f$ 1 < \Omega_s < 6 \f$ and \f$ 10 < \text{Re}_p < 140 \f$
675 * (Oesterle and Dinh, 1998):
676 * \f[
677 * C_m = 0.45 + (2\Omega_s - 0.45)
678 * \exp\!\left(-0.075 \, \Omega_s^{0.4} \, \text{Re}_p^{0.7}\right)
679 * \f]
680 *
681 * Otherwise:
682 * \f[
683 * C_m = 2 \Omega_s
684 * \f]
685 *
686 * where \f$ d_p \f$ is the particle diameter, \f$ \rho_f \f$ is the fluid
687 * density, \f$ \mathbf{u}_r \f$ is the relative velocity between the fluid and
688 * the particle, \f$ \boldsymbol{\omega}_p \f$ is the particle angular velocity,
689 * and \f$ \text{Re}_p \f$ is the particle Reynolds number.
690 *
691 * @tparam dim An integer that denotes the number of spatial dimensions.
692 * @tparam PropertiesIndex Index of the properties used within the
693 * ParticleHandler.
694 *
695 * @ingroup assemblers
696 */
697template <int dim, typename PropertiesIndex>
699 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
700{
701public:
702 /**
703 * @brief Default constructor.
704 */
706
707 /**
708 * @brief Calculate the Magnus lift force on particles.
709 *
710 * @param[in,out] scratch_data (see base class)
711 */
712 virtual void
714 NavierStokesScratchData<dim> &scratch_data) override;
715};
716
717/**
718 * @brief Assembler for the viscous dissipative torque due to particle rotation
719 * as defined by Derksen (2004).
720 *
721 * The viscous torque due to particle rotation is:
722 * \f[
723 * \mathbf{M}_{\text{viscous}} = -\frac{\pi}{2} d_p^3 \mu
724 * \boldsymbol{\omega}_p
725 * \f]
726 *
727 * where \f$ d_p \f$ is the particle diameter, \f$ \mu = \nu \rho_f \f$ is
728 * the dynamic viscosity, and \f$ \boldsymbol{\omega}_p \f$ is the particle
729 * angular velocity. This torque opposes the particle rotation.
730 *
731 * @note The complete model described by Derksen is composed of
732 * VANSAssemblerViscousTorque + VANSAssemblerVorticalTorque.
733 *
734 * @tparam dim An integer that denotes the number of spatial dimensions.
735 * @tparam PropertiesIndex Index of the properties used within the
736 * ParticleHandler.
737 *
738 * @ingroup assemblers
739 */
740template <int dim, typename PropertiesIndex>
742 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
743{
744public:
745 /**
746 * @brief Default constructor.
747 */
749
750 /**
751 * @brief Calculate the viscous torque dissipation on particles.
752 *
753 * @param[in,out] scratch_data (see base class)
754 */
755 virtual void
757 NavierStokesScratchData<dim> &scratch_data) override;
758};
759
760/**
761 * @brief Assembler for the viscous dissipative torque due to fluid vorticity
762 * as defined by Derksen (2004).
763 *
764 * The viscous torque due to the fluid vorticity is:
765 * \f[
766 * \mathbf{M}_{\text{vorticity}} = \frac{\pi}{2} d_p^3 \mu
767 * \boldsymbol{\omega}_f
768 * \f]
769 *
770 * where \f$ d_p \f$ is the particle diameter, \f$ \mu = \nu \rho_f \f$ is
771 * the dynamic viscosity, and \f$ \boldsymbol{\omega}_f \f$ is the fluid
772 * vorticity. This torque drives the particle rotation towards the local fluid
773 * vorticity.
774 *
775 * @note The complete model described by Derksen is composed of
776 * VANSAssemblerViscousTorque + VANSAssemblerVorticalTorque.
777 *
778 * @tparam dim An integer that denotes the number of spatial dimensions.
779 * @tparam PropertiesIndex Index of the properties used within the
780 * ParticleHandler.
781 *
782 * @ingroup assemblers
783 */
784template <int dim, typename PropertiesIndex>
786 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
787{
788public:
789 /**
790 * @brief Default constructor.
791 */
793
794 /**
795 * @brief Calculate the vortical torque on particles.
796 *
797 * @param[in,out] scratch_data (see base class)
798 */
799 virtual void
801 NavierStokesScratchData<dim> &scratch_data) override;
802};
803
804/**
805 * @brief Assembler for the buoyancy force on particles in the VANS equations.
806 *
807 * The buoyancy force applied to each particle is computed as:
808 * \f[
809 * \mathbf{F}_b = -\rho_f \mathbf{g} \frac{\pi}{6} d_p^3
810 * \f]
811 *
812 * which is equivalent to \f$ -\rho_f \mathbf{g} V_p \f$, where \f$ V_p =
813 * \frac{4}{3}\pi\left(\frac{d_p}{2}\right)^3 \f$ is the particle volume,
814 * \f$ \rho_f \f$ is the fluid density, \f$ \mathbf{g} \f$ is the
815 * gravitational acceleration, and \f$ d_p \f$ is the particle diameter.
816 *
817 * @note The buoyancy force is stored as a one-way coupling force on the
818 * particle and does not generate a reaction force on the fluid.
819 *
820 * @tparam dim An integer that denotes the number of spatial dimensions.
821 * @tparam PropertiesIndex Index of the properties used within the
822 * ParticleHandler.
823 *
824 * @ingroup assemblers
825 */
826template <int dim, typename PropertiesIndex>
828 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
829{
830public:
831 /**
832 * @brief Construct a VANSAssemblerBuoyancy object.
833 *
834 * @param[in] p_gravity The gravity acceleration vector applied to the
835 * particles.
836 */
837 VANSAssemblerBuoyancy(const Tensor<1, 3> &p_gravity)
838 : gravity(p_gravity)
839 {}
840
841 /**
842 * @brief Calculate the buoyancy force on particles.
843 *
844 * @param[in,out] scratch_data (see base class)
845 */
846 virtual void
848 NavierStokesScratchData<dim> &scratch_data) override;
849
850 /// Gravity acceleration applied to the particles.
851 const Tensor<1, 3> gravity;
852};
853
854/**
855 * @brief Assembler for the pressure force on particles.
856 *
857 * The undisturbed pressure force applied to each particle is computed as:
858 * \f[
859 * \mathbf{F}_p = -\rho_f V_p \nabla p
860 * \f]
861 *
862 * where \f$ \rho_f \f$ is the fluid density, \f$ V_p = \frac{\pi}{6} d_p^3
863 * \f$ is the particle volume, \f$ d_p \f$ is the particle diameter, and
864 * \f$ \nabla p \f$ is the fluid pressure gradient evaluated at the particle
865 * location.
866 *
867 * @note When using VANS Model A, the pressure force is applied only to the
868 * particle (one-way coupling). When using Model B, the pressure force is
869 * also applied back on the fluid as a reaction force (two-way coupling).
870 *
871 * @tparam dim An integer that denotes the number of spatial dimensions.
872 * @tparam PropertiesIndex Index of the properties used within the
873 * ParticleHandler.
874 *
875 * @ingroup assemblers
876 */
877template <int dim, typename PropertiesIndex>
879 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
880{
881public:
882 /**
883 * @brief Construct a VANSAssemblerPressureForce object.
884 *
885 * @param[in] cfd_dem CFD-DEM simulation parameters.
886 */
890
891 /**
892 * @brief Calculate the pressure force on particles.
893 *
894 * @param[in,out] scratch_data (see base class)
895 */
896 virtual void
898 NavierStokesScratchData<dim> &scratch_data) override;
899
900 /// CFD-DEM simulation parameters.
902};
903
904/**
905 * @brief Assembler for the shear force on particles.
906 *
907 * The undisturbed shear (viscous stress) force applied to each particle is
908 * computed as:
909 * \f[
910 * \mathbf{F}_s = -V_p \mu \nabla^2 \mathbf{u}
911 * \f]
912 *
913 * where \f$ V_p = \frac{\pi}{6} d_p^3 \f$ is the particle volume, \f$ \mu =
914 * \nu \rho_f \f$ is the dynamic viscosity, \f$ d_p \f$ is the particle
915 * diameter, and \f$ \nabla^2 \mathbf{u} \f$ is the Laplacian of the fluid
916 * velocity evaluated at the particle location.
917 *
918 * @note When using VANS Model A, the shear force is applied only to the
919 * particle (one-way coupling). When using Model B, the shear force is also
920 * applied back on the fluid as a reaction force (two-way coupling).
921 *
922 * @tparam dim An integer that denotes the number of spatial dimensions.
923 * @tparam PropertiesIndex Index of the properties used within the
924 * ParticleHandler.
925 *
926 * @ingroup assemblers
927 */
928template <int dim, typename PropertiesIndex>
930 : public ParticleFluidAssemblerBase<dim, PropertiesIndex>
931{
932public:
933 /**
934 * @brief Construct a VANSAssemblerShearForce object.
935 *
936 * @param[in] cfd_dem CFD-DEM simulation parameters.
937 */
941
942 /**
943 * @brief Calculate the shear force on particles.
944 *
945 * @param[in,out] scratch_data (see base class)
946 */
947 virtual void
949 NavierStokesScratchData<dim> &scratch_data) override;
950
951 /// CFD-DEM simulation parameters.
953};
954
955/**
956 * @brief Assembler for the fluid-particle interactions (FPI) in the VANS
957 * equations, such as the drag force.
958 *
959 * @tparam dim An integer that denotes the number of spatial dimensions.
960 *
961 * @ingroup assemblers
962 */
963template <int dim>
965{
966public:
967 /**
968 * @brief Construct a VANSAssemblerFPI object.
969 *
970 * @param[in] cfd_dem CFD-DEM simulation parameters.
971 */
975
976 /**
977 * @brief Assemble the matrix.
978 *
979 * @param[in] scratch_data (see base class)
980 * @param[in,out] copy_data (see base class)
981 */
982 virtual void
984 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
985
986 /**
987 * @brief Assemble the right-hand side.
988 *
989 * @param[in] scratch_data (see base class)
990 * @param[in,out] copy_data (see base class)
991 */
992 virtual void
993 assemble_rhs(const NavierStokesScratchData<dim> &scratch_data,
994 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
995
996 /// CFD-DEM simulation parameters.
998};
999
1000/**
1001 * @brief Assembler for the fluid-particle interactions (FPI) in the VANS
1002 * equations when the forces are projected from the particles to the fluid grid.
1003 *
1004 * @tparam dim An integer that denotes the number of spatial dimensions.
1005 *
1006 * @ingroup assemblers
1007 */
1008template <int dim>
1010{
1011public:
1012 /**
1013 * @brief Construct a VANSAssemblerFPIProjection object.
1014 *
1015 * @param[in] cfd_dem CFD-DEM simulation parameters.
1016 */
1020
1021 /**
1022 * @brief Assemble the matrix.
1023 *
1024 * @param[in] scratch_data (see base class)
1025 * @param[in,out] copy_data (see base class)
1026 */
1027 virtual void
1029 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
1030
1031 /**
1032 * @brief Assemble the right-hand side.
1033 *
1034 * @param[in] scratch_data (see base class)
1035 * @param[in,out] copy_data (see base class)
1036 */
1037 virtual void
1038 assemble_rhs(const NavierStokesScratchData<dim> &scratch_data,
1039 StabilizedMethodsTensorCopyData<dim> &copy_data) override;
1040
1041 /// CFD-DEM simulation parameters.
1043};
1044
1045/**
1046 * @brief Calculate the grad-div stabilization constant \f$ \gamma \f$ for the
1047 * VANS equations.
1048 *
1049 * The stabilization constant is computed as:
1050 * \f[
1051 * \gamma = \nu + c^* \|\mathbf{u}\|
1052 * \f]
1053 *
1054 * where \f$ \nu \f$ is the kinematic viscosity, \f$ c^* \f$ is a scaling
1055 * constant with units of length, and \f$ \|\mathbf{u}\| \f$ is the magnitude
1056 * of the velocity at the quadrature point.
1057 *
1058 * @param[in] velocity Magnitude of the velocity at the quadrature point.
1059 * @param[in] kinematic_viscosity Kinematic viscosity of the fluid.
1060 * @param[in] h The element size (unused).
1061 * @param[in] c_star Scaling constant with units of length.
1062 *
1063 * @return The grad-div stabilization constant \f$ \gamma \f$.
1064 */
1065inline double
1067 double kinematic_viscosity,
1068 double /*h*/,
1069 double c_star)
1070{
1071 return kinematic_viscosity + c_star * velocity;
1072}
1073#endif
Class that stores the information required by the assembly procedure for a Navier-Stokes equation....
Interface for all assemblers of particle-fluid interactions in the VANS equations.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data)=0
Calculate the particle-fluid interaction for all particles in a cell.
virtual ~ParticleFluidAssemblerBase()=default
Default destructor.
Class responsible for storing the information calculated using the assembly of stabilized Tensor<1,...
Definition copy_data.h:166
VANSAssemblerBDF(const std::shared_ptr< SimulationControl > &simulation_control, const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerBDF object.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the matrix.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the right-hand side.
const std::shared_ptr< SimulationControl > simulation_control
Shared pointer to the simulation control object.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
VANSAssemblerBeetstra(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerBeetstra object.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Beetstra model....
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the buoyancy force on particles.
VANSAssemblerBuoyancy(const Tensor< 1, 3 > &p_gravity)
Construct a VANSAssemblerBuoyancy object.
const Tensor< 1, 3 > gravity
Gravity acceleration applied to the particles.
const bool SUPG
Flag indicating whether SUPG stabilization is used.
const std::shared_ptr< SimulationControl > simulation_control
Shared pointer to the simulation control object.
VANSAssemblerCoreModelA(const std::shared_ptr< SimulationControl > &simulation_control, const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerCoreModelA object.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the right-hand side.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the matrix.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
const std::shared_ptr< SimulationControl > simulation_control
Shared pointer to the simulation control object.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the matrix.
VANSAssemblerCoreModelB(const std::shared_ptr< SimulationControl > &simulation_control, const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerCoreModelB object.
const bool SUPG
Flag indicating whether SUPG stabilization is used.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the right-hand side.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Dallavalle model.
VANSAssemblerDallavalle(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerDallavalle object.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Di Felice model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
VANSAssemblerDiFelice(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerDiFelice object.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the right-hand side.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the matrix.
VANSAssemblerFPIProjection(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerFPIProjection object.
virtual void assemble_matrix(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the matrix.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
VANSAssemblerFPI(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerFPI object.
virtual void assemble_rhs(const NavierStokesScratchData< dim > &scratch_data, StabilizedMethodsTensorCopyData< dim > &copy_data) override
Assemble the right-hand side.
VANSAssemblerGidaspow(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerGidaspow object.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Gidaspow model.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Koch-Hill model.
VANSAssemblerKochHill(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerKochHill object.
VANSAssemblerMagnus()=default
Default constructor.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the Magnus lift force on particles.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
VANSAssemblerPressureForce(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerPressureForce object.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the pressure force on particles.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
VANSAssemblerRong(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerRong object.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the particle-fluid interactions resulting from drag, using the Rong model.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the Saffman-Mei lift force on particles.
VANSAssemblerSaffmanMei()=default
Default constructor.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the shear force on particles.
VANSAssemblerShearForce(const Parameters::CFDDEM &cfd_dem)
Construct a VANSAssemblerShearForce object.
const Parameters::CFDDEM cfd_dem
CFD-DEM simulation parameters.
VANSAssemblerViscousTorque()=default
Default constructor.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the viscous torque dissipation on particles.
virtual void calculate_particle_fluid_interactions(NavierStokesScratchData< dim > &scratch_data) override
Calculate the vortical torque on particles.
VANSAssemblerVorticalTorque()=default
Default constructor.
@ velocity
Velocity vector field from fluid dynamics.
PhysicsAssemblerBase< NavierStokesScratchData< dim >, StabilizedMethodsTensorCopyData< dim > > NavierStokesAssemblerBase
A pure virtual class that serves as an interface for all of the assemblers for the Navier-Stokes Equa...
Simulation control classes for managing time-stepping and iteration control in Lethe.
Parameters for the CFD-DEM coupled solver.
double calculate_gamma(double velocity, double kinematic_viscosity, double, double c_star)
Calculate the grad-div stabilization constant for the VANS equations.