Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : #include <pup.h>
       8              : 
       9              : #include "DataStructures/DataBox/DataBox.hpp"
      10              : #include "DataStructures/DataBox/ObservationBox.hpp"
      11              : #include "NumericalAlgorithms/Strahlkorper/Strahlkorper.hpp"
      12              : #include "Parallel/GlobalCache.hpp"
      13              : #include "ParallelAlgorithms/ApparentHorizonFinder/FastFlow.hpp"
      14              : #include "Utilities/CallWithDynamicType.hpp"
      15              : #include "Utilities/Serialization/CharmPupable.hpp"
      16              : 
      17              : namespace ah {
      18              : /*!
      19              :  * \ingroup SurfacesGroup
      20              :  * \brief Base class for criteria that determine how the resolution of an
      21              :  * apparent horizon should be changed
      22              :  *
      23              :  * \details Each class derived from this class should
      24              :  * - Be option-creatable
      25              :  * - Be serializable
      26              :  * - Define the type aliases `argument_tags` and
      27              :  *   `compute_tags_for_observation_box` that are type lists of tags used in the
      28              :  *   call operator
      29              :  * - Define a call operator that returns a `size_t` that is the recommended
      30              :  *   resolution $L$ for the Strahlkorper representing the apparent horizon
      31              :  *
      32              :  * The call operator should take the following arguments, in order:
      33              :  * - An argument for each tag in `argument_tags`
      34              :  * - The Parallel::GlobalCache
      35              :  * - The Strahlkorper representing the apparent horizon
      36              :  * - A FastFlow::IterInfo corresponding to the horizon find that found the
      37              :  *   Strahlkorper
      38              :  */
      39            1 : class Criterion : public PUP::able {
      40              :  protected:
      41              :   /// \cond
      42              :   Criterion() = default;
      43              :   Criterion(const Criterion&) = default;
      44              :   Criterion(Criterion&&) = default;
      45              :   Criterion& operator=(const Criterion&) = default;
      46              :   Criterion& operator=(Criterion&&) = default;
      47              :   /// \endcond
      48              :  public:
      49            0 :   ~Criterion() override = default;
      50            0 :   explicit Criterion(CkMigrateMessage* msg) : PUP::able(msg) {}
      51              : 
      52            0 :   WRAPPED_PUPable_abstract(Criterion);
      53              : 
      54            0 :   virtual std::string observation_name() = 0;
      55              : 
      56            0 :   virtual bool is_equal(const Criterion& other) const = 0;
      57              : 
      58              :   /// Evaluates the apparent horizon criteria by selecting the appropriate
      59              :   /// derived class and forwarding its `argument_tags` from the ObservationBox
      60              :   /// (along with the GlobalCache) to the call operator of the
      61              :   /// derived class
      62              :   ///
      63              :   /// \note In order to be available, a derived Criterion must be listed in
      64              :   /// the entry for Criterion in
      65              :   /// Metavarialbes::factory_creation::factory_classes
      66              :   ///
      67              :   /// \note The ComputeTagsList of the ObservationBox should contain the union
      68              :   /// of the tags listed in `compute_tags_for_observation_box` for each derived
      69              :   /// Criterion listed in the `factory_classes`.
      70              :   template <typename ComputeTagsList, typename DataBoxType,
      71              :             typename Metavariables, typename Frame>
      72            1 :   auto evaluate(const ObservationBox<ComputeTagsList, DataBoxType>& box,
      73              :                 Parallel::GlobalCache<Metavariables>& cache,
      74              :                 const ylm::Strahlkorper<Frame>& strahlkorper,
      75              :                 const FastFlow::IterInfo& info) const {
      76              :     using factory_classes =
      77              :         typename std::decay_t<Metavariables>::factory_creation::factory_classes;
      78              :     return call_with_dynamic_type<size_t, tmpl::at<factory_classes, Criterion>>(
      79              :         this, [&box, &cache, &strahlkorper, &info](auto* const criterion) {
      80              :           return apply(*criterion, box, cache, strahlkorper, info);
      81              :         });
      82              :   }
      83              : };
      84              : }  // namespace ah