simulator_access.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 - 2024 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 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 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 TimeStepping
  {
    template <int dim> class Manager;
  }

  template <int dim>
  class SimulatorAccess
  {
    public:
      SimulatorAccess ();

      SimulatorAccess (const Simulator<dim> &simulator_object);

      virtual ~SimulatorAccess () = default;

      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;

      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 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 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_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 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
      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 StokesMatrixFreeHandler<dim> &
      get_stokes_matrix_free () 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:
      const Simulator<dim> *simulator;
  };
}


#endif