solve_context.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2025 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/constraint_manager.h>
#include <prismspf/core/dof_manager.h>
#include <prismspf/core/field_attributes.h>
#include <prismspf/core/invm_manager.h>
#include <prismspf/core/matrix_free_manager.h>
#include <prismspf/core/pde_operator_base.h>
#include <prismspf/core/simulation_timer.h>
#include <prismspf/core/solution_indexer.h>
#include <prismspf/core/triangulation_manager.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
{
public:
  SolveContext(std::vector<FieldAttributes>            _field_attributes,
               const UserInputParameters<dim>         &_user_inputs,
               TriangulationManager<dim>              &_triangulation_manager,
               DoFManager<dim, degree>                &_dof_manager,
               ConstraintManager<dim, degree, number> &_constraint_manager,
               SolutionIndexer<dim, number>           &_solution_indexer,
               PDEOperatorBase<dim, degree, number>   &_pde_operator)
    : field_attributes(std::move(_field_attributes))
    , user_inputs(&_user_inputs)
    , triangulation_manager(&_triangulation_manager)
    , dof_manager(&_dof_manager)
    , constraint_manager(&_constraint_manager)
    , matrix_free_manager()
    , solution_indexer(&_solution_indexer)
    , invm_manager()
    , sim_timer(user_inputs->temporal_discretization.dt)
    , pde_operator(&_pde_operator) {};

  [[nodiscard]] const std::vector<FieldAttributes> &
  get_field_attributes() const
  {
    return field_attributes;
  }

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

  [[nodiscard]] const TriangulationManager<dim> &
  get_triangulation_manager() const
  {
    Assert(triangulation_manager != nullptr, dealii::ExcNotInitialized());
    return *triangulation_manager;
  }

  [[nodiscard]] TriangulationManager<dim> &
  get_triangulation_manager()
  {
    Assert(triangulation_manager != nullptr, dealii::ExcNotInitialized());
    return *triangulation_manager;
  }

  [[nodiscard]] const DoFManager<dim, degree> &
  get_dof_manager() const
  {
    Assert(dof_manager != nullptr, dealii::ExcNotInitialized());
    return *dof_manager;
  }

  [[nodiscard]] DoFManager<dim, degree> &
  get_dof_manager()
  {
    Assert(dof_manager != nullptr, dealii::ExcNotInitialized());
    return *dof_manager;
  }

  [[nodiscard]] const ConstraintManager<dim, degree, number> &
  get_constraint_manager() const
  {
    Assert(constraint_manager != nullptr, dealii::ExcNotInitialized());
    return *constraint_manager;
  }

  [[nodiscard]] ConstraintManager<dim, degree, number> &
  get_constraint_manager()
  {
    Assert(constraint_manager != nullptr, dealii::ExcNotInitialized());
    return *constraint_manager;
  }

  [[nodiscard]] const MatrixFreeManager<dim, number> &
  get_matrix_free_manager() const
  {
    return matrix_free_manager;
  }

  [[nodiscard]] MatrixFreeManager<dim, number> &
  get_matrix_free_manager()
  {
    return matrix_free_manager;
  }

  [[nodiscard]] SolutionIndexer<dim, number> &
  get_solution_indexer() const
  {
    Assert(solution_indexer != nullptr, dealii::ExcNotInitialized());
    return *solution_indexer;
  }

  [[nodiscard]] const InvMManager<dim, degree, number> &
  get_invm_manager() const
  {
    return invm_manager;
  }

  [[nodiscard]] InvMManager<dim, degree, number> &
  get_invm_manager()
  {
    return invm_manager;
  }

  [[nodiscard]] const SimulationTimer &
  get_simulation_timer() const
  {
    return sim_timer;
  }

  [[nodiscard]] SimulationTimer &
  get_simulation_timer()
  {
    return sim_timer;
  }

  [[nodiscard]] const PDEOperatorBase<dim, degree, number> &
  get_pde_operator() const
  {
    Assert(pde_operator != nullptr, dealii::ExcNotInitialized());
    return *pde_operator;
  }

  [[nodiscard]] PDEOperatorBase<dim, degree, number> &
  get_pde_operator()
  {
    Assert(pde_operator != nullptr, dealii::ExcNotInitialized());
    return *pde_operator;
  }
 
private:
  std::vector<FieldAttributes> field_attributes;

  const UserInputParameters<dim> *user_inputs;

  TriangulationManager<dim> *triangulation_manager;

  DoFManager<dim, degree> *dof_manager;

  ConstraintManager<dim, degree, number> *constraint_manager;

  MatrixFreeManager<dim, number> matrix_free_manager;

  SolutionIndexer<dim, number> *solution_indexer;

  InvMManager<dim, degree, number> invm_manager;

  SimulationTimer sim_timer;

  PDEOperatorBase<dim, degree, number> *pde_operator;
};
 
PRISMS_PF_END_NAMESPACE