Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <pup.h>
       8             : #include <type_traits>
       9             : 
      10             : #include "DataStructures/DataBox/MetavariablesTag.hpp"
      11             : #include "DataStructures/DataBox/ObservationBox.hpp"
      12             : #include "Domain/Amr/Flag.hpp"
      13             : #include "Domain/Structure/ElementId.hpp"
      14             : #include "Parallel/GlobalCache.hpp"
      15             : #include "ParallelAlgorithms/Amr/Criteria/Type.hpp"
      16             : #include "Utilities/CallWithDynamicType.hpp"
      17             : #include "Utilities/Serialization/CharmPupable.hpp"
      18             : #include "Utilities/TMPL.hpp"
      19             : 
      20             : namespace amr {
      21             : /// \ingroup AmrGroup
      22             : /// \brief Base class for something that determines how an adaptive mesh should
      23             : /// be changed
      24             : ///
      25             : /// \details Each class derived from this class should (see the examples below):
      26             : /// - Be option-creatable
      27             : /// - Be serializable
      28             : /// - Define a call operator that returns a std::array<amr::Flag, Dim>
      29             : ///   containing the recommended refinement choice in each logical dimension of
      30             : ///   the Element.
      31             : /// - Define the type aliases `argument_tags` and
      32             : ///   `compute_tags_for_observation_box` that are type lists of tags used in the
      33             : ///   call operator.
      34             : /// The call operator should take as arguments the values corresponding to each
      35             : /// tag in `argument_tags` (in order), followed by the Parallel::GlobalCache,
      36             : /// and the ElementId.  The tags listed in `argument_tags` should either be tags
      37             : /// in the DataBox of the array component, or listed in
      38             : /// `compute_tags_for_observation_box`.
      39             : ///
      40             : /// \example
      41             : /// \snippet Amr/Criteria/Test_Criterion.cpp criterion_examples
      42           1 : class Criterion : public PUP::able {
      43             :  protected:
      44             :   /// \cond
      45             :   Criterion() = default;
      46             :   Criterion(const Criterion&) = default;
      47             :   Criterion(Criterion&&) = default;
      48             :   Criterion& operator=(const Criterion&) = default;
      49             :   Criterion& operator=(Criterion&&) = default;
      50             :   /// \endcond
      51             : 
      52             :  public:
      53           0 :   ~Criterion() override = default;
      54           0 :   explicit Criterion(CkMigrateMessage* msg) : PUP::able(msg) {}
      55             : 
      56           0 :   WRAPPED_PUPable_abstract(Criterion);  // NOLINT
      57             : 
      58           0 :   virtual Criteria::Type type() = 0;
      59             : 
      60           0 :   virtual std::string observation_name() = 0;
      61             : 
      62             :   /// Evaluates the AMR criteria by selecting the appropriate derived class
      63             :   /// and forwarding its `argument_tags` from the ObservationBox (along with the
      64             :   /// GlobalCache and ArrayIndex) to the call operator of the derived class
      65             :   ///
      66             :   /// \note In order to be available, a derived Criterion must be listed in
      67             :   /// the entry for Criterion in
      68             :   /// Metavarialbes::factory_creation::factory_classes
      69             :   ///
      70             :   /// \note The ComputeTagsList of the ObservationBox should contain the union
      71             :   /// of the tags listed in `compute_tags_for_observation_box` for each derived
      72             :   /// Criterion listed in the `factory_classes`.
      73             :   template <typename ComputeTagsList, typename DataBoxType,
      74             :             typename Metavariables>
      75           1 :   auto evaluate(const ObservationBox<ComputeTagsList, DataBoxType>& box,
      76             :                 Parallel::GlobalCache<Metavariables>& cache,
      77             :                 const ElementId<Metavariables::volume_dim>& element_id) const {
      78             :     using factory_classes =
      79             :         typename std::decay_t<Metavariables>::factory_creation::factory_classes;
      80             :     return call_with_dynamic_type<
      81             :         std::array<amr::Flag, Metavariables::volume_dim>,
      82             :         tmpl::at<factory_classes, Criterion>>(
      83             :         this, [&box, &cache, &element_id](auto* const criterion) {
      84             :           return apply(*criterion, box, cache, element_id);
      85             :         });
      86             :   }
      87             : };
      88             : }  // namespace amr