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 <type_traits>
       8             : 
       9             : #include "DataStructures/DataBox/PrefixHelpers.hpp"
      10             : #include "DataStructures/DataBox/SubitemTag.hpp"
      11             : #include "DataStructures/DataBox/Tag.hpp"
      12             : #include "DataStructures/Variables.hpp"
      13             : #include "Domain/Structure/DirectionMap.hpp"
      14             : #include "Utilities/Gsl.hpp"
      15             : #include "Utilities/Requires.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : 
      18             : namespace domain {
      19             : namespace Tags {
      20             : 
      21             : /// The `Tag` on element faces
      22             : template <size_t Dim, typename Tag>
      23           1 : struct Faces : db::PrefixTag, db::SimpleTag {
      24           0 :   static constexpr size_t volume_dim = Dim;
      25           0 :   using tag = Tag;
      26           0 :   using type = DirectionMap<Dim, typename Tag::type>;
      27             : };
      28             : 
      29             : }  // namespace Tags
      30             : 
      31             : /// Wrap `Tag` in `domain::Tags::Faces`, unless `Tag` is in the `VolumeTags`
      32             : /// list
      33             : template <typename Dim, typename Tag, typename VolumeTags = tmpl::list<>>
      34           1 : struct make_faces_tag {
      35           0 :   using type = tmpl::conditional_t<tmpl::list_contains_v<VolumeTags, Tag>, Tag,
      36             :                                    domain::Tags::Faces<Dim::value, Tag>>;
      37             : };
      38             : 
      39             : /// Wrap all tags in `TagsList` in `domain::Tags::Faces`, except those in the
      40             : /// `VolumeTags` list
      41             : template <size_t Dim, typename TagsList, typename VolumeTags = tmpl::list<>>
      42           1 : using make_faces_tags =
      43             :     tmpl::transform<TagsList, make_faces_tag<tmpl::pin<tmpl::size_t<Dim>>,
      44             :                                              tmpl::_1, tmpl::pin<VolumeTags>>>;
      45             : 
      46             : }  // namespace domain
      47             : 
      48             : namespace db {
      49             : template <typename FacesTag>
      50             : struct Subitems<
      51             :     FacesTag,
      52             :     Requires<std::is_base_of_v<domain::Tags::Faces<FacesTag::volume_dim,
      53             :                                                    typename FacesTag::tag>,
      54             :                                FacesTag> and
      55             :              tt::is_a_v<Variables, typename FacesTag::tag::type>>> {
      56             :   static constexpr size_t Dim = FacesTag::volume_dim;
      57             :   using VariablesTag = typename FacesTag::tag;
      58             :   using VectorType = typename VariablesTag::type::vector_type;
      59             : 
      60             :   template <typename LocalTag>
      61             :   using faces_tag = domain::Tags::Faces<Dim, LocalTag>;
      62             : 
      63             :   using tag = faces_tag<VariablesTag>;
      64             :   using type =
      65             :       db::wrap_tags_in<faces_tag, typename VariablesTag::type::tags_list>;
      66             : 
      67             :   template <typename Subtag>
      68             :   static void create_item(
      69             :       const gsl::not_null<typename tag::type*> parent_value,
      70             :       const gsl::not_null<typename Subtag::type*> sub_value) {
      71             :     sub_value->clear();
      72             :     for (auto& [direction, all_parent_vars] : *parent_value) {
      73             :       auto& parent_var = get<typename Subtag::tag>(all_parent_vars);
      74             :       auto& sub_var = (*sub_value)[direction];
      75             :       for (auto vars_it = parent_var.begin(), sub_var_it = sub_var.begin();
      76             :            vars_it != parent_var.end(); ++vars_it, ++sub_var_it) {
      77             :         sub_var_it->set_data_ref(&*vars_it);
      78             :       }
      79             :     }
      80             :   }
      81             : 
      82             :   // The `return_type` can be anything for Subitems because the DataBox figures
      83             :   // out the correct return type, we just use the `return_type` type alias to
      84             :   // signal to the DataBox we want mutating behavior.
      85             :   using return_type = NoSuchType;
      86             : 
      87             :   template <typename Subtag>
      88             :   static void create_compute_item(
      89             :       const gsl::not_null<typename Subtag::type*> sub_value,
      90             :       const typename tag::type& parent_value) {
      91             :     for (const auto& [direction, all_parent_vars] : parent_value) {
      92             :       const auto& parent_var = get<typename Subtag::tag>(all_parent_vars);
      93             :       auto& sub_var = (*sub_value)[direction];
      94             :       auto sub_var_it = sub_var.begin();
      95             :       for (auto vars_it = parent_var.begin(); vars_it != parent_var.end();
      96             :            ++vars_it, ++sub_var_it) {
      97             :         // clang-tidy: do not use const_cast
      98             :         // The DataBox will only give out a const reference to the
      99             :         // result of a compute item.  Here, that is a reference to a
     100             :         // const map to Tensors of DataVectors.  There is no (publicly
     101             :         // visible) indirection there, so having the map const will
     102             :         // allow only allow const access to the contained DataVectors,
     103             :         // so no modification through the pointer cast here is
     104             :         // possible.
     105             :         sub_var_it->set_data_ref(const_cast<VectorType*>(&*vars_it));  // NOLINT
     106             :       }
     107             :     }
     108             :   }
     109             : };
     110             : }  // namespace db
     111             : 
     112             : namespace Tags {
     113             : /// \brief Specialization of a subitem tag for a compute tag that inherits off
     114             : /// `domain::Tags::Faces`.
     115             : ///
     116             : /// This tag holds a map from faces to _one_ of the subitems, typically one
     117             : /// tensor in a Variables. The `FacesSubitemTag` represents the particular
     118             : /// tensor on faces, and the `FacesComputeTag` represents the full Variables on
     119             : /// faces.
     120             : template <typename FacesSubitemTag, typename FacesComputeTag>
     121             : struct Subitem<FacesSubitemTag, FacesComputeTag,
     122             :                Requires<std::is_base_of_v<
     123             :                    domain::Tags::Faces<FacesComputeTag::volume_dim,
     124             :                                        typename FacesComputeTag::tag>,
     125             :                    FacesComputeTag>>> : db::ComputeTag,
     126             :                                         FacesSubitemTag {
     127             :   using base = FacesSubitemTag;
     128             :   using return_type = typename base::type;
     129             :   using parent_tag = FacesComputeTag;
     130             :   using argument_tags = tmpl::list<typename parent_tag::base>;
     131             :   static void function(const gsl::not_null<return_type*> subitems,
     132             :                        const typename parent_tag::type& parent_value) {
     133             :     ::db::Subitems<parent_tag>::template create_compute_item<base>(
     134             :         subitems, parent_value);
     135             :   }
     136             : };
     137             : }  // namespace Tags