Lethe Open-Source Library version 1.2.0
Developer Guide
Loading...
Searching...
No Matches
cahn_hilliard.h
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Copyright (c) 2023-2026 The Lethe Authors
2// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
3
4/*
5 * Implementation of the Cahn-Hilliard equations as an auxiliary physics.
6 * Equations solved:
7 * dPhi/dt + u * gradPhi = div(M(Phi)*grad eta)
8 * eta - f(Phi) + epsilon^2 * div(grad Phi) = 0
9 * with Phi the phase field parameter (or phase order), eta the chemical
10 * potential, and M the mobility function and epsilon the interface thickness.
11 * The phase field parameter must not be confused with the order (respectively
12 * phase_cahn_hilliard_order and potential_cahn_hilliard_order) of the finite
13 * elements related to the phase field parameter and the chemical potential.
14 */
15
16#ifndef lethe_cahn_hilliard_h
17#define lethe_cahn_hilliard_h
18
19#include <core/bdf.h>
21#include <core/vector.h>
22
28
29#include <deal.II/base/convergence_table.h>
30#include <deal.II/base/quadrature_lib.h>
31#include <deal.II/base/timer.h>
32
33#include <deal.II/distributed/tria_base.h>
34
35#include <deal.II/fe/fe_q.h>
36#include <deal.II/fe/fe_simplex_p.h>
37#include <deal.II/fe/mapping_fe.h>
38#include <deal.II/fe/mapping_q.h>
39
40#include <deal.II/grid/grid_tools.h>
41
42#include <deal.II/lac/trilinos_precondition.h>
43#include <deal.II/lac/trilinos_sparse_matrix.h>
44#include <deal.II/lac/trilinos_vector.h>
45
46#include <deal.II/numerics/solution_transfer.h>
47
48#include <utility>
49
51 CahnHilliardBoundaryConditionMissing,
52 types::boundary_id,
53 << "The boundary id: " << arg1
54 << " is defined in the triangulation, but not as a boundary condition for the Cahn Hilliard physics. Lethe does not assign a default boundary condition to boundary ids. Every boundary id defined within the triangulation must have a corresponding boundary condition defined in the input file.");
55
56
57
58template <int dim>
59class CahnHilliard : public AuxiliaryPhysics<dim, GlobalVectorType>
60{
61public:
63 MultiphysicsInterface<dim> *multiphysics_interface,
64 const SimulationParameters<dim> &p_simulation_parameters,
65 const std::shared_ptr<parallel::DistributedTriangulationBase<dim>>
66 &p_triangulation,
67 std::shared_ptr<SimulationControl> p_simulation_control)
69 p_simulation_parameters.physics_solving_strategy.at(
71 , multiphysics(multiphysics_interface)
72 , computing_timer(p_triangulation->get_mpi_communicator(),
73 this->pcout,
74 TimerOutput::never,
75 TimerOutput::wall_times)
76 , simulation_parameters(p_simulation_parameters)
77 , triangulation(p_triangulation)
78 , simulation_control(std::move(p_simulation_control))
79 , dof_handler(std::make_shared<DoFHandler<dim>>(*triangulation))
80 {
81 this->pcout << std::setprecision(simulation_control->get_log_precision())
82 << std::scientific;
83
84 if (simulation_parameters.mesh.simplex)
85 {
86 // for simplex meshes
87 fe = std::make_shared<FESystem<dim>>(
88 FE_SimplexP<dim>(
89 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree),
90 1,
91 FE_SimplexP<dim>(simulation_parameters.fem_parameters
92 .potential_cahn_hilliard_degree),
93 1);
94 mapping = std::make_shared<MappingFE<dim>>(*fe);
95 cell_quadrature = std::make_shared<QGaussSimplex<dim>>(
96 std::max(
97 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree,
98 simulation_parameters.fem_parameters
99 .potential_cahn_hilliard_degree) +
100 1);
101 face_quadrature = std::make_shared<QGaussSimplex<dim - 1>>(
102 std::max(
103 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree,
104 simulation_parameters.fem_parameters
105 .potential_cahn_hilliard_degree) +
106 1);
107 ;
108 }
109 else
110 {
111 // Usual case, for quad/hex meshes
112 fe = std::make_shared<FESystem<dim>>(
113 FE_Q<dim>(
114 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree),
115 1,
116 FE_Q<dim>(simulation_parameters.fem_parameters
117 .potential_cahn_hilliard_degree),
118 1);
119 mapping = std::make_shared<MappingQ<dim>>(std::max(
120 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree,
121 simulation_parameters.fem_parameters.potential_cahn_hilliard_degree));
122 cell_quadrature = std::make_shared<QGauss<dim>>(
123 std::max(
124 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree,
125 simulation_parameters.fem_parameters
126 .potential_cahn_hilliard_degree) +
127 1);
128 face_quadrature = std::make_shared<QGauss<dim - 1>>(
129 std::max(
130 simulation_parameters.fem_parameters.phase_cahn_hilliard_degree,
131 simulation_parameters.fem_parameters
132 .potential_cahn_hilliard_degree) +
133 1);
134 }
135
136 // Allocate solution transfer
138 std::make_shared<SolutionTransfer<dim, GlobalVectorType>>(*dof_handler);
139
140 // Initialize and set size of previous solutions using BDF schemes
141 // information
142 previous_solutions = std::make_shared<std::vector<GlobalVectorType>>(
144
145 // Prepare previous solutions transfer
147 for (unsigned int i = 0; i < previous_solutions->size(); ++i)
148 {
149 previous_solutions_transfer.emplace_back(
150 SolutionTransfer<dim, GlobalVectorType>(*this->dof_handler));
151 }
152
153 // Initialize solutions shared_ptr
154 present_solution = std::make_shared<GlobalVectorType>();
155 filtered_solution = std::make_shared<GlobalVectorType>();
156 }
157
158 /**
159 * @brief Gather and return vector of output structs that are particular to some applications.
160 *
161 * @return Vector of OutputStructs that will be used to write the output results as VTU files.
162 */
163 std::vector<OutputStruct<dim, GlobalVectorType>>
164 gather_output_hook() override;
165
166 /**
167 * @brief Calculates the L2 error of the solution
168 */
169 std::pair<double, double>
171
172 /**
173 * @brief Carry out the operations required to finish a simulation correctly.
174 */
175 void
176 finish_simulation() override;
177
178 /**
179 * @brief Rearrange vector solution correctly for transient simulations
180 */
181 void
182 percolate_time_vectors() override;
183
184 /**
185 * @brief Carry out modifications on the auxiliary physic solution.
186 */
187 void
188 modify_solution() override;
189
190 /**
191 * @brief Postprocess the auxiliary physics results. Post-processing this case implies
192 * the calculation of all derived quantities using the solution vector of the
193 * physics. It does not concern the output of the solution using the
194 * DataOutObject, which is accomplished through the attach_solution_to_output
195 * function
196 */
197 void
198 postprocess(bool first_iteration) override;
199
200 /**
201 * @brief Output the per iteration wallclock times.
202 */
203 void
205
206 /**
207 * @brief pre_mesh_adaption Prepares the auxiliary physics variables for a
208 * mesh refinement/coarsening
209 */
210 void
211 pre_mesh_adaptation() override;
212
213 /**
214 * @brief post_mesh_adaption Interpolates the auxiliary physics variables to the new mesh
215 */
216 void
217 post_mesh_adaptation() override;
218
219 /**
220 * @brief Compute the error estimator for mesh refinement.
221 *
222 * @param[in] ivar The current element of the map
223 * simulation_parameters.mesh_adaptation.variables
224 *
225 * @param[in,out] estimated_error_per_cell The deal.II vector of
226 * estimated_error_per_cell
227 */
228 void
230 const std::pair<const Variable, Parameters::MultipleAdaptationParameters>
231 &ivar,
232 dealii::Vector<float> &estimated_error_per_cell) override;
233
234 /**
235 * @brief Compute the Kelly error estimator on the phase variable for mesh refinement.
236 * See :
237 * https://www.dealii.org/current/doxygen/deal.II/classKellyErrorEstimator.html
238 * for more information on the Kelly error estimator.
239 *
240 * @param[in,out] estimated_error_per_cell The deal.II vector of
241 * estimated_error_per_cell
242 * @param[in] component_mask The component mask corresponding to the phase
243 * variable
244 */
245 void
246 compute_kelly(dealii::Vector<float> &estimated_error_per_cell,
247 const ComponentMask &component_mask);
248
249
250 /**
251 * @brief Prepares Cahn-Hilliard to write checkpoint
252 */
253 void
254 write_checkpoint() override;
255
256 /**
257 * @brief Allows Cahn-Hilliard physics to set-up solution vector from checkpoint file;
258 */
259 void
260 read_checkpoint() override;
261
262 /**
263 * @brief Returns a vector of references to TableHandler objects that needs to
264 * be serialized/deserialized for the Cahn-Hilliard solver.
265 *
266 * @return Structure containing the TableHandler objects and their corresponding file names.
267 */
268 std::vector<OutputStructTableHandler>
269 gather_tables() override;
270
271 /**
272 * @brief Returns the dof_handler of the Cahn-Hilliard physics
273 */
274 const DoFHandler<dim> &
276 {
277 return *dof_handler;
278 }
279
280 /**
281 * @brief Sets-up the DofHandler and the degree of freedom associated with the physics.
282 */
283 void
284 setup_dofs() override;
285
286 /**
287 * @brief Sets-up the initial conditions associated with the physics. Generally, physics
288 * only support imposing nodal values, but some physics additionally support
289 * the use of L2 projection or steady-state solutions.
290 */
291 void
292 set_initial_conditions() override;
293
294 /**
295 * @brief Update non zero constraints if the boundary is time-dependent
296 */
297 void
299
300 /**
301 * @brief Call for the solution of the linear system of equation using a strategy appropriate
302 * to the auxiliary physics
303 *
304 */
305 void
306 solve_linear_system() override;
307
308 /**
309 * @brief Set up the ILU preconditioner stored in ilu_preconditioner.
310 */
311 void
312 setup_ilu();
313
314 /**
315 * @brief Set up the AMG preconditioner stored in amg_preconditioner.
316 */
317 void
318 setup_amg();
319
320 /**
321 * @brief Getter methods to get the private attributes for the physic currently solved
322 * NB : dof_handler and present_solution are passed to the multiphysics
323 * interface at the end of the setup_dofs method
324 */
327 {
328 return evaluation_point;
329 }
332 {
334 }
337 {
338 return newton_update;
339 }
342 {
343 return *present_solution;
344 }
346 get_system_rhs() override
347 {
348 return system_rhs;
349 }
350 AffineConstraints<double> &
352 {
353 return nonzero_constraints;
354 }
355
356 /**
357 * @brief Output the L2 and Linfty norms of the correction vector.
358 */
359 void
361
362 /**
363 * @brief Return the metric for residual rescaling. By default, should return 1.
364 * If the rescale_residual_by_volume is set to true, the method
365 * returns the square root of the global volume of the triangulation.
366 *
367 * @return Rescale metric.
368 */
369 double
371 {
372 return simulation_parameters.linear_solver.at(PhysicsID::cahn_hilliard)
373 .rescale_residual_by_volume ?
374 std::sqrt(
375 GridTools::volume(*this->triangulation, *this->mapping)) :
376 1.;
377 }
378
379
380private:
381 /**
382 * @brief Verify consistency of the input parameters for boundary
383 * conditions to ensure that for every boundary condition within the
384 * triangulation, a boundary condition has been specified in the input file.
385 */
386 void
388 {
389 // Sanity check all of the boundary conditions of the triangulation to
390 // ensure that they have a type.
391 std::vector<types::boundary_id> boundary_ids_in_triangulation =
392 this->triangulation->get_boundary_ids();
393 for (auto const &boundary_id_in_tria : boundary_ids_in_triangulation)
394 {
395 AssertThrow(
396 simulation_parameters.cahn_hilliard_boundary_conditions.type.find(
397 boundary_id_in_tria) !=
398 simulation_parameters.cahn_hilliard_boundary_conditions.type.end(),
399 CahnHilliardBoundaryConditionMissing(boundary_id_in_tria));
400 }
401 }
402
403 /**
404 * @brief Assembles the matrix associated with the solver
405 */
406 void
407 assemble_system_matrix() override;
408
409 /**
410 * @brief Assemble the rhs associated with the solver
411 */
412 void
413 assemble_system_rhs() override;
414
415
416 /**
417 * @brief Assemble the local matrix for a given cell.
418 *
419 * This function is used by the WorkStream class to assemble
420 * the system matrix. It is a thread safe function.
421 *
422 * @param cell The cell for which the local matrix is assembled.
423 *
424 * @param scratch_data The scratch data which is used to store
425 * the calculated finite element information at the gauss point.
426 * See the documentation for CahnHilliardScratchData for more
427 * information
428 *
429 * @param copy_data The copy data which is used to store
430 * the results of the assembly over a cell
431 */
432 virtual void
434 const typename DoFHandler<dim>::active_cell_iterator &cell,
435 CahnHilliardScratchData<dim> &scratch_data,
436 StabilizedMethodsCopyData &copy_data);
437
438 /**
439 * @brief Assemble the local rhs for a given cell
440 *
441 * @param cell The cell for which the local matrix is assembled.
442 *
443 * @param scratch_data The scratch data which is used to store
444 * the calculated finite element information at the gauss point.
445 * See the documentation for CahnHilliardScratchData for more
446 * information
447 *
448 * @param copy_data The copy data which is used to store
449 * the results of the assembly over a cell
450 */
451 virtual void
453 const typename DoFHandler<dim>::active_cell_iterator &cell,
454 CahnHilliardScratchData<dim> &scratch_data,
455 StabilizedMethodsCopyData &copy_data);
456
457 /**
458 * @brief sets up the vector of assembler functions
459 */
460 virtual void
462
463
464 /**
465 * @brief Copy local cell information to global matrix
466 */
467
468 virtual void
470 const StabilizedMethodsCopyData &copy_data);
471
472 /**
473 * @brief Copy local cell rhs information to global rhs
474 */
475
476 virtual void
478
479 /**
480 * @brief Calculate phase statistics for monitoring purposes
481 */
482 void
484
485 /**
486 * @brief Writes the phase statistics to an output file
487 */
488 void
490
491 /**
492 *
493 * @brief Calculate the phase energies : bulk energy, interface energy and total energy.
494 */
495 void
497
498 /*
499 * @brief Write the energy to an output file
500 */
501 void
503
504 /**
505 * @brief Calculates the barycenter of fluid 1 and its velocity
506 *
507 * @param solution Cahn-Hilliard solution
508 *
509 * @param current_solution_fd Fluid dynamics solution
510 *
511 */
512 template <typename VectorType>
513 std::pair<Tensor<1, dim>, Tensor<1, dim>>
515 const VectorType &current_solution_fd);
516
517 /**
518 * @brief Applies filter on phase fraction values.
519 */
520 void
522
523
525
526 TimerOutput computing_timer;
527
529
530
531 // Core elements for the Cahn-Hilliard equations variables (Phi and eta)
532 std::shared_ptr<parallel::DistributedTriangulationBase<dim>> triangulation;
533 std::shared_ptr<SimulationControl> simulation_control;
534 std::shared_ptr<DoFHandler<dim>> dof_handler;
535
536 // Finite element space
537 std::shared_ptr<FESystem<dim>> fe;
538 // Mapping and Quadrature
539 std::shared_ptr<Mapping<dim>> mapping;
540 std::shared_ptr<Quadrature<dim>> cell_quadrature;
541 std::shared_ptr<Quadrature<dim - 1>> face_quadrature;
542
543
544 ConvergenceTable error_table;
545
546 // Solution storage:
549
553 std::shared_ptr<GlobalVectorType> present_solution;
555 AffineConstraints<double> nonzero_constraints;
556 AffineConstraints<double> zero_constraints;
557 TrilinosWrappers::SparseMatrix system_matrix;
558
559 /**
560 * @brief ILU preconditioner used by the iterative linear solver.
561 */
562 std::shared_ptr<TrilinosWrappers::PreconditionILU> ilu_preconditioner;
563
564 /**
565 * @brief AMG preconditioner used by the iterative linear solver.
566 */
567 std::shared_ptr<TrilinosWrappers::PreconditionAMG> amg_preconditioner;
568
569 std::shared_ptr<GlobalVectorType> filtered_solution;
570
571
572 // Previous solutions vectors
573 std::shared_ptr<std::vector<GlobalVectorType>> previous_solutions;
574
575 // Solution transfer classes
576 std::shared_ptr<SolutionTransfer<dim, GlobalVectorType>> solution_transfer;
577 std::vector<SolutionTransfer<dim, GlobalVectorType>>
579
580 // Assemblers for the matrix and rhs
581 std::vector<std::shared_ptr<CahnHilliardAssemblerBase<dim>>> assemblers;
582
583 // Barycenter analysis
584 TableHandler barycenter_table;
585
586 // Phase statistics table
587 TableHandler statistics_table;
588
589 // Phase energy table
590 TableHandler phase_energy_table;
591
592 // Phase fraction filter
593 std::shared_ptr<CahnHilliardFilterBase> filter;
594};
595
596
597#endif
unsigned int maximum_number_of_previous_solutions()
Get the maximum number of previous time steps supposed by the BDF schemes implemented in Lethe.
Definition bdf.h:84
DeclException1(CahnHilliardBoundaryConditionMissing, types::boundary_id,<< "The boundary id: "<< arg1<< " is defined in the triangulation, but not as a boundary condition for the Cahn Hilliard physics. Lethe does not assign a default boundary condition to boundary ids. Every boundary id defined within the triangulation must have a corresponding boundary condition defined in the input file.")
AuxiliaryPhysics(const Parameters::NonLinearSolver non_linear_solver_parameters)
Class that stores the information required by the assembly procedure for the Cahn-Hilliard equations....
void apply_phase_filter()
Applies filter on phase fraction values.
std::vector< OutputStructTableHandler > gather_tables() override
Returns a vector of references to TableHandler objects that needs to be serialized/deserialized for t...
virtual void setup_assemblers()
sets up the vector of assembler functions
std::shared_ptr< TrilinosWrappers::PreconditionAMG > amg_preconditioner
AMG preconditioner used by the iterative linear solver.
void verify_consistency_of_boundary_conditions()
Verify consistency of the input parameters for boundary conditions to ensure that for every boundary ...
std::shared_ptr< DoFHandler< dim > > dof_handler
std::shared_ptr< TrilinosWrappers::PreconditionILU > ilu_preconditioner
ILU preconditioner used by the iterative linear solver.
TrilinosWrappers::SparseMatrix system_matrix
TableHandler barycenter_table
GlobalVectorType newton_update
void solve_linear_system() override
Call for the solution of the linear system of equation using a strategy appropriate to the auxiliary ...
TimerOutput computing_timer
std::shared_ptr< Quadrature< dim - 1 > > face_quadrature
std::shared_ptr< std::vector< GlobalVectorType > > previous_solutions
void finish_simulation() override
Carry out the operations required to finish a simulation correctly.
virtual void copy_local_matrix_to_global_matrix(const StabilizedMethodsCopyData &copy_data)
Copy local cell information to global matrix.
void compute_kelly(dealii::Vector< float > &estimated_error_per_cell, const ComponentMask &component_mask)
Compute the Kelly error estimator on the phase variable for mesh refinement. See : https://www....
IndexSet locally_relevant_dofs
std::vector< std::shared_ptr< CahnHilliardAssemblerBase< dim > > > assemblers
std::shared_ptr< parallel::DistributedTriangulationBase< dim > > triangulation
void setup_amg()
Set up the AMG preconditioner stored in amg_preconditioner.
const DoFHandler< dim > & get_dof_handler() override
Returns the dof_handler of the Cahn-Hilliard physics.
IndexSet locally_owned_dofs
std::shared_ptr< GlobalVectorType > filtered_solution
std::shared_ptr< FESystem< dim > > fe
void setup_dofs() override
Sets-up the DofHandler and the degree of freedom associated with the physics.
void assemble_system_matrix() override
Assembles the matrix associated with the solver.
void modify_solution() override
Carry out modifications on the auxiliary physic solution.
void setup_ilu()
Set up the ILU preconditioner stored in ilu_preconditioner.
std::shared_ptr< SimulationControl > simulation_control
GlobalVectorType system_rhs
void write_phase_statistics()
Writes the phase statistics to an output file.
GlobalVectorType & get_newton_update() override
virtual void copy_local_rhs_to_global_rhs(const StabilizedMethodsCopyData &copy_data)
Copy local cell rhs information to global rhs.
GlobalVectorType & get_evaluation_point() override
Getter methods to get the private attributes for the physic currently solved NB : dof_handler and pre...
TableHandler phase_energy_table
MultiphysicsInterface< dim > * multiphysics
GlobalVectorType & get_local_evaluation_point() override
GlobalVectorType local_evaluation_point
GlobalVectorType evaluation_point
std::pair< Tensor< 1, dim >, Tensor< 1, dim > > calculate_barycenter(const GlobalVectorType &solution, const VectorType &current_solution_fd)
Calculates the barycenter of fluid 1 and its velocity.
std::shared_ptr< CahnHilliardFilterBase > filter
AffineConstraints< double > nonzero_constraints
void post_mesh_adaptation() override
post_mesh_adaption Interpolates the auxiliary physics variables to the new mesh
std::shared_ptr< SolutionTransfer< dim, GlobalVectorType > > solution_transfer
void read_checkpoint() override
Allows Cahn-Hilliard physics to set-up solution vector from checkpoint file;.
void write_checkpoint() override
Prepares Cahn-Hilliard to write checkpoint.
void assemble_system_rhs() override
Assemble the rhs associated with the solver.
std::vector< SolutionTransfer< dim, GlobalVectorType > > previous_solutions_transfer
std::shared_ptr< Quadrature< dim > > cell_quadrature
std::shared_ptr< Mapping< dim > > mapping
AffineConstraints< double > zero_constraints
void write_phase_energy()
virtual void assemble_local_system_rhs(const typename DoFHandler< dim >::active_cell_iterator &cell, CahnHilliardScratchData< dim > &scratch_data, StabilizedMethodsCopyData &copy_data)
Assemble the local rhs for a given cell.
void percolate_time_vectors() override
Rearrange vector solution correctly for transient simulations.
void calculate_phase_statistics()
Calculate phase statistics for monitoring purposes.
ConvergenceTable error_table
double get_residual_rescale_metric() const override
Return the metric for residual rescaling. By default, should return 1. If the rescale_residual_by_vol...
CahnHilliard(MultiphysicsInterface< dim > *multiphysics_interface, const SimulationParameters< dim > &p_simulation_parameters, const std::shared_ptr< parallel::DistributedTriangulationBase< dim > > &p_triangulation, std::shared_ptr< SimulationControl > p_simulation_control)
std::shared_ptr< GlobalVectorType > present_solution
GlobalVectorType & get_present_solution() override
void set_initial_conditions() override
Sets-up the initial conditions associated with the physics. Generally, physics only support imposing ...
const SimulationParameters< dim > & simulation_parameters
AffineConstraints< double > & get_nonzero_constraints() override
void postprocess(bool first_iteration) override
Postprocess the auxiliary physics results. Post-processing this case implies the calculation of all d...
void calculate_phase_energy()
Calculate the phase energies : bulk energy, interface energy and total energy.
GlobalVectorType & get_system_rhs() override
void output_per_iteration_timer() override
Output the per iteration wallclock times.
TableHandler statistics_table
virtual void assemble_local_system_matrix(const typename DoFHandler< dim >::active_cell_iterator &cell, CahnHilliardScratchData< dim > &scratch_data, StabilizedMethodsCopyData &copy_data)
Assemble the local matrix for a given cell.
std::pair< double, double > calculate_L2_error()
Calculates the L2 error of the solution.
void update_boundary_conditions() override
Update non zero constraints if the boundary is time-dependent.
void pre_mesh_adaptation() override
pre_mesh_adaption Prepares the auxiliary physics variables for a mesh refinement/coarsening
void compute_error_estimate(const std::pair< const Variable, Parameters::MultipleAdaptationParameters > &ivar, dealii::Vector< float > &estimated_error_per_cell) override
Compute the error estimator for mesh refinement.
std::vector< OutputStruct< dim, GlobalVectorType > > gather_output_hook() override
Gather and return vector of output structs that are particular to some applications.
void output_newton_update_norms() override
Output the L2 and Linfty norms of the correction vector.
PhysicsSolverStrategy< GlobalVectorType > * physics_solving_strategy
Class responsible for storing the information calculated using the assembly of stabilized scalar equa...
Definition copy_data.h:67
PhysicsID
Unique identifiers for each physics module in Lethe.
@ cahn_hilliard
Cahn-Hilliard (Phase indicator, Potential).
Simulation control classes for managing time-stepping and iteration control in Lethe.
GlobalVectorType VectorType
dealii::TrilinosWrappers::MPI::Vector GlobalVectorType
Definition vector.h:17