simulator_access.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 - 2026 by the authors of the ASPECT code.
 
  This file is part of ASPECT.
 
  ASPECT is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.
 
  ASPECT is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with ASPECT; see the file LICENSE.  If not see
  <http://www.gnu.org/licenses/>.
*/
 
 
#ifndef _aspect_simulator_access_h
#define _aspect_simulator_access_h
 
#include <aspect/global.h>
#include <aspect/parameters.h>
#include <aspect/introspection.h>
 
#include <deal.II/base/table_handler.h>
#include <deal.II/base/timer.h>
#include <deal.II/base/conditional_ostream.h>
#include <deal.II/distributed/tria.h>
#include <deal.II/dofs/dof_handler.h>
#include <deal.II/fe/fe.h>
#include <deal.II/fe/mapping_q.h>
#include <deal.II/lac/affine_constraints.h>
 
namespace WorldBuilder
{
  class World;
}
 
namespace aspect
{
  // forward declarations:
  template <int dim> class Simulator;
  template <int dim> struct SimulatorSignals;
  template <int dim> class LateralAveraging;
  template <int dim> struct RotationProperties;
 
  namespace GravityModel
  {
    template <int dim> class Interface;
  }
 
  namespace HeatingModel
  {
    template <int dim> class Manager;
  }
 
  namespace PrescribedDilation
  {
    template <int dim> class Manager;
  }
 
  namespace MaterialModel
  {
    template <int dim> class Interface;
  }
 
  namespace InitialTemperature
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace BoundaryTemperature
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace BoundaryHeatFlux
  {
    template <int dim> class Interface;
  }
 
  namespace BoundaryConvectiveHeating
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace BoundaryComposition
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace BoundaryTraction
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace BoundaryVelocity
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace InitialComposition
  {
    template <int dim> class Manager;
    template <int dim> class Interface;
  }
 
  namespace InitialTopographyModel
  {
    template <int dim> class Interface;
  }
 
  namespace MeshRefinement
  {
    template <int dim> class Manager;
  }
 
  namespace AdiabaticConditions
  {
    template <int dim> class Interface;
  }
 
  namespace Postprocess
  {
    template <int dim> class Manager;
  }
 
  template <int dim> class MeltHandler;
  template <int dim> class VolumeOfFluidHandler;
 
  namespace MeshDeformation
  {
    template <int dim> class MeshDeformationHandler;
  }
 
  template <int dim> class NewtonHandler;
 
  template <int dim> class StokesMatrixFreeHandler;
 
  namespace Particle
  {
    template <int dim> class Manager;
  }
 
  namespace StokesSolver
  {
    template <int dim> class Interface;
  }
 
  namespace TimeStepping
  {
    template <int dim> class Manager;
  }
 
  namespace PrescribedSolution
  {
    template <int dim> class  Manager;
  }
 
  template <int dim>
  class SimulatorAccess
  {
    public:
      SimulatorAccess ();
 
      SimulatorAccess (const Simulator<dim> &simulator_object);
 
      virtual ~SimulatorAccess ();
 
      virtual void initialize_simulator (const Simulator<dim> &simulator_object);
 
      const Introspection<dim> &
      introspection () const;
 
      const Simulator<dim> &
      get_simulator () const;
 
      const Parameters<dim> &
      get_parameters () const;
 
      SimulatorSignals<dim> &
      get_signals() const;
 
      MPI_Comm
      get_mpi_communicator () const;
 
      TimerOutput &
      get_computing_timer () const;
 
      const ConditionalOStream &
      get_pcout () const;
 
      double get_time () const;
 
      double
      get_timestep () const;
 
      double
      get_old_timestep () const;
 
      unsigned int
      get_timestep_number () const;
 
      const TimeStepping::Manager<dim> &
      get_timestepping_manager() const;
 
      unsigned int
      get_nonlinear_iteration () const;
 
      const parallel::distributed::Triangulation<dim> &
      get_triangulation () const;
 
      double
      get_volume () const;
 
      const Mapping<dim> &
      get_mapping () const;
 
      std::string
      get_output_directory () const;
 
      unsigned int
      get_checkpoint_id () const;
 
      bool
      include_adiabatic_heating () const;
 
      bool
      include_latent_heat () const;
 
      bool
      include_melt_transport () const;
 
      int
      get_stokes_velocity_degree () const;
 
      double
      get_adiabatic_surface_temperature () const;
 
      double
      get_surface_pressure () const;
 
      bool
      convert_output_to_years () const;
 
      unsigned int
      get_pre_refinement_step () const;
 
      unsigned int
      n_compositional_fields () const;
 
      double
      get_end_time () const;
 
      void
      get_refinement_criteria(Vector<float> &estimated_error_per_cell) const;
 
      void
      get_artificial_viscosity(Vector<float> &viscosity_per_cell,
                               const bool skip_interior_cells = false) const;
 
      void
      get_artificial_viscosity_composition(Vector<float> &viscosity_per_cell,
                                           const unsigned int compositional_variable) const;
      const LinearAlgebra::BlockVector &
      get_current_linearization_point () const;
 
      const LinearAlgebra::BlockVector &
      get_solution () const;
 
      const LinearAlgebra::BlockVector &
      get_old_solution () const;
 
      const LinearAlgebra::BlockVector &
      get_old_old_solution () const;
 
      const LinearAlgebra::BlockVector &
      get_reaction_vector () const;
 
      const LinearAlgebra::BlockVector &
      get_mesh_velocity () const;
 
      const DoFHandler<dim> &
      get_dof_handler () const;
 
      const FiniteElement<dim> &
      get_fe () const;
 
      const LinearAlgebra::BlockSparseMatrix &
      get_system_matrix () const;
 
      const LinearAlgebra::BlockSparseMatrix &
      get_system_preconditioner_matrix () const;
 
      const MaterialModel::Interface<dim> &
      get_material_model () const;
 
      const GravityModel::Interface<dim> &
      get_gravity_model () const;
 
      const InitialTopographyModel::Interface<dim> &
      get_initial_topography_model () const;
 
      const std::shared_ptr<const InitialTopographyModel::Interface<dim>>
      get_initial_topography_model_pointer () const;
 
      const GeometryModel::Interface<dim> &
      get_geometry_model () const;
 
 
      const AdiabaticConditions::Interface<dim> &
      get_adiabatic_conditions () const;
 
      bool has_boundary_temperature () const;
 
      const BoundaryTemperature::Manager<dim> &
      get_boundary_temperature_manager () const;
 
      const BoundaryConvectiveHeating::Manager<dim> &
      get_boundary_convective_heating_manager () const;
 
      const BoundaryHeatFlux::Interface<dim> &
      get_boundary_heat_flux () const;
 
      bool has_boundary_composition () const;
 
      const BoundaryComposition::Manager<dim> &
      get_boundary_composition_manager () const;
 
      const BoundaryTraction::Manager<dim> &
      get_boundary_traction_manager () const;
 
      std::shared_ptr<const InitialTemperature::Manager<dim>>
      get_initial_temperature_manager_pointer () const;
 
      const InitialTemperature::Manager<dim> &
      get_initial_temperature_manager () const;
 
      std::shared_ptr<const InitialComposition::Manager<dim>>
      get_initial_composition_manager_pointer () const;
 
      const InitialComposition::Manager<dim> &
      get_initial_composition_manager () const;
 
      const std::set<types::boundary_id> &
      get_fixed_temperature_boundary_indicators () const;
 
      const std::set<types::boundary_id> &
      get_fixed_heat_flux_boundary_indicators () const;
 
      const std::set<types::boundary_id> &
      get_fixed_convective_heating_boundary_indicators () const;
 
      const std::set<types::boundary_id> &
      get_fixed_composition_boundary_indicators () const;
 
      const std::set<types::boundary_id> &
      get_mesh_deformation_boundary_indicators () const;
 
      const BoundaryVelocity::Manager<dim> &
      get_boundary_velocity_manager () const;
 
      const HeatingModel::Manager<dim> &
      get_heating_model_manager () const;
 
      const PrescribedDilation::Manager<dim> &
      get_prescribed_dilation_manager () const;
 
      const MeshRefinement::Manager<dim> &
      get_mesh_refinement_manager () const;
 
      const MeltHandler<dim> &
      get_melt_handler () const;
 
      const VolumeOfFluidHandler<dim> &
      get_volume_of_fluid_handler () const;
 
      const NewtonHandler<dim> &
      get_newton_handler () const;
 
#ifdef ASPECT_WITH_WORLD_BUILDER
      const WorldBuilder::World &
      get_world_builder () const;
 
      std::shared_ptr<const WorldBuilder::World>
      get_world_builder_pointer () const;
#endif
      const MeshDeformation::MeshDeformationHandler<dim> &
      get_mesh_deformation_handler () const;
 
      const LateralAveraging<dim> &
      get_lateral_averaging () const;
 
      const AffineConstraints<double> &
      get_current_constraints () const;
 
      bool simulator_is_past_initialization () const;
 
      double
      get_pressure_scaling () const;
 
      bool
      pressure_rhs_needs_compatibility_modification() const;
 
      bool
      stokes_A_block_is_symmetric() const;
 
      bool
      model_has_prescribed_stokes_solution () const;
 
      static
      void
      get_composition_values_at_q_point (const std::vector<std::vector<double>> &composition_values,
                                         const unsigned int                      q,
                                         std::vector<double>                    &composition_values_at_q_point);
 
      TableHandler &get_statistics_object() const;
 
      const Postprocess::Manager<dim> &
      get_postprocess_manager () const;
 
      unsigned int
      n_particle_managers() const;
 
      const Particle::Manager<dim> &
      get_particle_manager(const unsigned int particle_manager_index) const;
 
      Particle::Manager<dim> &
      get_particle_manager(const unsigned int particle_manager_index);
 
      bool is_stokes_matrix_free() const;
 
      const StokesMatrixFreeHandler<dim> &
      get_stokes_matrix_free () const;
 
      const StokesSolver::Interface<dim> &
      get_stokes_solver () const;
 
      const PrescribedSolution::Manager<dim> &
      get_prescribed_solution () const;
 
      RotationProperties<dim>
      compute_net_angular_momentum(const bool use_constant_density,
                                   const LinearAlgebra::BlockVector &solution,
                                   const bool limit_to_top_faces = false) const;
 
      void remove_nullspace(LinearAlgebra::BlockVector &solution,
                            LinearAlgebra::BlockVector &distributed_stokes_solution) const;
 
      double normalize_pressure(LinearAlgebra::BlockVector &vector) const;
 
      void denormalize_pressure(const double                      pressure_adjustment,
                                LinearAlgebra::BlockVector       &vector) const;
 
    private:
      ObserverPointer<const Simulator<dim>, SimulatorAccess<dim>> simulator;
  };
}
 
 
#endif