simulator_signals.h

Go to the documentation of this file.

/*
  Copyright (C) 2015 - 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_signals_h
#define _aspect_simulator_signals_h

#include <aspect/global.h>
#include <aspect/simulator_access.h>
#include <aspect/parameters.h>

#include <deal.II/base/parameter_handler.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/lac/solver_control.h>

#include <boost/signals2.hpp>

namespace aspect
{
  namespace Assemblers
  {
    template <int dim>
    class Manager;

    template <int dim>
    class Interface;
  }

  template <int dim>
  struct SimulatorSignals
  {
    boost::signals2::signal<void (std::vector<VariableDeclaration<dim>> &)>
    edit_finite_element_variables;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_set_initial_state;

    boost::signals2::signal<void (const SimulatorAccess<dim> &)>  post_set_initial_state;

    boost::signals2::signal<void (const SimulatorAccess<dim> &)>  start_timestep;

    boost::signals2::signal<void (const SimulatorAccess<dim> &,
                                  AffineConstraints<double> &)>  post_constraints_creation;

    boost::signals2::signal<void (const SimulatorAccess<dim> &,
                                  Parameters<dim> &parameters)>  edit_parameters_pre_setup_dofs;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_refinement_store_user_data;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_refinement_load_user_data;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_compute_no_normal_flux_constraints;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_compute_no_normal_flux_constraints;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  pre_checkpoint_store_user_data;

    boost::signals2::signal<void (typename parallel::distributed::Triangulation<dim> &)>  post_resume_load_user_data;

    boost::signals2::signal<double (const double pressure_scaling, const double reference_viscosity, const double length_scale)>  modify_pressure_scaling;

    static boost::signals2::signal<void (const unsigned int aspect_dim,
                                         ParameterHandler &prm)>  declare_additional_parameters;

    static boost::signals2::signal<void (const Parameters<dim> &,
                                         ParameterHandler &)>  parse_additional_parameters;

    boost::signals2::signal<void (const SimulatorAccess<dim> &,
                                  const unsigned int number_S_iterations,
                                  const unsigned int number_A_iterations,
                                  const SolverControl &solver_control_cheap,
                                  const SolverControl &solver_control_expensive)> post_stokes_solver;

    boost::signals2::signal<void (const SimulatorAccess<dim> &,
                                  const bool solved_temperature_field,
                                  const unsigned int compositional_index,
                                  const SolverControl &solver_control)> post_advection_solver;

    boost::signals2::signal<void (const SolverControl &)> post_nonlinear_solver;

    boost::signals2::signal<void (const SimulatorAccess<dim> &,
                                  const unsigned int iteration_count)> post_ARKode_solve;

    boost::signals2::signal<void (const SimulatorAccess<dim> &)> post_mesh_deformation;

    boost::signals2::signal<void (const SimulatorAccess<dim> &)> pre_nonlinear_solver;

    boost::signals2::signal<void (const SimulatorAccess<dim> &,
                                  aspect::Assemblers::Manager<dim> &)>
    set_assemblers;

    boost::signals2::signal<void (DataOut<dim> &)>  pre_data_out_build_patches;

    boost::signals2::signal<void (Particle::Manager<dim> &)> post_restore_particles;

  };


  // Explain to the compiler that we instantiate this class elsewhere, along
  // with its static members. This is necessary to avoid warnings by some
  // compilers.
  extern template struct SimulatorSignals<2>;
  extern template
  boost::signals2::signal<void (const unsigned int aspect_dim, ParameterHandler &prm)>
  SimulatorSignals<2>::declare_additional_parameters;
  extern template
  boost::signals2::signal<void (const Parameters<2> &, ParameterHandler &)>
  SimulatorSignals<2>::parse_additional_parameters;

  extern template struct SimulatorSignals<3>;
  extern template
  boost::signals2::signal<void (const unsigned int aspect_dim, ParameterHandler &prm)>
  SimulatorSignals<3>::declare_additional_parameters;
  extern template
  boost::signals2::signal<void (const Parameters<3> &, ParameterHandler &)>
  SimulatorSignals<3>::parse_additional_parameters;


  namespace internals
  {
    namespace SimulatorSignals
    {
      void register_connector_function_2d (const std::function<void (aspect::SimulatorSignals<2> &)> &connector);
      void register_connector_function_3d (const std::function<void (aspect::SimulatorSignals<3> &)> &connector);

      template <int dim>
      void call_connector_functions (aspect::SimulatorSignals<dim> &signals);
    }
  }


#define ASPECT_REGISTER_SIGNALS_CONNECTOR(connector_function_2d,connector_function_3d) \
  namespace ASPECT_REGISTER_SIGNALS_CONNECTOR \
  { \
    struct dummy_do_register \
    {          \
      dummy_do_register () \
      { \
        aspect::internals::SimulatorSignals::register_connector_function_2d (connector_function_2d); \
        aspect::internals::SimulatorSignals::register_connector_function_3d (connector_function_3d); \
      } \
    } dummy_variable; \
  }


#define ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR(connector_function) \
  namespace ASPECT_REGISTER_SIGNALS_PARAMETER_CONNECTOR_ ## connector_function \
  { \
    struct dummy_do_register_ ## connector_function \
    { \
      dummy_do_register_ ## connector_function () \
      {                \
        connector_function (); \
      }          \
    } dummy_variable_ ## classname; \
  }

}
#endif