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             : /// Mark a boundary condition as being periodic.
      16             : ///
      17             : /// Periodic boundary conditions shouldn't require any implementation outside of
      18             : /// a check in the domain creator using the `is_periodic()` function to
      19             : /// determine what boundaries are periodic. Across each matching pair of
      20             : /// periodic boundary conditions, the domain creator should specify that the DG
      21             : /// elements are neighbors of each other.
      22           1 : class MarkAsPeriodic {
      23             :  public:
      24           0 :   MarkAsPeriodic() = default;
      25           0 :   MarkAsPeriodic(MarkAsPeriodic&&) = default;
      26           0 :   MarkAsPeriodic& operator=(MarkAsPeriodic&&) = default;
      27           0 :   MarkAsPeriodic(const MarkAsPeriodic&) = default;
      28           0 :   MarkAsPeriodic& operator=(const MarkAsPeriodic&) = default;
      29           0 :   virtual ~MarkAsPeriodic() = 0;
      30             : };
      31             : 
      32             : /*!
      33             :  * \brief Periodic boundary conditions.
      34             :  *
      35             :  * To use with a specific system add:
      36             :  *
      37             :  * \code
      38             :  *  domain::BoundaryConditions::Periodic<your::system::BoundaryConditionBase>
      39             :  * \endcode
      40             :  *
      41             :  * to the list of creatable classes.
      42             :  *
      43             :  * \note Not all domain creators will allow you to specify periodic boundary
      44             :  * conditions since they may not make sense.
      45             :  */
      46             : template <typename SystemBoundaryConditionBaseClass>
      47           1 : struct Periodic final : public SystemBoundaryConditionBaseClass,
      48             :                         public MarkAsPeriodic {
      49             :  public:
      50           0 :   using options = tmpl::list<>;
      51           0 :   static constexpr Options::String help{
      52             :       "Periodic boundary conditions.\n\nNote: Not all domain creators will "
      53             :       "allow you to specify periodic boundary conditions since they may not "
      54             :       "make sense."};
      55           0 :   static std::string name() { return "Periodic"; }
      56             : 
      57           0 :   Periodic() = default;
      58           0 :   Periodic(Periodic&&) = default;
      59           0 :   Periodic& operator=(Periodic&&) = default;
      60           0 :   Periodic(const Periodic&) = default;
      61           0 :   Periodic& operator=(const Periodic&) = default;
      62           0 :   ~Periodic() override = default;
      63             : 
      64           0 :   explicit Periodic(CkMigrateMessage* msg);
      65             : 
      66           0 :   WRAPPED_PUPable_decl_base_template(
      67             :       domain::BoundaryConditions::BoundaryCondition, Periodic);
      68             : 
      69           0 :   auto get_clone() const -> std::unique_ptr<
      70             :       domain::BoundaryConditions::BoundaryCondition> override;
      71             : 
      72           0 :   void pup(PUP::er& p) override;
      73             : };
      74             : 
      75             : template <typename SystemBoundaryConditionBaseClass>
      76             : Periodic<SystemBoundaryConditionBaseClass>::Periodic(
      77             :     CkMigrateMessage* const msg)
      78             :     : SystemBoundaryConditionBaseClass(msg) {}
      79             : 
      80             : template <typename SystemBoundaryConditionBaseClass>
      81             : std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
      82             : Periodic<SystemBoundaryConditionBaseClass>::get_clone() const {
      83             :   return std::make_unique<Periodic>(*this);
      84             : }
      85             : 
      86             : template <typename SystemBoundaryConditionBaseClass>
      87             : void Periodic<SystemBoundaryConditionBaseClass>::pup(PUP::er& p) {
      88             :   BoundaryCondition::pup(p);
      89             : }
      90             : 
      91             : /// \cond
      92             : template <typename SystemBoundaryConditionBaseClass>
      93             : // NOLINTNEXTLINE
      94             : PUP::able::PUP_ID Periodic<SystemBoundaryConditionBaseClass>::my_PUP_ID = 0;
      95             : /// \endcond
      96             : 
      97             : /// Check if a boundary condition inherits from `MarkAsPeriodic`, which
      98             : /// constitutes as it being marked as a periodic boundary condition.
      99           1 : bool is_periodic(const std::unique_ptr<BoundaryCondition>& boundary_condition);
     100             : }  // namespace domain::BoundaryConditions