interface.h

Go to the documentation of this file.

/*
 Copyright (C) 2015 - 2022 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_particle_property_interface_h
#define _aspect_particle_property_interface_h

#include <aspect/global.h>
#include <aspect/plugins.h>

#include <aspect/particle/interpolator/interface.h>
#include <aspect/simulator_access.h>

#include <deal.II/particles/particle.h>
#include <deal.II/particles/particle_handler.h>
#include <deal.II/particles/property_pool.h>
#include <deal.II/fe/fe_update_flags.h>

#include <memory>

namespace aspect
{
  namespace Particle
  {
    namespace Property
    {
      using namespace ::Particles;

      class ParticlePropertyInformation
      {
        public:
          ParticlePropertyInformation();

          ParticlePropertyInformation(const std::vector<std::vector<std::pair<std::string,unsigned int>>> &property_information);

          bool
          fieldname_exists(const std::string &name) const;

          unsigned int
          get_field_index_by_name(const std::string &name) const;

          std::string
          get_field_name_by_index(const unsigned int field_index) const;

          unsigned int
          get_position_by_field_name(const std::string &name) const;

          unsigned int
          get_components_by_field_name(const std::string &name) const;

          unsigned int
          get_position_by_field_index(const unsigned int field_index) const;

          unsigned int
          get_components_by_field_index(const unsigned int field_index) const;

          unsigned int
          get_position_by_plugin_index(const unsigned int plugin_index) const;

          unsigned int
          get_components_by_plugin_index(const unsigned int plugin_index) const;

          unsigned int
          get_fields_by_plugin_index(const unsigned int plugin_index) const;


          unsigned int
          n_plugins() const;

          unsigned int
          n_fields() const;

          unsigned int
          n_components() const;

        private:
          std::vector<std::string> field_names;

          std::vector<unsigned int> components_per_field;

          std::vector<unsigned int> position_per_field;

          std::vector<unsigned int> fields_per_plugin;

          std::vector<unsigned int> components_per_plugin;

          std::vector<unsigned int> position_per_plugin;

          unsigned int number_of_components;

          unsigned int number_of_fields;

          unsigned int number_of_plugins;
      };

      enum UpdateTimeFlags
      {
        update_never,
        update_output_step,
        update_time_step
      };

      enum InitializationModeForLateParticles
      {
        initialize,
        interpolate,
        interpolate_respect_boundary,
        initialize_to_zero
      };

      template <int dim>
      class Interface
      {
        public:
          virtual ~Interface () = default;

          virtual
          void
          initialize ();

          virtual
          void
          initialize_one_particle_property (const Point<dim> &position,
                                            std::vector<double> &particle_properties) const;

          virtual
          void
          update_particle_property (const unsigned int data_position,
                                    const Vector<double> &solution,
                                    const std::vector<Tensor<1,dim>> &gradients,
                                    typename ParticleHandler<dim>::particle_iterator &particle) const;

          DEAL_II_DEPRECATED
          virtual
          void
          update_one_particle_property (const unsigned int data_position,
                                        const Point<dim> &position,
                                        const Vector<double> &solution,
                                        const std::vector<Tensor<1,dim>> &gradients,
                                        const ArrayView<double> &particle_properties) const;

          virtual
          UpdateTimeFlags
          need_update () const;

          virtual
          UpdateFlags
          get_needed_update_flags () const;

          virtual
          InitializationModeForLateParticles
          late_initialization_mode () const;

          virtual
          std::vector<std::pair<std::string, unsigned int>>
          get_property_information() const = 0;


          static
          void
          declare_parameters (ParameterHandler &prm);

          virtual
          void
          parse_parameters (ParameterHandler &prm);
      };

      template <int dim>
      class IntegratorProperties : public Interface<dim>
      {
        public:
          void
          initialize_one_particle_property (const Point<dim> &position,
                                            std::vector<double> &particle_properties) const override;

          std::vector<std::pair<std::string, unsigned int>>
          get_property_information() const override;

          void
          parse_parameters (ParameterHandler &prm) override;

        private:
          unsigned int n_integrator_properties;
      };



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

          ~Manager () override;

          void
          initialize ();

          void
          initialize_one_particle (typename ParticleHandler<dim>::particle_iterator &particle) const;

          std::vector<double>
          initialize_late_particle (const Point<dim> &particle_location,
                                    const ParticleHandler<dim> &particle_handler,
                                    const Interpolator::Interface<dim> &interpolator,
                                    const typename parallel::distributed::Triangulation<dim>::active_cell_iterator &cell = typename parallel::distributed::Triangulation<dim>::active_cell_iterator()) const;

          void
          update_one_particle (typename ParticleHandler<dim>::particle_iterator &particle,
                               const Vector<double> &solution,
                               const std::vector<Tensor<1,dim>> &gradients) const;

          UpdateTimeFlags
          need_update () const;

          UpdateFlags
          get_needed_update_flags () const;

          bool
          plugin_name_exists(const std::string &name) const;

          bool
          check_plugin_order(const std::string &first, const std::string &second) const;

          unsigned int get_plugin_index_by_name(const std::string &name) const;

          template <typename ParticlePropertyType>
          inline
          bool
          has_matching_property () const;

          template <typename ParticlePropertyType>
          inline
          const ParticlePropertyType &
          get_matching_property () const;

          unsigned int
          get_n_property_components () const;

          std::size_t
          get_particle_size () const;

          const ParticlePropertyInformation &
          get_data_info() const;

          DEAL_II_DEPRECATED
          unsigned int
          get_property_component_by_name(const std::string &name) const;

          static
          void
          register_particle_property (const std::string &name,
                                      const std::string &description,
                                      void (*declare_parameters_function) (ParameterHandler &),
                                      std::unique_ptr<Property::Interface<dim>> (*factory_function) ());


          static
          void
          declare_parameters (ParameterHandler &prm);

          void
          parse_parameters (ParameterHandler &prm);


          static
          void
          write_plugin_graph (std::ostream &output_stream);

        private:
          std::vector<std::string> plugin_names;

          std::list<std::unique_ptr<Interface<dim>>> property_list;

          ParticlePropertyInformation property_information;
      };

      /* -------------------------- inline and template functions ---------------------- */


      template <int dim>
      template <typename ParticlePropertyType>
      inline
      bool
      Manager<dim>::has_matching_property () const
      {
        for (const auto &p : property_list)
          if (Plugins::plugin_type_matches<ParticlePropertyType>(*p))
            return true;

        return false;
      }


      template <int dim>
      template <typename ParticlePropertyType>
      inline
      const ParticlePropertyType &
      Manager<dim>::get_matching_property () const
      {
        AssertThrow(has_matching_property<ParticlePropertyType> (),
                    ExcMessage("You asked Particle::Property::Manager::has_matching_property() for a "
                               "particle property of type <" + boost::core::demangle(typeid(ParticlePropertyType).name()) + "> "
                               "that could not be found in the current model. Activate this "
                               "particle property in the input file."));

        typename std::vector<std::unique_ptr<Interface<dim>>>::const_iterator property;
        for (const auto &p : property_list)
          if (Plugins::plugin_type_matches<ParticlePropertyType>(*p))
            return Plugins::get_plugin_as_type<ParticlePropertyType>(*p);

        // We will never get here, because we had the Assert above. Just to avoid warnings.
        return Plugins::get_plugin_as_type<ParticlePropertyType>(*(*property));
      }


#define ASPECT_REGISTER_PARTICLE_PROPERTY(classname,name,description) \
  template class classname<2>; \
  template class classname<3>; \
  namespace ASPECT_REGISTER_PARTICLE_PROPERTY_ ## classname \
  { \
    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Property::Interface<2>,classname<2>> \
    dummy_ ## classname ## _2d (&aspect::Particle::Property::Manager<2>::register_particle_property, \
                                name, description); \
    aspect::internal::Plugins::RegisterHelper<aspect::Particle::Property::Interface<3>,classname<3>> \
    dummy_ ## classname ## _3d (&aspect::Particle::Property::Manager<3>::register_particle_property, \
                                name, description); \
  }

    }
  }
}

#endif