Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <memory>
       7              : #include <pup.h>
       8              : 
       9              : #include "Domain/BoundaryConditions/BoundaryCondition.hpp"
      10              : #include "Options/String.hpp"
      11              : #include "Utilities/Serialization/CharmPupable.hpp"
      12              : #include "Utilities/TMPL.hpp"
      13              : 
      14              : namespace domain::BoundaryConditions {
      15            0 : class MarkAsNone {
      16              :  public:
      17            0 :   MarkAsNone() = default;
      18            0 :   MarkAsNone(MarkAsNone&&) = default;
      19            0 :   MarkAsNone& operator=(MarkAsNone&&) = default;
      20            0 :   MarkAsNone(const MarkAsNone&) = default;
      21            0 :   MarkAsNone& operator=(const MarkAsNone&) = default;
      22            0 :   virtual ~MarkAsNone() = 0;
      23              : };
      24              : 
      25              : /*!
      26              :  * \brief None boundary conditions.
      27              :  *
      28              :  * This boundary condition doesn't actually do anything, and gets pretty much
      29              :  * completely ignored by everything but the domain creator internals. The domain
      30              :  * creator internals can use `None` as a way of specifying "boundary conditions"
      31              :  * without a system. It can also be used in cases like the BinaryCompactObject
      32              :  * domain where there may be no excision boundaries, and so the excision
      33              :  * boundary condition must be `None` in that case so the domain creator can be
      34              :  * sure the domain is set in a consistent state.
      35              :  *
      36              :  * To use with a specific system add:
      37              :  *
      38              :  * \code
      39              :  *  domain::BoundaryConditions::None<your::system::BoundaryConditionBase>
      40              :  * \endcode
      41              :  *
      42              :  * to the list of creatable classes.
      43              :  *
      44              :  * \warning if you want an outflow-type boundary condition, you must implement
      45              :  * one, not use `None`.
      46              :  */
      47              : template <typename SystemBoundaryConditionBaseClass>
      48            1 : struct None final : public SystemBoundaryConditionBaseClass, public MarkAsNone {
      49              :  public:
      50            0 :   using options = tmpl::list<>;
      51            0 :   static constexpr Options::String help{
      52              :       "None boundary condition. Used only during domain creation to ensure a "
      53              :       "consistent state to the domain."};
      54            0 :   static std::string name() { return "None"; }
      55              : 
      56            0 :   None() = default;
      57            0 :   None(None&&) = default;
      58            0 :   None& operator=(None&&) = default;
      59            0 :   None(const None&) = default;
      60            0 :   None& operator=(const None&) = default;
      61            0 :   ~None() override = default;
      62              : 
      63            0 :   explicit None(CkMigrateMessage* msg);
      64              : 
      65            0 :   WRAPPED_PUPable_decl_base_template(
      66              :       domain::BoundaryConditions::BoundaryCondition, None);
      67              : 
      68            0 :   auto get_clone() const -> std::unique_ptr<
      69              :       domain::BoundaryConditions::BoundaryCondition> override;
      70              : 
      71            0 :   void pup(PUP::er& p) override;
      72              : };
      73              : 
      74              : template <typename SystemBoundaryConditionBaseClass>
      75              : None<SystemBoundaryConditionBaseClass>::None(CkMigrateMessage* const msg)
      76              :     : SystemBoundaryConditionBaseClass(msg) {}
      77              : 
      78              : template <typename SystemBoundaryConditionBaseClass>
      79              : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
      80              : None<SystemBoundaryConditionBaseClass>::get_clone() const {
      81              :   return std::make_unique<None>(*this);
      82              : }
      83              : 
      84              : template <typename SystemBoundaryConditionBaseClass>
      85              : void None<SystemBoundaryConditionBaseClass>::pup(PUP::er& p) {
      86              :   BoundaryCondition::pup(p);
      87              : }
      88              : 
      89              : /// \cond
      90              : template <typename SystemBoundaryConditionBaseClass>
      91              : // NOLINTNEXTLINE
      92              : PUP::able::PUP_ID None<SystemBoundaryConditionBaseClass>::my_PUP_ID = 0;
      93              : /// \endcond
      94              : 
      95              : /// Check if a boundary condition inherits from `MarkAsNone`, which
      96              : /// constitutes as it being marked as a none boundary condition.
      97            1 : bool is_none(const std::unique_ptr<BoundaryCondition>& boundary_condition);
      98              : }  // namespace domain::BoundaryConditions