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 <optional>
       9             : #include <pup.h>
      10             : #include <string>
      11             : #include <unordered_map>
      12             : #include <unordered_set>
      13             : #include <vector>
      14             : 
      15             : #include "DataStructures/Tensor/Tensor.hpp"
      16             : #include "DataStructures/Tensor/TypeAliases.hpp"
      17             : #include "DataStructures/Variables.hpp"
      18             : #include "NumericalAlgorithms/LinearOperators/Filters/Filter.hpp"
      19             : #include "Options/Auto.hpp"
      20             : #include "Options/Context.hpp"
      21             : #include "Options/String.hpp"
      22             : #include "Utilities/Gsl.hpp"
      23             : 
      24             : /// \cond
      25             : template <size_t Dim>
      26             : class Mesh;
      27             : /// \endcond
      28             : 
      29             : namespace Filters {
      30             : /*!
      31             :  * \ingroup DiscontinuousGalerkinGroup
      32             :  * \brief A no-op filter that never modifies any data and accepts any mesh
      33             :  * basis or quadrature.
      34             :  *
      35             :  * See `Filters::Filter` for the general interface description.
      36             :  */
      37             : template <size_t Dim, typename TagList>
      38           1 : class None : public Filter<Dim, TagList> {
      39             :  public:
      40             :   /// \brief Which blocks the filter should be applied to.
      41           1 :   struct BlocksToFilter {
      42           0 :     using type =
      43             :         Options::Auto<std::vector<std::string>, Options::AutoLabel::All>;
      44           0 :     static constexpr Options::String help = {
      45             :         "List of blocks or block groups to restrict this no-op filter to. "
      46             :         "You can also specify 'All' to apply to every block in the domain. "
      47             :         "Since the filter never modifies data, this option only affects which "
      48             :         "blocks appear in the filter's block list."};
      49             :   };
      50             : 
      51           0 :   using options = tmpl::list<BlocksToFilter>;
      52             : 
      53           0 :   static constexpr Options::String help = {
      54             :       "A no-op filter that never modifies any data and is valid for any basis "
      55             :       "or quadrature."};
      56             : 
      57           0 :   None() = default;
      58             : 
      59           0 :   explicit None(const std::optional<std::vector<std::string>>& blocks_to_filter,
      60             :                 const Options::Context& context = {});
      61             : 
      62           0 :   WRAPPED_PUPable_decl_base_template(  // NOLINT
      63             :       SINGLE_ARG(Filter<Dim, TagList>), None);
      64           0 :   explicit None(CkMigrateMessage* msg) : Filter<Dim, TagList>(msg) {}
      65             : 
      66             :   // NOLINTNEXTLINE(google-runtime-references)
      67           0 :   void pup(PUP::er& p) override;
      68             : 
      69           1 :   std::unique_ptr<Filter<Dim, TagList>> get_clone() const override {
      70             :     return std::make_unique<None>(*this);
      71             :   }
      72             : 
      73           1 :   bool apply_volume_filter_on_substep() const override { return false; }
      74           1 :   bool apply_volume_filter_on_this_step(size_t /*step_number*/) const override {
      75             :     return false;
      76             :   }
      77             : 
      78           1 :   bool apply_boundary_filter_on_substep() const override { return false; }
      79           1 :   bool apply_boundary_filter_on_this_step(
      80             :       size_t /*step_number*/) const override {
      81             :     return false;
      82             :   }
      83             : 
      84           1 :   bool need_jacobians() const override { return false; }
      85             : 
      86           1 :   bool supports_mesh(const Mesh<Dim>& /*mesh*/) const override { return true; }
      87             : 
      88           1 :   std::string name() const override { return "None"; }
      89             : 
      90           1 :   const std::optional<std::vector<size_t>>& blocks_to_filter() const override;
      91             : 
      92           1 :   void set_blocks_to_filter(
      93             :       const std::vector<std::string>& all_block_names,
      94             :       const std::unordered_map<std::string, std::unordered_set<std::string>>&
      95             :           block_groups) override;
      96             : 
      97           1 :   void apply_in_volume(
      98             :       gsl::not_null<Variables<TagList>*> vars, const Mesh<Dim>& mesh,
      99             :       const std::optional<
     100             :           InverseJacobian<DataVector, Dim, Frame::Grid, Frame::Inertial>>&
     101             :           inv_jac_grid_to_inertial,
     102             :       const std::optional<
     103             :           Jacobian<DataVector, Dim, Frame::Grid, Frame::Inertial>>&
     104             :           jac_grid_to_inertial) const override;
     105             : 
     106           1 :   void apply_on_boundary(
     107             :       gsl::not_null<Variables<TagList>*> vars, const Mesh<Dim - 1>& mesh,
     108             :       const std::optional<
     109             :           InverseJacobian<DataVector, Dim, Frame::Grid, Frame::Inertial>>&
     110             :           inv_jac_grid_to_inertial,
     111             :       const std::optional<
     112             :           Jacobian<DataVector, Dim, Frame::Grid, Frame::Inertial>>&
     113             :           jac_grid_to_inertial) const override;
     114             : 
     115           1 :   bool is_equal(const Filter<Dim, TagList>& other) const override;
     116             : 
     117             :  private:
     118             :   template <size_t LocalDim, typename LocalTagList>
     119             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     120           0 :   friend bool operator==(const None<LocalDim, LocalTagList>& lhs,
     121             :                          const None<LocalDim, LocalTagList>& rhs);
     122             : 
     123           0 :   std::optional<std::vector<std::string>> blocks_and_groups_to_filter_{};
     124           0 :   std::optional<std::vector<size_t>> blocks_to_filter_{};
     125             : };
     126             : 
     127             : template <size_t Dim, typename TagList>
     128           0 : bool operator==(const None<Dim, TagList>& lhs, const None<Dim, TagList>& rhs);
     129             : 
     130             : template <size_t Dim, typename TagList>
     131           0 : bool operator!=(const None<Dim, TagList>& lhs, const None<Dim, TagList>& rhs);
     132             : }  // namespace Filters