18 const std::vector<double> &diffusivity_vector =
23 const auto &JxW_vec = scratch_data.
JxW;
24 const unsigned int n_q_points = scratch_data.
n_q_points;
25 const unsigned int n_dofs = scratch_data.
n_dofs;
29 std::vector<double> time_steps_vector =
31 const double dt = time_steps_vector[0];
32 const double sdt = 1. / dt;
39 for (
unsigned int q = 0; q < n_q_points; ++q)
42 const double diffusivity = diffusivity_vector[q];
47 const double JxW = JxW_vec[q];
58 const Tensor<1, dim> tracer_gradient_for_dcdd =
61 const double tracer_gradient_for_dcdd_norm =
62 tracer_gradient_for_dcdd.norm();
68 pow(tracer_gradient_for_dcdd.norm() * h, order);
70 const double tolerance = 1e-12;
73 tracer_gradient_for_dcdd / (tracer_gradient_for_dcdd_norm + tolerance);
75 const Tensor<2, dim> k_corr = (r * s) * outer_product(s, s);
76 const Tensor<2, dim> rr = outer_product(r, r);
77 const Tensor<2, dim> dcdd_factor = rr - k_corr;
82 const double d_vdcdd =
85 pow(tracer_gradient_for_dcdd_norm * h, order - 1) :
90 const double u_mag = std::max(
velocity.norm(), tolerance);
98 1. / std::sqrt(std::pow(2. * u_mag / h, 2) +
99 9 * std::pow(4 * diffusivity / (h * h), 2)) :
100 1. / std::sqrt(std::pow(sdt, 2) + std::pow(2. * u_mag / h, 2) +
101 9 * std::pow(4 * diffusivity / (h * h), 2));
103 for (
unsigned int j = 0; j < n_dofs; ++j)
105 const Tensor<1, dim> &grad_phi_C_j = scratch_data.
grad_phi[q][j];
106 const double &laplacian_phi_C_j = scratch_data.
laplacian_phi[q][j];
107 strong_jacobian_vec[q][j] +=
108 velocity * grad_phi_C_j - diffusivity * laplacian_phi_C_j;
111 for (
unsigned int i = 0; i < n_dofs; ++i)
113 const double &phi_C_i = scratch_data.
phi[q][i];
114 const Tensor<1, dim> &grad_phi_C_i = scratch_data.
grad_phi[q][i];
116 for (
unsigned int j = 0; j < n_dofs; ++j)
118 const Tensor<1, dim> &grad_phi_C_j = scratch_data.
grad_phi[q][j];
121 local_matrix(i, j) += (diffusivity * grad_phi_C_i * grad_phi_C_j +
122 phi_C_i *
velocity * grad_phi_C_j) *
126 local_matrix(i, j) += tau * strong_jacobian_vec[q][j] *
130 local_matrix(i, j) +=
132 scalar_product(grad_phi_C_i, dcdd_factor * grad_phi_C_j) +
133 d_vdcdd * grad_phi_C_j.norm() *
134 scalar_product(grad_phi_C_i,
135 dcdd_factor * tracer_gradient)) *
150 const std::vector<double> &diffusivity_vector =
155 const auto &JxW_vec = scratch_data.
JxW;
156 const unsigned int n_q_points = scratch_data.
n_q_points;
157 const unsigned int n_dofs = scratch_data.
n_dofs;
161 std::vector<double> time_steps_vector =
163 const double dt = time_steps_vector[0];
164 const double sdt = 1. / dt;
171 for (
unsigned int q = 0; q < n_q_points; ++q)
174 const double diffusivity = diffusivity_vector[q];
176 const Tensor<1, dim> &previous_tracer_gradient =
182 const double JxW = JxW_vec[q];
186 const Tensor<1, dim> tracer_gradient_for_dcdd =
187 is_steady(method) ? tracer_gradient : previous_tracer_gradient;
188 const double tracer_gradient_for_dcdd_norm =
189 tracer_gradient_for_dcdd.norm();
196 pow(tracer_gradient_for_dcdd_norm * h, order);
198 const double tolerance = 1e-12;
201 tracer_gradient_for_dcdd / (tracer_gradient_for_dcdd_norm + tolerance);
203 const Tensor<2, dim> k_corr = (r * s) * outer_product(s, s);
204 const Tensor<2, dim> rr = outer_product(r, r);
205 const Tensor<2, dim> dcdd_factor = rr - k_corr;
209 const double u_mag = std::max(
velocity.norm(), tolerance);
217 1. / std::sqrt(std::pow(2. * u_mag / h, 2) +
218 9 * std::pow(4 * diffusivity / (h * h), 2)) :
219 1. / std::sqrt(std::pow(sdt, 2) + std::pow(2. * u_mag / h, 2) +
220 9 * std::pow(4 * diffusivity / (h * h), 2));
223 strong_residual_vec[q] +=
224 velocity * tracer_gradient - diffusivity * tracer_laplacian;
226 for (
unsigned int i = 0; i < n_dofs; ++i)
228 const double &phi_C_i = scratch_data.
phi[q][i];
229 const Tensor<1, dim> &grad_phi_C_i = scratch_data.
grad_phi[q][i];
232 local_rhs(i) -= (diffusivity * grad_phi_C_i * tracer_gradient +
233 phi_C_i *
velocity * tracer_gradient -
234 scratch_data.
source[q] * phi_C_i) *
239 tau * (strong_residual_vec[q] * (grad_phi_C_i *
velocity)) * JxW;
244 scalar_product(grad_phi_C_i, dcdd_factor * tracer_gradient) * JxW;
259 const std::vector<double> &diffusivity_vector =
263 const auto &JxW_vec = scratch_data.
JxW;
264 const unsigned int n_q_points = scratch_data.
n_q_points;
265 const unsigned int n_dofs = scratch_data.
n_dofs;
271 for (
unsigned int q = 0; q < n_q_points; ++q)
274 const double diffusivity = diffusivity_vector[q];
279 const double JxW = JxW_vec[q];
281 for (
unsigned int i = 0; i < n_dofs; ++i)
283 const double &phi_C_i = scratch_data.
phi[q][i];
284 const Tensor<1, dim> &grad_phi_C_i = scratch_data.
grad_phi[q][i];
286 for (
unsigned int j = 0; j < n_dofs; ++j)
288 const double &phi_C_j = scratch_data.
phi[q][j];
289 const Tensor<1, dim> &grad_phi_C_j = scratch_data.
grad_phi[q][j];
294 local_matrix(i, j) += (diffusivity * grad_phi_C_i * grad_phi_C_j -
295 grad_phi_C_i *
velocity * phi_C_j) *
300 local_matrix(i, j) +=
301 -phi_C_i * velocity_divergence * phi_C_j * JxW;
315 const std::vector<double> &diffusivity_vector =
319 const auto &JxW_vec = scratch_data.
JxW;
320 const unsigned int n_q_points = scratch_data.
n_q_points;
321 const unsigned int n_dofs = scratch_data.
n_dofs;
327 for (
unsigned int q = 0; q < n_q_points; ++q)
330 const double diffusivity = diffusivity_vector[q];
337 const double JxW = JxW_vec[q];
339 for (
unsigned int i = 0; i < n_dofs; ++i)
341 const double &phi_C_i = scratch_data.
phi[q][i];
342 const Tensor<1, dim> &grad_phi_C_i = scratch_data.
grad_phi[q][i];
345 local_rhs(i) -= (diffusivity * grad_phi_C_i * tracer_gradient -
346 grad_phi_C_i *
velocity * tracer_value -
347 scratch_data.
source[q] * phi_C_i) *
352 local_rhs(i) -= -phi_C_i * velocity_divergence * tracer_value * JxW;
368 const auto &JxW = scratch_data.
JxW;
369 const unsigned int n_q_points = scratch_data.
n_q_points;
370 const unsigned int n_dofs = scratch_data.
n_dofs;
380 const Vector<double> &bdf_coefs =
385 for (
unsigned int q = 0; q < n_q_points; ++q)
394 strong_residual[q] += bdf_coefs[p] *
tracer[p];
397 for (
unsigned int j = 0; j < n_dofs; ++j)
399 strong_jacobian[q][j] += bdf_coefs[0] * scratch_data.
phi[q][j];
403 for (
unsigned int i = 0; i < n_dofs; ++i)
405 const double phi_u_i = scratch_data.
phi[q][i];
406 for (
unsigned int j = 0; j < n_dofs; ++j)
408 const double phi_u_j = scratch_data.
phi[q][j];
410 local_matrix(i, j) += phi_u_j * phi_u_i * bdf_coefs[0] * JxW[q];
423 const auto &JxW = scratch_data.
JxW;
424 const unsigned int n_q_points = scratch_data.
n_q_points;
425 const unsigned int n_dofs = scratch_data.
n_dofs;
434 const Vector<double> &bdf_coefs =
439 for (
unsigned int q = 0; q < n_q_points; ++q)
448 strong_residual[q] += (bdf_coefs[p] *
tracer[p]);
451 for (
unsigned int i = 0; i < n_dofs; ++i)
453 const double phi_u_i = scratch_data.
phi[q][i];
454 double local_rhs_i = 0;
458 local_rhs_i -= bdf_coefs[p] * (
tracer[p] * phi_u_i);
460 local_rhs(i) += local_rhs_i * JxW[q];
478 const auto &q_points = fe_iv.get_quadrature_points();
479 auto ©_data_face = copy_data.
face_data.back();
480 const unsigned int n_dofs = fe_iv.n_current_interface_dofs();
483 const std::vector<double> &JxW = fe_iv.get_JxW_values();
484 const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
486 for (
unsigned int q = 0; q < q_points.size(); ++q)
488 const double velocity_dot_n =
492 const auto &phi_upwind = (velocity_dot_n > 0.) ?
498 const double advection_factor = velocity_dot_n * JxW[q];
499 const double diffusion_factor =
501 const double penalty_diffusion_factor = penalty_factor * diffusion_factor;
503 for (
unsigned int i = 0; i < n_dofs; ++i)
505 const double jump_phi_i = jump_phi[i];
506 const double avg_grad_phi_n_i = avg_grad_phi_n[i];
508 for (
unsigned int j = 0; j < n_dofs; ++j)
512 copy_data_face.face_matrix(i, j) +=
513 jump_phi_i * phi_upwind[j] * advection_factor;
517 copy_data_face.face_matrix(i, j) +=
518 diffusion_factor * (-avg_grad_phi_n[j] * jump_phi_i -
519 avg_grad_phi_n_i * jump_phi[j]) +
520 penalty_diffusion_factor * jump_phi[j] * jump_phi_i;
534 const auto &q_points = fe_iv.get_quadrature_points();
535 const unsigned int n_dofs = fe_iv.n_current_interface_dofs();
537 auto ©_data_face = copy_data.
face_data.back();
539 const std::vector<double> &JxW = fe_iv.get_JxW_values();
540 const std::vector<Tensor<1, dim>> &normals = fe_iv.get_normal_vectors();
542 for (
unsigned int q = 0; q < q_points.size(); ++q)
544 const double velocity_dot_n =
548 const double upwind_value = (velocity_dot_n > 0) ?
555 const double advective_flux = upwind_value * velocity_dot_n * JxW[q];
556 const double diffusion_factor =
559 const double tracer_average_gradient_n =
562 for (
unsigned int i = 0; i < n_dofs; ++i)
566 copy_data_face.face_rhs(i) -= jump_phi[i] * advective_flux;
570 copy_data_face.face_rhs(i) -=
571 diffusion_factor * (-tracer_average_gradient_n * jump_phi[i] -
572 tracer_jump * avg_grad_phi_n[i] +
573 penalty_factor * tracer_jump * jump_phi[i]);
589 const FEFaceValuesBase<dim> &fe_face =
591 const auto &q_points = fe_face.get_quadrature_points();
595 const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
596 const std::vector<double> &JxW = fe_face.get_JxW_values();
597 const std::vector<Tensor<1, dim>> &normals = fe_face.get_normal_vectors();
606 const bool is_dirichlet =
610 std::vector<double> grad_phi_n(n_facet_dofs);
612 for (
unsigned int point = 0; point < q_points.size(); ++point)
614 const double velocity_dot_n =
618 const double advection_factor =
619 (velocity_dot_n > 0) ? velocity_dot_n * JxW[point] : 0.;
623 if (velocity_dot_n > 0)
624 for (
unsigned int i = 0; i < n_facet_dofs; ++i)
626 const double phi_i = fe_face.shape_value(i, point);
627 for (
unsigned int j = 0; j < n_facet_dofs; ++j)
629 phi_i * fe_face.shape_value(j, point) * advection_factor;
634 const double diffusion_factor =
637 for (
unsigned int j = 0; j < n_facet_dofs; ++j)
638 grad_phi_n[j] = fe_face.shape_grad(j, point) * normals[point];
640 for (
unsigned int i = 0; i < n_facet_dofs; ++i)
642 const double phi_i = fe_face.shape_value(i, point);
643 for (
unsigned int j = 0; j < n_facet_dofs; ++j)
645 const double phi_j = fe_face.shape_value(j, point);
647 copy_data.
local_matrix(i, j) += phi_i * phi_j * advection_factor;
651 (-phi_i * grad_phi_n[j] - phi_j * grad_phi_n[i] +
652 beta * phi_i * phi_j);
665 const FEFaceValuesBase<dim> &fe_face =
667 const auto &q_points = fe_face.get_quadrature_points();
671 const unsigned int n_facet_dofs = fe_face.get_fe().n_dofs_per_cell();
672 const std::vector<double> &JxW = fe_face.get_JxW_values();
673 const std::vector<Tensor<1, dim>> &normals = fe_face.get_normal_vectors();
680 for (
unsigned int point = 0; point < q_points.size(); ++point)
682 const double velocity_dot_n =
685 for (
unsigned int i = 0; i < n_facet_dofs; ++i)
686 copy_data.
local_rhs(i) -= fe_face.shape_value(i, point)
697 std::vector<double> function_value(q_points.size());
699 q_points, function_value);
701 for (
unsigned int point = 0; point < q_points.size(); ++point)
703 const double velocity_dot_n =
706 for (
unsigned int i = 0; i < n_facet_dofs; ++i)
708 if (velocity_dot_n < 0)
709 copy_data.
local_rhs(i) -= fe_face.shape_value(i, point) *
710 function_value[point] *
711 velocity_dot_n * JxW[point];
713 if (velocity_dot_n > 0)
714 copy_data.
local_rhs(i) -= fe_face.shape_value(i, point) *
716 velocity_dot_n * JxW[point];
720 (-fe_face.shape_value(i, point) *
722 (scratch_data.
values_here[point] - function_value[point]) *
723 fe_face.shape_grad(i, point) * normals[point] +
724 beta * fe_face.shape_value(i, point) *
725 (scratch_data.
values_here[point] - function_value[point])) *
746 "Periodic boundary conditions cannot be used with the tracer physics when discontinous Galerkin elements are used."));
754 "No valid boundary conditions types were identified."));
771 const auto &JxW_vec = scratch_data.
JxW;
772 const unsigned int n_q_points = scratch_data.
n_q_points;
773 const unsigned int n_dofs = scratch_data.
n_dofs;
779 for (
unsigned int q = 0; q < n_q_points; ++q)
781 const double reaction_coeff = k[q];
786 for (
unsigned int j = 0; j < n_dofs; ++j)
788 const double &phi_C_j = scratch_data.
phi[q][j];
789 strong_jacobian_vec[q][j] +=
796 const double JxW = JxW_vec[q];
798 for (
unsigned int i = 0; i < n_dofs; ++i)
800 const auto &phi_C_i = scratch_data.
phi[q][i];
802 for (
unsigned int j = 0; j < n_dofs; ++j)
804 const auto &phi_C_j = scratch_data.
phi[q][j];
806 local_matrix(i, j) += reaction_coeff * phi_C_i * phi_C_j * JxW;
822 const auto &JxW_vec = scratch_data.
JxW;
823 const unsigned int n_q_points = scratch_data.
n_q_points;
824 const unsigned int n_dofs = scratch_data.
n_dofs;
831 for (
unsigned int q = 0; q < n_q_points; ++q)
834 const double JxW = JxW_vec[q];
840 strong_residual_vec[q] += -k[q] * C;
842 for (
unsigned int i = 0; i < n_dofs; ++i)
844 const auto &phi_C_i = scratch_data.
phi[q][i];
847 local_rhs(i) -= k[q] * phi_C_i * C * JxW;
unsigned int number_of_previous_solutions(const Parameters::SimulationControl::TimeSteppingMethod method)
Get the number of previous time steps for a specific BDF scheme.
Responsible for storing the information calculated using the discontinuous galerkin (DG) assembly of ...
std::vector< CopyDataFace > face_data
Class responsible for storing the information calculated using the assembly of stabilized scalar equa...
Vector< double > local_rhs
Vector< double > strong_residual
FullMatrix< double > local_matrix
std::vector< Vector< double > > strong_jacobian
Class that assembles the transient time arising from BDF time integration for the Tracer equations....
const std::shared_ptr< SimulationControl > simulation_control
virtual void assemble_rhs(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the rhs.
virtual void assemble_matrix(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the matrix.
Assembles Nitsche's method for boundary faces. This assembler is only required when solving the Trace...
BoundaryConditions::TracerBoundaryConditions< dim > tracer_boundary_conditions
virtual void assemble_rhs(const TracerScratchData< dim > &scratch_data, StabilizedDGMethodsCopyData ©_data) override
Interface for the call to rhs.
virtual void assemble_matrix(const TracerScratchData< dim > &scratch_data, StabilizedDGMethodsCopyData ©_data) override
Interface for the call to matrix assembly.
Class that assembles the core of the Tracer equation. This class assembles the weak form of: with an...
const std::shared_ptr< SimulationControl > simulation_control
virtual void assemble_rhs(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the rhs.
virtual void assemble_matrix(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the matrix.
Class that assembles the core (cells) of the Tracer equation for DG elements. This class assembles th...
virtual void assemble_rhs(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the rhs.
virtual void assemble_matrix(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the matrix.
Class that assembles the reaction source term of the Tracer equation. It assembles the term: Where C...
virtual void assemble_matrix(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the matrix.
virtual void assemble_rhs(const TracerScratchData< dim > &scratch_data, StabilizedMethodsCopyData ©_data) override
Assembles the rhs.
Assembles the symmetric interior penalty (SIPG) method (or Nitsche's method) for internal faces....
virtual void assemble_matrix(const TracerScratchData< dim > &scratch_data, StabilizedDGMethodsCopyData ©_data) override
Interface for the call to matrix assembly.
virtual void assemble_rhs(const TracerScratchData< dim > &scratch_data, StabilizedDGMethodsCopyData ©_data) override
Interface for the call to rhs.
Class that stores the information required by the assembly procedure for a Tracer advection-diffusion...
std::vector< Tensor< 1, dim > > face_velocity_values
std::vector< double > tracer_values
std::vector< Tensor< 1, dim > > previous_tracer_gradients
unsigned int boundary_index
Table< 2, double > face_average_grad_phi_dot_n
std::vector< double > values_there
std::vector< Tensor< 1, dim > > velocity_values
std::vector< double > grad_tracer_reaction_prefactor
std::vector< double > velocity_divergences
std::vector< std::vector< double > > previous_tracer_values
std::vector< double > tracer_diffusivity
FEInterfaceValues< dim > fe_interface_values_tracer
std::vector< Tensor< 1, dim > > tracer_average_gradient
std::vector< double > tracer_reaction_prefactor
Table< 2, double > laplacian_phi
std::vector< Tensor< 1, dim > > tracer_gradients
std::vector< double > source
std::vector< double > tracer_value_jump
std::vector< double > values_here
Table< 2, double > face_jump_phi
Table< 2, double > face_phi_there
Table< 2, double > face_phi_here
std::vector< double > tracer_laplacians
Table< 2, Tensor< 1, dim > > grad_phi
std::vector< double > tracer_diffusivity_face
std::vector< Tensor< 1, dim > > gradients_here
FEValues< dim > fe_values_tracer
@ velocity
Velocity vector field from fluid dynamics.
@ tracer
Passive scalar tracer (Tracer).
bool is_steady(const Parameters::SimulationControl::TimeSteppingMethod method)
Determines if the time integration method is a steady-state method.