pde_operator_base.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2026 PRISMS Center at the University of Michigan
// SPDX-License-Identifier: GNU Lesser General Public Version 2.1
 
#pragma once
 
#include <deal.II/base/exceptions.h>
 
#include <prismspf/core/field_container.h>
#include <prismspf/core/phase_field_tools.h>
#include <prismspf/core/simulation_timer.h>
#include <prismspf/core/types.h>
 
#include <prismspf/user_inputs/user_input_parameters.h>
 
#include <prismspf/config.h>
 
PRISMS_PF_BEGIN_NAMESPACE
 
template <unsigned int dim, unsigned int degree, typename number>
class SolveContext;

template <unsigned int dim, unsigned int degree, typename number>
class PDEOperatorBase
{
public:
  using SizeType = dealii::VectorizedArray<number>;

  explicit PDEOperatorBase(const UserInputParameters<dim> &_user_inputs,
                           const PhaseFieldTools<dim>     &_pf_tools)
    : user_inputs(&_user_inputs)
    , pf_tools(&_pf_tools)
  {}

  virtual ~PDEOperatorBase() = default;

  virtual void
  set_initial_condition([[maybe_unused]] const unsigned int       &index,
                        [[maybe_unused]] const unsigned int       &component,
                        [[maybe_unused]] const dealii::Point<dim> &point,
                        [[maybe_unused]] number                   &scalar_value,
                        [[maybe_unused]] number &vector_component_value) const
  {}

  virtual void
  set_dirichlet([[maybe_unused]] const unsigned int       &index,
                [[maybe_unused]] const unsigned int       &boundary_id,
                [[maybe_unused]] const unsigned int       &component,
                [[maybe_unused]] const dealii::Point<dim> &point,
                [[maybe_unused]] const SimulationTimer    &sim_timer,
                [[maybe_unused]] number                   &scalar_value,
                [[maybe_unused]] number                   &vector_component_value) const
  {
    this->set_initial_condition(index,
                                component,
                                point,
                                scalar_value,
                                vector_component_value);
  }

  virtual void
  compute_rhs([[maybe_unused]] FieldContainer<dim, degree, number> &variable_list,
              [[maybe_unused]] const SimulationTimer               &sim_timer,
              [[maybe_unused]] unsigned int                         solver_id) const
  {}

  virtual void
  compute_lhs([[maybe_unused]] FieldContainer<dim, degree, number> &variable_list,
              [[maybe_unused]] const SimulationTimer               &sim_timer,
              [[maybe_unused]] unsigned int                         solver_id) const
  {}

  virtual void
  pre_solve_block([[maybe_unused]] SolveContext<dim, degree, number> &solve_context,
                  [[maybe_unused]] unsigned int                       solver_id)
  {}

  virtual void
  post_solve_block([[maybe_unused]] SolveContext<dim, degree, number> &solve_context,
                   [[maybe_unused]] unsigned int                       solver_id)
  {}

  [[nodiscard]] const UserInputParameters<dim> &
  get_user_inputs() const
  {
    Assert(user_inputs != nullptr, dealii::StandardExceptions::ExcNotInitialized());
    return *user_inputs;
  }

  [[nodiscard]] const PhaseFieldTools<dim> &
  get_pf_tools() const
  {
    Assert(pf_tools != nullptr, dealii::StandardExceptions::ExcNotInitialized());
    return *pf_tools;
  }

  void
  set_user_stop(bool flag)
  {
    user_stop = flag;
  }

  bool
  get_user_stop()
  {
    return user_stop;
  }
 
private:
  const UserInputParameters<dim> *user_inputs = nullptr;

  const PhaseFieldTools<dim> *pf_tools = nullptr;

  bool user_stop = false;
};
 
PRISMS_PF_END_NAMESPACE