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             : #include <string>
       9             : #include <vector>
      10             : 
      11             : #include "DataStructures/DataBox/ObservationBox.hpp"
      12             : #include "DataStructures/FloatingPointType.hpp"
      13             : #include "DataStructures/Tensor/IndexType.hpp"
      14             : #include "DataStructures/Tensor/Tensor.hpp"
      15             : #include "DataStructures/Tensor/TypeAliases.hpp"
      16             : #include "Domain/Amr/Flag.hpp"
      17             : #include "IO/H5/TensorData.hpp"
      18             : #include "Options/String.hpp"
      19             : #include "ParallelAlgorithms/Amr/Criteria/Criterion.hpp"
      20             : #include "ParallelAlgorithms/Amr/Criteria/Tags/Criteria.hpp"
      21             : #include "ParallelAlgorithms/Events/ObserveConstantsPerElement.hpp"
      22             : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
      23             : #include "Utilities/Gsl.hpp"
      24             : #include "Utilities/Serialization/CharmPupable.hpp"
      25             : #include "Utilities/TMPL.hpp"
      26             : 
      27             : /// \cond
      28             : template <size_t VolumeDim>
      29             : class Domain;
      30             : template <size_t VolumeDim>
      31             : class ElementId;
      32             : namespace domain {
      33             : namespace FunctionsOfTime {
      34             : class FunctionOfTime;
      35             : }  // namespace FunctionsOfTime
      36             : namespace Tags {
      37             : template <size_t VolumeDim>
      38             : struct Domain;
      39             : struct FunctionsOfTime;
      40             : }  // namespace Tags
      41             : }  // namespace domain
      42             : namespace Parallel {
      43             : template <typename Metavariables>
      44             : class GlobalCache;
      45             : }  // namespace Parallel
      46             : namespace Tags {
      47             : struct Time;
      48             : struct TimeStep;
      49             : }  // namespace Tags
      50             : /// \endcond
      51             : 
      52             : namespace amr::Events {
      53             : namespace detail {
      54             : template <typename Criterion>
      55             : struct get_compute_tags {
      56             :   using type = typename Criterion::compute_tags_for_observation_box;
      57             : };
      58             : }  // namespace detail
      59             : 
      60             : /// \brief Observe the desired decisions of AMR criteria
      61             : ///
      62             : /// \details The event will return a vector of decisions (an independent choice
      63             : /// in each logical dimension) for each of the AMR criteria.  These are the raw
      64             : /// choices made by each AMR critera, not taking into account any AMR policies.
      65             : /// Each element is output as a single cell with two points per dimension and
      66             : /// the observation constant on all those points.  The decisions are converted
      67             : /// to values as follows (in each logical dimension):
      68             : /// - -2.0 is for join with sibling (if possible)
      69             : /// - -1.0 is for decrease number of grid points
      70             : /// - 0.0 is for no change
      71             : /// - 1.0 is for increase number of grid points
      72             : /// - 2.0 is for splitting the element
      73             : template <typename Metavariables>
      74           1 : class ObserveAmrCriteria
      75             :     : public dg::Events::ObserveConstantsPerElement<Metavariables::volume_dim> {
      76             :  public:
      77           0 :   static constexpr size_t volume_dim = Metavariables::volume_dim;
      78             :   /// \cond
      79             :   explicit ObserveAmrCriteria(CkMigrateMessage* m)
      80             :       : dg::Events::ObserveConstantsPerElement<volume_dim>(m) {}
      81             :   using PUP::able::register_constructor;
      82             :   WRAPPED_PUPable_decl_template(ObserveAmrCriteria);  // NOLINT
      83             :   /// \endcond
      84             : 
      85           0 :   static constexpr Options::String help =
      86             :       "Observe the desired decisions of AMR criteria in the volume.";
      87             : 
      88           0 :   ObserveAmrCriteria() = default;
      89             : 
      90           0 :   ObserveAmrCriteria(const std::string& subfile_name,
      91             :                      ::FloatingPointType coordinates_floating_point_type,
      92             :                      ::FloatingPointType floating_point_type)
      93             :       : dg::Events::ObserveConstantsPerElement<volume_dim>(
      94             :             subfile_name, coordinates_floating_point_type,
      95             :             floating_point_type) {}
      96             : 
      97           0 :   using compute_tags_for_observation_box =
      98             :       tmpl::remove_duplicates<tmpl::flatten<tmpl::transform<
      99             :           tmpl::at<typename Metavariables::factory_creation::factory_classes,
     100             :                    Criterion>,
     101             :           detail::get_compute_tags<tmpl::_1>>>>;
     102             : 
     103           0 :   using return_tags = tmpl::list<>;
     104           0 :   using argument_tags = tmpl::list<::Tags::ObservationBox>;
     105             : 
     106             :   template <typename DataBoxType, typename ComputeTagsList,
     107             :             typename ParallelComponent>
     108           0 :   void operator()(const ObservationBox<DataBoxType, ComputeTagsList>& box,
     109             :                   Parallel::GlobalCache<Metavariables>& cache,
     110             :                   const ElementId<Metavariables::volume_dim>& element_id,
     111             :                   const ParallelComponent* const component,
     112             :                   const Event::ObservationValue& observation_value) const {
     113             :     const auto& refinement_criteria = get<amr::Criteria::Tags::Criteria>(box);
     114             :     const double time = get<::Tags::Time>(box);
     115             :     const auto& functions_of_time = get<::domain::Tags::FunctionsOfTime>(box);
     116             :     const Domain<volume_dim>& domain =
     117             :         get<::domain::Tags::Domain<volume_dim>>(box);
     118             : 
     119             :     std::vector<TensorComponent> components = this->allocate_and_insert_coords(
     120             :         volume_dim * refinement_criteria.size(), time, functions_of_time,
     121             :         domain, element_id);
     122             : 
     123             :     for (const auto& criterion : refinement_criteria) {
     124             :       const auto decision = criterion->evaluate(box, cache, element_id);
     125             :       for (size_t d = 0; d < volume_dim; ++d) {
     126             :         this->add_constant(
     127             :             make_not_null(&components),
     128             :             criterion->observation_name() +
     129             :                 tnsr::i<double, volume_dim,
     130             :                         Frame::ElementLogical>::component_suffix(d),
     131             :             static_cast<double>(gsl::at(decision, d)) - 3.0);
     132             :       }
     133             :     }
     134             : 
     135             :     this->observe(components, cache, element_id, component, observation_value);
     136             :   }
     137             : 
     138           1 :   bool needs_evolved_variables() const override { return true; }
     139             : 
     140           0 :   void pup(PUP::er& p) override {
     141             :     dg::Events::ObserveConstantsPerElement<volume_dim>::pup(p);
     142             :   }
     143             : };
     144             : 
     145             : /// \cond
     146             : template <typename Metavariables>
     147             : PUP::able::PUP_ID ObserveAmrCriteria<Metavariables>::my_PUP_ID = 0;  // NOLINT
     148             : /// \endcond
     149             : }  // namespace amr::Events