Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines class template Block.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <array>
      10             : #include <cstddef>
      11             : #include <iosfwd>
      12             : #include <memory>
      13             : #include <string>
      14             : #include <unordered_set>
      15             : 
      16             : #include "Domain/CoordinateMaps/CoordinateMap.hpp"
      17             : #include "Domain/Structure/BlockNeighbors.hpp"
      18             : #include "Domain/Structure/Direction.hpp"
      19             : #include "Domain/Structure/DirectionMap.hpp"
      20             : #include "Domain/Structure/Topology.hpp"
      21             : #include "Utilities/MakeArray.hpp"
      22             : 
      23             : /// \cond
      24             : namespace Frame {
      25             : struct BlockLogical;
      26             : struct Inertial;
      27             : }  // namespace Frame
      28             : namespace PUP {
      29             : class er;
      30             : }  // namespace PUP
      31             : /// \endcond
      32             : 
      33             : /// \ingroup ComputationalDomainGroup
      34             : /// A Block<VolumeDim> is a region of a VolumeDim-dimensional computational
      35             : /// domain that defines the root node of a tree which is used to construct the
      36             : /// Elements that cover a region of the computational domain.
      37             : ///
      38             : /// Each codimension 1 boundary of a Block<VolumeDim> is either an external
      39             : /// boundary or identical to a boundary of one or more Blocks.
      40             : ///
      41             : /// A Block has logical coordinates that depend upon the topology in each
      42             : /// dimension.  The global coordinates are obtained from the logical
      43             : /// coordinates from the Coordinatemap:  CoordinateMap::operator() takes
      44             : /// Points in the BlockLogical Frame (i.e., block logical coordinates) and
      45             : /// returns Points in the Inertial Frame (i.e., the global coordinate frame in
      46             : /// which the problem to be solved is set up).
      47             : template <size_t VolumeDim>
      48           1 : class Block {
      49             :  public:
      50             :   /// \param stationary_map the CoordinateMap.
      51             :   /// \param id a unique ID.
      52             :   /// \param neighbors info about the Blocks that share a codimension 1
      53             :   /// boundary with this Block.
      54             :   /// \param name Human-readable name for the block
      55             :   /// \param topologies domain::Topology in each dimension (default value is
      56             :   /// domain::Topology::I1)
      57           1 :   Block(std::unique_ptr<domain::CoordinateMapBase<
      58             :             Frame::BlockLogical, Frame::Inertial, VolumeDim>>&& stationary_map,
      59             :         size_t id, DirectionMap<VolumeDim, BlockNeighbors<VolumeDim>> neighbors,
      60             :         std::string name = "",
      61             :         std::array<domain::Topology, VolumeDim> topologies =
      62             :             domain::topologies::hypercube<VolumeDim>);
      63             : 
      64           0 :   Block() = default;
      65           0 :   ~Block() = default;
      66           0 :   Block(const Block&) = delete;
      67           0 :   Block(Block&&) = default;
      68           0 :   Block& operator=(const Block&) = delete;
      69           0 :   Block& operator=(Block&&) = default;
      70             : 
      71             :   /// \brief The map used when the coordinate map is time-independent.
      72             :   ///
      73             :   /// \see is_time_dependent()
      74             :   const domain::CoordinateMapBase<Frame::BlockLogical, Frame::Inertial,
      75             :                                   VolumeDim>&
      76           1 :   stationary_map() const;
      77             : 
      78             :   /// \brief The map going from the block logical frame to the last time
      79             :   /// independent frame. Only used when the coordinate map is time-dependent.
      80             :   ///
      81             :   /// \see is_time_dependent() moving_mesh_grid_to_inertial_map()
      82             :   const domain::CoordinateMapBase<Frame::BlockLogical, Frame::Grid, VolumeDim>&
      83           1 :   moving_mesh_logical_to_grid_map() const;
      84             : 
      85             :   /// \brief The map going from the last time independent frame to the frame in
      86             :   /// which the equations are solved. Only used when the coordinate map is
      87             :   /// time-dependent.
      88             :   ///
      89             :   /// \see is_time_dependent() moving_mesh_logical_to_grid_map()
      90             :   const domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, VolumeDim>&
      91           1 :   moving_mesh_grid_to_inertial_map() const;
      92             : 
      93             :   /// \brief The map going from the last time independent frame to the
      94             :   /// distorted frame. Only used when the coordinate map is
      95             :   /// time-dependent. See \ref domain_concepts to see how the distorted
      96             :   /// frame is defined.
      97             :   ///
      98             :   /// \see is_time_dependent() moving_mesh_distorted_to_grid_map()
      99             :   const domain::CoordinateMapBase<Frame::Grid, Frame::Distorted, VolumeDim>&
     100           1 :   moving_mesh_grid_to_distorted_map() const;
     101             : 
     102             :   /// \brief The map going from the distorted frame to the frame in
     103             :   /// which the equations are solved. Only used when the coordinate map is
     104             :   /// time-dependent. See \ref domain_concepts to see how the distorted
     105             :   /// frame is defined.
     106             :   ///
     107             :   /// \see is_time_dependent() moving_mesh_grid_to_distorted_map()
     108             :   const domain::CoordinateMapBase<Frame::Distorted, Frame::Inertial, VolumeDim>&
     109           1 :   moving_mesh_distorted_to_inertial_map() const;
     110             : 
     111             :   /// \brief Returns `true` if the block has time-dependent maps.
     112           1 :   bool is_time_dependent() const { return stationary_map_ == nullptr; }
     113             : 
     114             :   /// \brief Returns `true` if the block has a distorted frame.
     115             :   ///
     116             :   /// If a block has a distorted frame, then
     117             :   ///   - moving_mesh_grid_to_distorted_map() is non-null
     118             :   ///   - moving_mesh_distorted_to_inertial_map() is non-null
     119             :   ///   - moving_mesh_grid_to_inertial_map() is non-null
     120             :   /// Note in particular the last point above:  If the block is time-dependent,
     121             :   /// then the block must have a grid_to_inertial map independent of whether
     122             :   /// it has a distorted frame.  This allows us to write more efficient maps.
     123             :   /// In particular, we often care only about the grid_to_inertial map, so we
     124             :   /// can code that map directly instead of composing
     125             :   /// grid_to_distorted + distorted_to_inertial maps at runtime.
     126             :   ///
     127             :   /// If a block does not have a distorted frame, then
     128             :   ///   - moving_mesh_grid_to_distorted_map() is null
     129             :   ///   - moving_mesh_distorted_to_inertial_map() is null
     130             :   ///   - moving_mesh_grid_to_inertial_map() is non-null
     131             :   ///   - If we ever find ourselves needing ::Frame::Distorted coordinates
     132             :   ///     in that block, we can assume that ::Frame::Distorted and ::Frame::Grid
     133             :   ///     are the same.  Usually this case will not occur.
     134           1 :   bool has_distorted_frame() const {
     135             :     return moving_mesh_grid_to_distorted_map_ != nullptr and
     136             :            moving_mesh_distorted_to_inertial_map_ != nullptr;
     137             :   }
     138             : 
     139             :   /// \brief Given a Block that has a time-independent map, injects the
     140             :   /// time-dependent map into the Block.
     141           1 :   void inject_time_dependent_map(
     142             :       std::unique_ptr<
     143             :           domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, VolumeDim>>
     144             :           moving_mesh_grid_to_inertial_map,
     145             :       std::unique_ptr<
     146             :           domain::CoordinateMapBase<Frame::Grid, Frame::Distorted, VolumeDim>>
     147             :           moving_mesh_grid_to_distorted_map = nullptr,
     148             :       std::unique_ptr<domain::CoordinateMapBase<Frame::Distorted,
     149             :                                                 Frame::Inertial, VolumeDim>>
     150             :           moving_mesh_distorted_to_inertial_map = nullptr);
     151             : 
     152             :   /// A unique identifier for the Block that is in the range
     153             :   /// [0, number_of_blocks -1] where number_of_blocks is the number
     154             :   /// of Blocks that cover the computational domain.
     155           1 :   size_t id() const { return id_; }
     156             : 
     157             :   /// Information about the neighboring Blocks.
     158           1 :   const DirectionMap<VolumeDim, BlockNeighbors<VolumeDim>>& neighbors() const {
     159             :     return neighbors_;
     160             :   }
     161             : 
     162             :   /// The directions of the faces of the Block that are external boundaries.
     163           1 :   const std::unordered_set<Direction<VolumeDim>>& external_boundaries() const {
     164             :     return external_boundaries_;
     165             :   }
     166             : 
     167           0 :   const std::string& name() const { return name_; }
     168             : 
     169             :   /// The topology in each dimensio of this Block
     170           1 :   const std::array<domain::Topology, VolumeDim>& topologies() const {
     171             :     return topologies_;
     172             :   }
     173             : 
     174             :   /// Serialization for Charm++
     175             :   // NOLINTNEXTLINE(google-runtime-references)
     176           1 :   void pup(PUP::er& p);
     177             : 
     178             :  private:
     179             :   template <size_t LocalVolumeDim>
     180             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     181           0 :   friend bool operator==(const Block<LocalVolumeDim>& lhs,
     182             :                          const Block<LocalVolumeDim>& rhs);
     183             : 
     184             :   std::unique_ptr<domain::CoordinateMapBase<Frame::BlockLogical,
     185             :                                             Frame::Inertial, VolumeDim>>
     186           0 :       stationary_map_{nullptr};
     187             :   std::unique_ptr<
     188             :       domain::CoordinateMapBase<Frame::BlockLogical, Frame::Grid, VolumeDim>>
     189           0 :       moving_mesh_logical_to_grid_map_{nullptr};
     190             :   std::unique_ptr<
     191             :       domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, VolumeDim>>
     192           0 :       moving_mesh_grid_to_inertial_map_{nullptr};
     193             :   std::unique_ptr<
     194             :       domain::CoordinateMapBase<Frame::Grid, Frame::Distorted, VolumeDim>>
     195           0 :       moving_mesh_grid_to_distorted_map_{nullptr};
     196             :   std::unique_ptr<
     197             :       domain::CoordinateMapBase<Frame::Distorted, Frame::Inertial, VolumeDim>>
     198           0 :       moving_mesh_distorted_to_inertial_map_{nullptr};
     199             : 
     200           0 :   size_t id_{0};
     201           0 :   DirectionMap<VolumeDim, BlockNeighbors<VolumeDim>> neighbors_;
     202           0 :   std::unordered_set<Direction<VolumeDim>> external_boundaries_;
     203           0 :   std::string name_;
     204           0 :   std::array<domain::Topology, VolumeDim> topologies_;
     205             : };
     206             : 
     207             : template <size_t VolumeDim>
     208           0 : std::ostream& operator<<(std::ostream& os, const Block<VolumeDim>& block);
     209             : 
     210             : template <size_t VolumeDim>
     211           0 : bool operator!=(const Block<VolumeDim>& lhs, const Block<VolumeDim>& rhs);