normal_vector_operation.hpp

Go to the documentation of this file.

#pragma once
// for parallelization
#include <deal.II/lac/generic_linear_algebra.h>
 
// MeltPoolDG
#include <meltpooldg/core/operator_base.hpp>
#include <meltpooldg/level_set/normal_vector_operation_base.hpp>
#include <meltpooldg/level_set/normal_vector_operator.hpp>
#include <meltpooldg/linear_algebra/linear_solver.hpp>
#include <meltpooldg/linear_algebra/preconditioner.hpp>
#include <meltpooldg/linear_algebra/predictor.hpp>
#include <meltpooldg/linear_algebra/utilities_matrixfree.hpp>
#include <meltpooldg/time_integration/solution_history.hpp>
#include <meltpooldg/utilities/utility_functions.hpp>
#include <meltpooldg/utilities/vector_tools.hpp>
 
namespace MeltPoolDG::LevelSet
{
  template <int dim, typename number>
  class NormalVectorOperation : public NormalVectorOperationBase<dim, number>
  {
  private:
    using VectorType       = dealii::LinearAlgebra::distributed::Vector<number>;
    using BlockVectorType  = dealii::LinearAlgebra::distributed::BlockVector<number>;
    using SparseMatrixType = dealii::TrilinosWrappers::SparseMatrix;
 
  public:
    NormalVectorOperation(const ScratchData<dim, dim, number> &scratch_data_in,
                          const NormalVectorData<number>      &normal_vector_data,
                          const VectorType                    &solution_level_set,
                          const std::array<unsigned int, dim> &normal_dof_indices_per_block_in,
                          const unsigned int                   normal_no_bc_dof_idx_in,
                          const unsigned int                   normal_quad_idx_in,
                          const unsigned int                   ls_dof_idx_in);
 
    void
    reinit() override;
 
    void
    solve() override;
 
    const BlockVectorType &
    get_solution_normal_vector() const override;
 
    BlockVectorType &
    get_solution_normal_vector() override;
 
    void
    attach_vectors(
      std::vector<dealii::LinearAlgebra::distributed::Vector<number> *> &vectors) override;
 
  private:
    void
    create_operator();
 
  private:
    const ScratchData<dim, dim, number> &scratch_data;
    const NormalVectorData<number>       normal_vector_data;
    const VectorType                    &solution_level_set;
    /*
     *  Based on the following indices the correct DoFHandler or quadrature rule from
     *  ScratchData<dim,dim,number> object is selected. This is important when
     * ScratchData<dim,dim,number> holds multiple DoFHandlers, quadrature rules, etc.
     */
    const unsigned int                  normal_no_bc_dof_idx;
    const std::array<unsigned int, dim> normal_dof_indices_per_block;
    const unsigned int                  normal_quad_idx;
    const unsigned int                  ls_dof_idx;
 
    TimeIntegration::SolutionHistory<BlockVectorType> solution_history;
 
    std::unique_ptr<Predictor<BlockVectorType, number>> predictor;
    /*
     *    This is the primary solution variable of this module, which will be also publicly
     *    accessible for output_results.
     */
    BlockVectorType solution_normal_vector_predictor;
    BlockVectorType rhs;
    /*
     * This pointer will point to your user-defined normal vector operator.
     */
    std::unique_ptr<NormalVectorOperator<dim, number>> normal_vector_operator;
    /*
     * Preconditioner for the curvature operator
     */
    Preconditioner<dim, BlockVectorType, number> preconditioner;
  };
} // namespace MeltPoolDG::LevelSet