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 <cstddef> 8 : #include <pup.h> 9 : 10 : #include "Domain/Amr/Flag.hpp" 11 : #include "Domain/Tags.hpp" 12 : #include "ParallelAlgorithms/Amr/Criteria/Criterion.hpp" 13 : #include "Utilities/TMPL.hpp" 14 : 15 : /// \cond 16 : template <size_t> 17 : class ElementId; 18 : template <size_t> 19 : class Mesh; 20 : /// \endcond 21 : 22 : namespace amr::Criteria { 23 : /*! 24 : * \brief Refine the grid towards the target number of grid points and 25 : * refinement levels in each dimension and then oscillate about the target. 26 : * 27 : * \details If the grid is at neither target in a given dimension, the 28 : * flag chosen will be in the priority order Split, IncreaseResolution, 29 : * DecreaseResolution, Join. 30 : * 31 : * \note To remain at the target, set the OscillationAtTarget Flags to 32 : * DoNothing. 33 : * 34 : * \note This criterion is primarily for testing the mechanics of refinement. 35 : */ 36 : template <size_t Dim> 37 1 : class DriveToTarget : public Criterion { 38 : public: 39 : /// The target number of grid point in each dimension 40 1 : struct TargetNumberOfGridPoints { 41 0 : using type = std::array<size_t, Dim>; 42 0 : static constexpr Options::String help = { 43 : "The target number of grid points in each dimension."}; 44 : }; 45 : 46 : /// The target refinement level in each dimension 47 1 : struct TargetRefinementLevels { 48 0 : using type = std::array<size_t, Dim>; 49 0 : static constexpr Options::String help = { 50 : "The target refinement level in each dimension."}; 51 : }; 52 : 53 : /// The AMR flags chosen when the target number of grid points and refinement 54 : /// levels are reached 55 1 : struct OscillationAtTarget { 56 0 : using type = std::array<Flag, Dim>; 57 0 : static constexpr Options::String help = { 58 : "The flags returned when at the target."}; 59 : }; 60 : 61 0 : using options = tmpl::list<TargetNumberOfGridPoints, TargetRefinementLevels, 62 : OscillationAtTarget>; 63 : 64 0 : static constexpr Options::String help = { 65 : "Refine the grid towards the TargetNumberOfGridPoints and " 66 : "TargetRefinementLevels, and then oscillate about them by applying " 67 : "OscillationAtTarget."}; 68 : 69 0 : DriveToTarget() = default; 70 : 71 0 : DriveToTarget(const std::array<size_t, Dim>& target_number_of_grid_points, 72 : const std::array<size_t, Dim>& target_refinement_levels, 73 : const std::array<Flag, Dim>& flags_at_target); 74 : 75 : /// \cond 76 : explicit DriveToTarget(CkMigrateMessage* msg); 77 : using PUP::able::register_constructor; 78 : WRAPPED_PUPable_decl_template(DriveToTarget); // NOLINT 79 : /// \endcond 80 : 81 0 : std::string observation_name() override { return "DriveToTarget"; } 82 : 83 0 : using compute_tags_for_observation_box = tmpl::list<>; 84 : 85 0 : using argument_tags = tmpl::list<::domain::Tags::Mesh<Dim>>; 86 : 87 : template <typename Metavariables> 88 0 : auto operator()(const Mesh<Dim>& current_mesh, 89 : Parallel::GlobalCache<Metavariables>& /*cache*/, 90 : const ElementId<Dim>& element_id) const; 91 : 92 0 : void pup(PUP::er& p) override; 93 : 94 : private: 95 0 : std::array<Flag, Dim> impl(const Mesh<Dim>& current_mesh, 96 : const ElementId<Dim>& element_id) const; 97 : 98 0 : std::array<size_t, Dim> target_number_of_grid_points_{}; 99 0 : std::array<size_t, Dim> target_refinement_levels_{}; 100 0 : std::array<Flag, Dim> flags_at_target_{}; 101 : }; 102 : 103 : template <size_t Dim> 104 : template <typename Metavariables> 105 : auto DriveToTarget<Dim>::operator()( 106 : const Mesh<Dim>& current_mesh, 107 : Parallel::GlobalCache<Metavariables>& /*cache*/, 108 : const ElementId<Dim>& element_id) const { 109 : return impl(current_mesh, element_id); 110 : } 111 : } // namespace amr::Criteria