4#ifndef lethe_postprocessors_h
5#define lethe_postprocessors_h
9#include <deal.II/base/tensor.h>
11#include <deal.II/numerics/data_postprocessor.h>
32 : DataPostprocessorVector<dim>(
"vorticity", update_gradients)
50 const DataPostprocessorInputs::Vector<dim> &input_data,
51 std::vector<Vector<double>> &computed_quantities)
const override
53 AssertDimension(input_data.solution_gradients.size(),
54 computed_quantities.size());
55 for (
unsigned int p = 0; p < input_data.solution_gradients.size(); ++p)
57 AssertDimension(computed_quantities[p].size(), dim);
58 if constexpr (dim == 3)
60 computed_quantities[p](0) =
61 (input_data.solution_gradients[p][2][1] -
62 input_data.solution_gradients[p][1][2]);
63 computed_quantities[p](1) =
64 (input_data.solution_gradients[p][0][2] -
65 input_data.solution_gradients[p][2][0]);
66 computed_quantities[p](2) =
67 (input_data.solution_gradients[p][1][0] -
68 input_data.solution_gradients[p][0][1]);
70 if constexpr (dim == 2)
72 computed_quantities[p][0] =
73 (input_data.solution_gradients[p][1][0] -
74 input_data.solution_gradients[p][0][1]);
95 : DataPostprocessorScalar<dim>(
"q_criterion", update_gradients)
113 const DataPostprocessorInputs::Vector<dim> &input_data,
114 std::vector<Vector<double>> &computed_quantities)
const override
116 for (
unsigned int p = 0; p < input_data.solution_gradients.size(); ++p)
118 AssertDimension(computed_quantities[p].size(), 1);
119 double p1 = 0.0, r1 = 0.0;
120 std::vector<Tensor<2, dim>> vorticity_vector(
121 input_data.solution_gradients.size());
122 std::vector<Tensor<2, dim>> strain_rate_tensor(
123 input_data.solution_gradients.size());
124 for (
int j = 0; j < dim; j++)
126 for (
int k = 0; k < dim; k++)
128 vorticity_vector[p][j][k] =
129 0.5 * ((input_data.solution_gradients[p][j][k]) -
130 input_data.solution_gradients[p][k][j]);
131 strain_rate_tensor[p][j][k] =
132 0.5 * ((input_data.solution_gradients[p][j][k]) +
133 input_data.solution_gradients[p][k][j]);
136 for (
int m = 0; m < dim; m++)
138 for (
int n = 0; n < dim; n++)
140 p1 += (vorticity_vector[p][m][n]) * (vorticity_vector[p][m][n]);
142 (strain_rate_tensor[p][m][n]) * (strain_rate_tensor[p][m][n]);
145 computed_quantities[p] = 0.5 * (p1 - r1);
165 : DataPostprocessorScalar<dim>(
"velocity_divergence", update_gradients)
182 const DataPostprocessorInputs::Vector<dim> &input_data,
183 std::vector<Vector<double>> &computed_quantities)
const override
185 AssertDimension(input_data.solution_gradients.size(),
186 computed_quantities.size());
187 for (
unsigned int p = 0; p < input_data.solution_gradients.size(); ++p)
189 double velocity_divergence = 0;
190 for (
int d = 0; d < dim; ++d)
192 velocity_divergence += input_data.solution_gradients[p][d][d];
194 computed_quantities[p] = velocity_divergence;
216 : DataPostprocessorTensor<dim>(
"velocity_gradient", update_gradients)
233 const DataPostprocessorInputs::Vector<dim> &input_data,
234 std::vector<Vector<double>> &computed_quantities)
const override
236 AssertDimension(input_data.solution_gradients.size(),
237 computed_quantities.size());
238 for (
unsigned int p = 0; p < input_data.solution_gradients.size(); ++p)
240 AssertDimension(computed_quantities[p].size(),
241 (Tensor<2, dim>::n_independent_components));
243 for (
int d = 0; d < dim; ++d)
244 for (
int e = 0; e < dim; ++e)
245 computed_quantities[p][Tensor<2, dim>::component_to_unrolled_index(
246 TableIndices<2>(d, e))] = input_data.solution_gradients[p][d][e];
275 : DataPostprocessorVector<dim>(std::string(
"velocity_eulerian"),
276 update_values | update_quadrature_points)
296 const DataPostprocessorInputs::Vector<dim> &inputs,
297 std::vector<Vector<double>> &computed_quantities)
const override
299 Tensor<1, dim> omega;
305 const unsigned int n_quadrature_points = inputs.solution_values.size();
306 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
309 velocity[0] = inputs.solution_values[q][0];
310 velocity[1] = inputs.solution_values[q][1];
313 cross_product_2d(inputs.evaluation_points[q]);
315 if constexpr (dim == 3)
317 velocity[2] = inputs.solution_values[q][2];
319 velocity + cross_product_3d(omega, inputs.evaluation_points[q]);
321 for (
int d = 0; d < dim; ++d)
323 computed_quantities[q][d] =
velocity[d];
360 const unsigned int fluid_id = 0)
361 : DataPostprocessorScalar<dim>(
"kinematic_viscosity" +
362 Utilities::to_string(fluid_id, 2),
383 const DataPostprocessorInputs::Vector<dim> &inputs,
384 std::vector<Vector<double>> &computed_quantities)
const override
386 const unsigned int n_quadrature_points = inputs.solution_gradients.size();
388 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
390 const auto gradient = inputs.solution_gradients[q];
392 for (
int i = 0; i < dim; ++i)
394 for (
int j = 0; j < dim; ++j)
396 shear_rate[i][j] += gradient[i][j] + gradient[j][i];
399 const double shear_rate_magnitude =
402 std::map<field, double> field_values;
444 const unsigned int fluid_id = 0)
445 : DataPostprocessorScalar<dim>(
"dynamic_viscosity_" +
446 Utilities::to_string(fluid_id, 2),
468 const DataPostprocessorInputs::Vector<dim> &inputs,
469 std::vector<Vector<double>> &computed_quantities)
const override
471 const unsigned int n_quadrature_points = inputs.solution_gradients.size();
473 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
475 const auto gradient = inputs.solution_gradients[q];
477 for (
int i = 0; i < dim; ++i)
479 for (
int j = 0; j < dim; ++j)
481 shear_rate[i][j] += gradient[i][j] + gradient[j][i];
484 const double shear_rate_magnitude =
487 std::map<field, double> field_values;
490 computed_quantities[q] =
518 : DataPostprocessorScalar<dim>(
"shear_rate", update_gradients)
535 const DataPostprocessorInputs::Vector<dim> &inputs,
536 std::vector<Vector<double>> &computed_quantities)
const override
538 const unsigned int n_quadrature_points = inputs.solution_gradients.size();
540 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
542 const auto gradient = inputs.solution_gradients[q];
544 for (
int i = 0; i < dim; ++i)
546 for (
int j = 0; j < dim; ++j)
548 shear_rate[i][j] += gradient[i][j] + gradient[j][i];
575 : DataPostprocessorScalar<dim>(name, update_quadrature_points)
590 const DataPostprocessorInputs::Vector<dim> &input_data,
591 std::vector<Vector<double>> &computed_quantities)
const override
593 const unsigned int n_quadrature_points =
594 input_data.evaluation_points.size();
596 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
598 AssertDimension(computed_quantities[q].size(), 1);
600 const Point<dim> evaluation_point = input_data.evaluation_points[q];
623 : DataPostprocessorScalar<dim>(
"levelset", update_quadrature_points)
642 const DataPostprocessorInputs::Vector<dim> &input_data,
643 std::vector<Vector<double>> &computed_quantities)
const override
645 const unsigned int n_quadrature_points =
646 input_data.evaluation_points.size();
648 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
650 AssertDimension(computed_quantities[q].size(), 1);
652 const Point<dim> evaluation_point = input_data.evaluation_points[q];
653 const auto cell = input_data.template get_cell<dim>();
654 computed_quantities[q] =
655 shape->value_with_cell_guess(evaluation_point, cell);
678 : DataPostprocessorVector<dim>(std::string(
"levelset_gradient"),
679 update_values | update_quadrature_points)
698 const DataPostprocessorInputs::Vector<dim> &inputs,
699 std::vector<Vector<double>> &computed_quantities)
const override
701 const unsigned int n_quadrature_points = inputs.evaluation_points.size();
703 Tensor<1, dim> levelset_gradient{};
704 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
706 AssertDimension(computed_quantities[q].size(), dim);
708 const Point<dim> evaluation_point = inputs.evaluation_points[q];
709 const auto cell = inputs.template get_cell<dim>();
711 shape->gradient_with_cell_guess(evaluation_point, cell);
712 for (
int d = 0; d < dim; d++)
713 computed_quantities[q][d] = levelset_gradient[d];
745 const unsigned int material_id = 0)
746 : DataPostprocessorScalar<dim>(
"density_" +
747 Utilities::to_string(material_id, 2),
762 const DataPostprocessorInputs::Vector<dim> &inputs,
763 std::vector<Vector<double>> &computed_quantities)
const override
765 const unsigned int n_quadrature_points = inputs.solution_values.size();
766 std::map<field, double> field_values;
768 for (
unsigned int q = 0; q < n_quadrature_points; ++q)
770 AssertDimension(computed_quantities[q].size(), 1);
813 &p_thermal_conductivity_model,
814 const std::string &p_material_string =
"f",
815 const unsigned int &p_id = 0,
816 const unsigned int &p_mesh_material_id = 0,
817 const bool &p_solid_phase_present =
false)
818 : DataPostprocessorVector<dim>(
"heat_flux_" + p_material_string +
819 Utilities::to_string(p_id, 2),
820 update_values | update_gradients)
837 const DataPostprocessorInputs::Scalar<dim> &inputs,
838 std::vector<Vector<double>> &computed_quantities)
const override
840 const unsigned int n_evaluation_points = computed_quantities.size();
841 AssertDimension(inputs.solution_gradients.size(), n_evaluation_points);
847 const auto cell = inputs.template get_cell<dim>();
857 Vector<double> null_vector(dim);
858 std::vector<Vector<double>> null_computed_quantities(
859 n_evaluation_points, null_vector);
860 computed_quantities = null_computed_quantities;
885 std::vector<Vector<double>> &computed_quantities)
const
887 std::map<field, double> field_values;
888 for (
unsigned int p = 0; p < computed_quantities.size(); ++p)
890 AssertDimension(computed_quantities[p].size(), dim);
893 for (
int i = 0; i < dim; ++i)
895 computed_quantities[p][i] =
897 inputs.solution_gradients[p][i];
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute the density of a material at given evaluation points.
DensityPostprocessor(std::shared_ptr< DensityModel > p_density_model, const unsigned int material_id=0)
Constructor for the density postprocessor.
std::shared_ptr< DensityModel > density_model
Model describing the material's density.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const override
Compute the divergence of the velocity at given evaluation points.
DivergencePostprocessor()
Constructor of the velocity divergence postprocessor.
DynamicViscosityPostprocessor(std::shared_ptr< RheologicalModel > rheological_model, const double density_ref, const unsigned int fluid_id=0)
Constructor of the dynamic viscosity postprocessor.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute the dynamic viscosity of a fluid at given evaluation points.
double density_ref
Density of the fluid at reference state.
std::shared_ptr< RheologicalModel > rheological_model
Model describing the fluid's rheology.
GradientPostprocessor()
Constructor of the velocity gradient postprocessor.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const override
Return the gradient of the velocity at given evaluation points.
const bool solid_phase_present
Boolean indicating if the simulation has solids.
void compute_quantities(const DataPostprocessorInputs::Scalar< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const
Computes local heat flux vectors.
virtual void evaluate_scalar_field(const DataPostprocessorInputs::Scalar< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute local heat fluxes from temperature gradient vector field and thermal conductivity at given ev...
HeatFluxPostprocessor(const std::shared_ptr< ThermalConductivityModel > &p_thermal_conductivity_model, const std::string &p_material_string="f", const unsigned int &p_id=0, const unsigned int &p_mesh_material_id=0, const bool &p_solid_phase_present=false)
Constructor of the heat flux postprocessor.
const unsigned int mesh_material_id
Identifier corresponding to the material as identified in the mesh.
std::shared_ptr< ThermalConductivityModel > thermal_conductivity_model
Model describing of thermal conductivity of the material.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute the kinematic viscosity of a fluid at given evaluation points.
KinematicViscosityPostprocessor(std::shared_ptr< RheologicalModel > rheological_model, const unsigned int fluid_id=0)
Constructor of the kinematic viscosity postprocessor.
std::shared_ptr< RheologicalModel > rheological_model
Model describing the fluid's rheology.
std::shared_ptr< Shape< dim > > shape
Geometrical entity.
LevelsetGradientPostprocessor(const std::shared_ptr< Shape< dim > > &shape)
Constructor for the level set gradient postprocessor.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute signed distance gradient of evaluation points with respect to the specified shape.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const override
Compute signed distance value of evaluation points with respect to the specified shape.
std::shared_ptr< Shape< dim > > shape
Geometrical entity.
LevelsetPostprocessor(const std::shared_ptr< Shape< dim > > &shape)
Constuctor of the level set postprocessor.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const override
Computes the Q-criterion from the velocity vector at given evaluation points.
QCriterionPostprocessor()
Constructor of the Q-criterion postprocessor.
double omega_x
Value of the component of the SRF's velocity.
double omega_y
Value of the component of the SRF's velocity.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute the Eulerian velocity in a SRF at given evaluation points.
SRFPostprocessor(double p_omega_x, double p_omega_y, double p_omega_z)
Constructor of the single rotating frame SRF postprocessor.
double omega_z
Value of the component of the SRF's velocity.
ScalarFunctionPostprocessor(std::string name, const std::shared_ptr< Function< dim > > scalar_function)
Constructor of the scalar function postprocessor.
std::shared_ptr< Function< dim > > scalar_function
Scalar postprocessing function.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const override
Compute the scalar given by the postprocessing function at given evaluation points.
A base class used to represent geometrical entities. Its main uses are to return signed distance and ...
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &inputs, std::vector< Vector< double > > &computed_quantities) const override
Compute the shear rate at given evaluation points.
ShearRatePostprocessor()
Constructor of the shear rate postprocessor.
VorticityPostprocessor()
Constructor of the vorticity postprocessor.
virtual void evaluate_vector_field(const DataPostprocessorInputs::Vector< dim > &input_data, std::vector< Vector< double > > &computed_quantities) const override
Compute the vorticity vector from the velocity vector at given evaluation points.
@ velocity
Velocity vector field from fluid dynamics.
double calculate_shear_rate_magnitude(const Tensor< 2, dim > shear_rate)
Calculates the magnitude of the shear rate tensor given as input.