operation_scratch_data.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/aligned_vector.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/fe/fe.h>
 
#include <deal.II/matrix_free/matrix_free.h>
 
#include <meltpooldg/compressible_flow/boundary_conditions.hpp>
#include <meltpooldg/compressible_flow/material.hpp>
#include <meltpooldg/compressible_flow/operation_data.hpp>
#include <meltpooldg/compressible_flow/phase_coupling_data.hpp>
#include <meltpooldg/compressible_flow/utils.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/flow/darcy_damping_data.hpp>
#include <meltpooldg/phase_change/phase_change_data.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
 
namespace MeltPoolDG::CompressibleFlow
{
  template <int dim, typename number>
  struct OperationScratchData
  {
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    explicit OperationScratchData(const OperationData<number>         &flow_data_in,
                                  const MaterialPhaseData<number>     &material_data_in,
                                  const ScratchData<dim, dim, number> &scratch_data_in,
                                  const unsigned int                   dof_idx_in,
                                  const unsigned int                   quad_idx_in,
                                  const CutSolverData<number>         *cut_data_in = nullptr)
      : flow_data(flow_data_in)
      , scratch_data(scratch_data_in)
      , material(material_data_in)
      , cut(cut_data_in)
      , dof_idx(dof_idx_in)
      , quad_idx(quad_idx_in)
    {
      if (material.number_of_species == 1)
        {
          is_viscous = material.dynamic_viscosity > 0.;
        }
      else
        {
          for (unsigned int species = 0; species < material.number_of_species; ++species)
            {
              if (material.species_data[species].dynamic_viscosity > 0.)
                {
                  is_viscous = true;
                  break;
                }
            }
        }
 
      if (flow_data.domain_representation_type == "cut")
        AssertThrow(
          cut_data_in != nullptr,
          dealii::ExcMessage(
            "A CompressibleFlowCutData object has to be provided to the constructor of "
            "CompressibleFlowScratchData in the case of domain_representation_type = 'cut'."));
    }
 
    const OperationData<number> flow_data;
 
    const ScratchData<dim, dim, number> &scratch_data;
 
    const MaterialPhaseData<number> material;
 
    const CutSolverData<number> *cut = nullptr;
 
    const unsigned int dof_idx = 0;
 
    const unsigned int quad_idx = 0;
 
    bool is_viscous = false;
 
    BoundaryConditions<dim, number> boundary_conditions;
 
    dealii::AlignedVector<dealii::VectorizedArray<number>> interior_penalty_parameter;
 
    TimeIntegration::SolutionHistory<VectorType> solution_history;
 
    std::unique_ptr<dealii::Function<dim>> body_force;
 
    void
    reinit(const unsigned solution_history_size)
    {
      solution_history.resize(solution_history_size);
      solution_history.apply(
        [&scratch_data = scratch_data, comp_flow_dof_idx = dof_idx](VectorType &v) {
          scratch_data.initialize_dof_vector(v, comp_flow_dof_idx);
        });
 
      if (is_viscous)
        calculate_penalty_parameter(interior_penalty_parameter,
                                    scratch_data.get_matrix_free(),
                                    flow_data.domain_representation_type,
                                    dof_idx);
    }
  };
 
  template <int dim, typename number>
  struct MultiphaseOperationScratchData
  {
    using VectorType = dealii::LinearAlgebra::distributed::Vector<number>;
 
    explicit MultiphaseOperationScratchData(
      const OperationData<number>                                 &flow_data_in,
      const MaterialPhaseData<number>                             &material_data_gas_in,
      const MaterialPhaseData<number>                             &material_data_liquid_in,
      const Multiphase::PhaseChangeData<number>                   &phase_change_data_in,
      const CutSolverData<number>                                 &cut_data_in,
      const Multiphase::CompressibleFlowPhaseCouplingData<number> &phase_coupling_data_in,
      const Flow::DarcyDampingData<number>                        &darcy_damping_data_in,
      const ScratchData<dim, dim, number>                         &scratch_data_in,
      const unsigned int                                           dof_idx_in,
      const unsigned int                                           quad_idx_in)
      : flow_data(flow_data_in)
      , scratch_data(scratch_data_in)
      , material_gas(material_data_gas_in)
      , material_liquid(material_data_liquid_in)
      , phase_change(phase_change_data_in)
      , cut(cut_data_in)
      , phase_coupling(phase_coupling_data_in)
      , darcy_damping(darcy_damping_data_in)
      , dof_idx(dof_idx_in)
      , quad_idx(quad_idx_in)
    {
      is_viscous = material_gas.dynamic_viscosity > 0. or material_liquid.dynamic_viscosity > 0.;
    }
 
    const OperationData<number> flow_data;
 
    const ScratchData<dim, dim, number> &scratch_data;
 
    const MaterialPhaseData<number> material_gas;
 
    const MaterialPhaseData<number> material_liquid;
 
    const Multiphase::PhaseChangeData<number> phase_change;
 
    const CutSolverData<number> cut;
 
    const Multiphase::CompressibleFlowPhaseCouplingData<number> phase_coupling;
 
    const Flow::DarcyDampingData<number> darcy_damping;
 
    const unsigned int dof_idx = 0;
 
    const unsigned int quad_idx = 0;
 
    bool is_viscous = false;
 
    BoundaryConditions<dim, number> boundary_conditions;
 
    dealii::AlignedVector<dealii::VectorizedArray<number>> interior_penalty_parameter;
 
    TimeIntegration::SolutionHistory<VectorType> solution_history;
 
    std::unique_ptr<dealii::Function<dim>> body_force;
 
    void
    reinit(const unsigned solution_history_size)
    {
      solution_history.resize(solution_history_size);
      solution_history.apply(
        [&scratch_data = scratch_data, comp_flow_dof_idx = dof_idx](VectorType &v) {
          scratch_data.initialize_dof_vector(v, comp_flow_dof_idx);
        });
 
      if (is_viscous)
        calculate_penalty_parameter(interior_penalty_parameter,
                                    scratch_data.get_matrix_free(),
                                    flow_data.domain_representation_type,
                                    dof_idx);
    }
  };
} // namespace MeltPoolDG::CompressibleFlow