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 <deal.II/base/mg_level_object.h>
#include <deal.II/fe/mapping_q1.h>
 
#include <prismspf/core/constraint_manager.h>
#include <prismspf/core/dof_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>
 
#include "prismspf/core/field_attributes.h"
#include "prismspf/core/invm_manager.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,
               const 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)
    , solution_indexer(&_solution_indexer)
    , invm_manager(*dof_manager, *constraint_manager, true, true)
    , 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]] 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;
  }
 
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;
 
  SolutionIndexer<dim, number> *solution_indexer;
 
  InvMManager<dim, degree, number> invm_manager;
 
  SimulationTimer sim_timer;
 
  const PDEOperatorBase<dim, degree, number> *pde_operator;
};
 
PRISMS_PF_END_NAMESPACE