interface.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_particle_property_interface_h
#define _aspect_particle_property_interface_h

#include <aspect/particle/interface.h>
#include <aspect/global.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;

      template <int dim>
      struct ParticleUpdateInputs
      {
        public:
          std::vector<small_vector<double,50>> solution;

          std::vector<small_vector<Tensor<1,dim>,50>> gradients;

          typename DoFHandler<dim>::active_cell_iterator current_cell;
      };

      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;


          std::vector<std::string>
          get_property_names() 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 ParticleInterfaceBase
      {
        public:
          virtual
          void
          initialize_one_particle_property (const Point<dim> &position,
                                            std::vector<double> &particle_properties) const;

          virtual
          void
          update_particle_properties (const ParticleUpdateInputs<dim> &inputs,
                                      typename ParticleHandler<dim>::particle_iterator_range &particles) const;

          DEAL_II_DEPRECATED
          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;


          virtual
          UpdateTimeFlags
          need_update () const;

          virtual
          UpdateFlags
          get_update_flags (const unsigned int component) const;

          DEAL_II_DEPRECATED
          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;

          virtual
          void
          set_data_position (const unsigned int data_position);

          virtual
          unsigned int
          get_data_position () const;

        protected:
          unsigned int data_position;
      };

      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 Plugins::ManagerBase<Interface<dim>>, public SimulatorAccess<dim>
      {
        public:
          void
          initialize () override;

          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_particles (ParticleUpdateInputs<dim> &inputs,
                            typename ParticleHandler<dim>::particle_iterator_range &particles) const;

          UpdateTimeFlags
          need_update () const;

          std::vector<UpdateFlags>
          get_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,
                    typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,ParticlePropertyType>::value>>
          DEAL_II_DEPRECATED
          bool
          has_matching_property () const;

          template <typename ParticlePropertyType,
                    typename = typename std::enable_if_t<std::is_base_of<Interface<dim>,ParticlePropertyType>::value>>
          DEAL_II_DEPRECATED
          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;

          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) override;

          void set_particle_manager_index(unsigned int particle_manager_index);

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

        private:
          unsigned int particle_manager_index;

          ParticlePropertyInformation property_information;
      };

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


      template <int dim>
      template <typename ParticlePropertyType, typename>
      inline
      bool
      Manager<dim>::has_matching_property () const
      {
        return this->template has_matching_active_plugin<ParticlePropertyType>();
      }


      template <int dim>
      template <typename ParticlePropertyType, typename>
      inline
      const ParticlePropertyType &
      Manager<dim>::get_matching_property () const
      {
        return this->template get_matching_active_plugin<ParticlePropertyType>();
      }


#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