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 <memory>
       8             : #include <vector>
       9             : 
      10             : #include "Domain/Tags.hpp"
      11             : #include "NumericalAlgorithms/LinearOperators/Filters/Tag.hpp"
      12             : #include "Utilities/TMPL.hpp"
      13             : 
      14             : /// \cond
      15             : template <size_t Dim>
      16             : class Element;
      17             : template <size_t Dim>
      18             : class Mesh;
      19             : namespace gsl {
      20             : template <typename T>
      21             : class not_null;
      22             : }  // namespace gsl
      23             : namespace Filters {
      24             : template <size_t Dim, typename TagList>
      25             : class Filter;
      26             : }  // namespace Filters
      27             : /// \endcond
      28             : 
      29             : namespace evolution::dg::Initialization {
      30             : /*!
      31             :  * \brief Initialization mutator that selects the spectral filter for each
      32             :  * element and stores it as `Filters::Tags::SpectralFilter` in the DataBox.
      33             :  *
      34             :  * \details Used with `Initialization::Actions::InitializeItems`. For each
      35             :  * element, `apply` scans the GlobalCache list
      36             :  * `Filters::Tags::SpectralFilters<Dim, TagList>` and selects the unique filter
      37             :  * `f` for which `f->supports_mesh(mesh)` returns `true` AND either
      38             :  * `f->blocks_to_filter()` is `std::nullopt` (the filter applies to every
      39             :  * block) or the element's block id is contained in
      40             :  * `f->blocks_to_filter().value()`. The selected filter is deep-copied via
      41             :  * `Filters::Filter::get_clone` and stored in
      42             :  * `Filters::Tags::SpectralFilter<Dim, TagList>`.
      43             :  *
      44             :  * Errors if more than one filter in the list matches an element, or if no
      45             :  * filter matches (specify a `None` filter to disable filtering in an element).
      46             :  *
      47             :  * Uses:
      48             :  * - GlobalCache:
      49             :  *   - `Filters::Tags::SpectralFilters<Dim, TagList>`
      50             :  * - DataBox:
      51             :  *   - `domain::Tags::Element<Dim>`
      52             :  *   - `domain::Tags::Mesh<Dim>`
      53             :  *
      54             :  * DataBox changes:
      55             :  * - Adds:
      56             :  *   - `Filters::Tags::SpectralFilter<Dim, TagList>`
      57             :  * - Removes: nothing
      58             :  * - Modifies: nothing
      59             :  *
      60             :  * \tparam Dim Spatial dimension of the element mesh.
      61             :  * \tparam TagList `tmpl::list` of tensor tags in the `Variables` to filter.
      62             :  */
      63             : template <size_t Dim, typename TagList>
      64           1 : struct SpectralFilters {
      65           0 :   using const_global_cache_tags =
      66             :       tmpl::list<Filters::Tags::SpectralFilters<Dim, TagList>>;
      67           0 :   using mutable_global_cache_tags = tmpl::list<>;
      68           0 :   using simple_tags_from_options = tmpl::list<>;
      69           0 :   using simple_tags = tmpl::list<Filters::Tags::SpectralFilter<Dim, TagList>>;
      70           0 :   using compute_tags = tmpl::list<>;
      71             : 
      72           0 :   using return_tags = simple_tags;
      73           0 :   using argument_tags =
      74             :       tmpl::list<Filters::Tags::SpectralFilters<Dim, TagList>,
      75             :                  domain::Tags::Element<Dim>, domain::Tags::Mesh<Dim>>;
      76             : 
      77             :   /// Sets `spectral_filter` to a clone of the unique filter from
      78             :   /// `spectral_filters` that supports `mesh` and applies to `element`'s block.
      79           1 :   static void apply(
      80             :       gsl::not_null<std::unique_ptr<Filters::Filter<Dim, TagList>>*>
      81             :           spectral_filter,
      82             :       const std::vector<std::unique_ptr<Filters::Filter<Dim, TagList>>>&
      83             :           spectral_filters,
      84             :       const Element<Dim>& element, const Mesh<Dim>& mesh);
      85             : };
      86             : }  // namespace evolution::dg::Initialization