evaporation_operation.hpp

Go to the documentation of this file.

#pragma once
 
#include <deal.II/base/aligned_vector.h>
#include <deal.II/base/numbers.h>
#include <deal.II/base/point.h>
#include <deal.II/base/tensor.h>
#include <deal.II/base/vectorization.h>
 
#include <deal.II/grid/tria.h>
 
#include <deal.II/lac/la_parallel_block_vector.h>
#include <deal.II/lac/la_parallel_vector.h>
 
#include <meltpooldg/core/material_data.hpp>
#include <meltpooldg/core/scratch_data.hpp>
#include <meltpooldg/level_set/nearest_point_data.hpp>
#include <meltpooldg/level_set/reinitialization_data.hpp>
#include <meltpooldg/phase_change/evaporation_data.hpp>
#include <meltpooldg/phase_change/evaporation_mass_flux_operator_base.hpp>
#include <meltpooldg/phase_change/evaporation_model_base.hpp>
#include <meltpooldg/phase_change/evaporation_source_terms_base.hpp>
#include <meltpooldg/post_processing/generic_data_out.hpp>
 
#include <memory>
#include <tuple>
#include <vector>
 
namespace MeltPoolDG::Evaporation
{
  template <int dim, typename number>
  class EvaporationOperation
  {
  private:
    using VectorType      = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType = dealii::LinearAlgebra::distributed::BlockVector<number>;
 
    const ScratchData<dim, dim, number> &scratch_data;
    const EvaporationData<number> &evapor_data;
 
    const MaterialData<number> &material_data;
    const VectorType      &level_set_as_heaviside;
    const BlockVectorType &normal_vector;
    const unsigned int normal_dof_idx;
    const unsigned int evapor_vel_dof_idx;
    const unsigned int evapor_mass_flux_dof_idx;
    const unsigned int ls_hanging_nodes_dof_idx;
    const unsigned int ls_quad_idx;
    /*
     * cut-off value for normalizing the normal vector field
     */
    const number tolerance_normal_vector;
 
    VectorType evaporative_mass_flux;
    dealii::AlignedVector<dealii::Tensor<1, dim, dealii::VectorizedArray<number>>>
      evaporation_velocities;
    VectorType evaporation_velocity;
 
    bool do_analytical_evaporative_mass_flux = false;
 
    std::shared_ptr<EvaporationModelBase<number>>                 evapor_model;
    std::shared_ptr<EvaporationMassFluxOperatorBase<dim, number>> evapor_mass_flux_operator;
    std::shared_ptr<EvaporationSourceTermsBase<dim, number>>      evapor_source_terms_operator;
 
  public:
    EvaporationOperation(const ScratchData<dim, dim, number> &scratch_data_in,
                         const VectorType                    &level_set_as_heaviside_in,
                         const BlockVectorType               &normal_vector_in,
                         const EvaporationData<number>       &evapor_data_in,
                         const MaterialData<number>          &material_data_in,
                         const unsigned int                   normal_dof_idx_in,
                         const unsigned int                   evapor_vel_dof_idx_in,
                         const unsigned int                   evapor_vel_quad_idx_in,
                         const unsigned int                   evapor_mass_flux_dof_idx_in,
                         const unsigned int                   ls_hanging_nodes_dof_idx_in,
                         const unsigned int                   ls_quad_idx_in);
 
    void
    compute_evaporative_mass_flux(
      const number      &time,
      const VectorType  *temperature        = nullptr,
      const unsigned int heat_no_bc_dof_idx = dealii::numbers::invalid_unsigned_int);
 
    void
    compute_analytical_evaporative_mass_flux(const number &time);
 
    void
    compute_temperature_dependent_evaporative_mass_flux(const VectorType  &temperature,
                                                        const unsigned int heat_no_bc_dof_idx);
 
    void
    compute_evaporation_velocity();
 
    void
    compute_level_set_source_term(VectorType        &rhs,
                                  const unsigned int ls_dof_idx,
                                  const VectorType  &level_set,
                                  const unsigned int pressure_dof_idx);
 
    void
    compute_mass_balance_source_term(VectorType        &mass_balance_rhs,
                                     const unsigned int pressure_dof_idx,
                                     const unsigned int pressure_quad_idx,
                                     bool               zero_out);
 
    void
    register_surface_mesh(
      const std::vector<
        std::tuple<const typename dealii::Triangulation<dim, dim>::cell_iterator /*cell*/,
                   std::vector<dealii::Point<dim>> /*quad_points*/,
                   std::vector<number> /*weights*/
                   >> &surface_mesh_info);
    void
    reinit();
    /*
     * attach functions
     */
    void
    attach_dim_vectors(std::vector<VectorType *> &vectors);
 
    void
    attach_vectors(std::vector<VectorType *> &vectors);
 
    void
    distribute_constraints();
 
    void
    attach_output_vectors(GenericDataOut<dim, number> &data_out) const;
 
    /*
     * getter functions
     */
    inline dealii::Tensor<1, dim, dealii::VectorizedArray<number>> *
    begin_evaporation_velocity(const unsigned int macro_cell);
 
    inline const dealii::Tensor<1, dim, dealii::VectorizedArray<number>> &
    begin_evaporation_velocity(const unsigned int macro_cell) const;
 
    const VectorType &
    get_velocity() const;
 
    VectorType &
    get_velocity();
 
    const VectorType &
    get_evaporative_mass_flux() const;
 
    VectorType &
    get_evaporative_mass_flux();
  };
} // namespace MeltPoolDG::Evaporation