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 <pup.h>
       8              : #include <string>
       9              : #include <vector>
      10              : 
      11              : #include "DataStructures/Tensor/TypeAliases.hpp"
      12              : #include "Elliptic/BoundaryConditions/BoundaryCondition.hpp"
      13              : #include "Elliptic/BoundaryConditions/BoundaryConditionType.hpp"
      14              : #include "Options/String.hpp"
      15              : #include "Utilities/Gsl.hpp"
      16              : #include "Utilities/Serialization/CharmPupable.hpp"
      17              : #include "Utilities/TMPL.hpp"
      18              : 
      19              : /// \cond
      20              : class DataVector;
      21              : /// \endcond
      22              : 
      23              : namespace Elasticity::BoundaryConditions {
      24              : namespace detail {
      25              : 
      26              : template <elliptic::BoundaryConditionType BoundaryConditionType>
      27              : struct ZeroHelpString;
      28              : template <>
      29              : struct ZeroHelpString<elliptic::BoundaryConditionType::Dirichlet> {
      30              :   static constexpr Options::String help =
      31              :       "Zero Dirichlet boundary conditions imposed on the displacement vector, "
      32              :       "i.e. the elastic material is held fixed at this boundary.";
      33              : };
      34              : template <>
      35              : struct ZeroHelpString<elliptic::BoundaryConditionType::Neumann> {
      36              :   static constexpr Options::String help =
      37              :       "Zero Neumann boundary conditions imposed on the stress tensor "
      38              :       "perpendicular to the surface, i.e. the elastic material is free to "
      39              :       "deform at this boundary.";
      40              : };
      41              : 
      42              : }  // namespace detail
      43              : 
      44              : /// Impose zero Dirichlet ("fixed") or Neumann ("free") boundary conditions.
      45              : template <size_t Dim, elliptic::BoundaryConditionType BoundaryConditionType>
      46            1 : class Zero : public elliptic::BoundaryConditions::BoundaryCondition<Dim> {
      47              :  private:
      48            0 :   using Base = elliptic::BoundaryConditions::BoundaryCondition<Dim>;
      49              : 
      50              :   static_assert(BoundaryConditionType ==
      51              :                         elliptic::BoundaryConditionType::Dirichlet or
      52              :                     BoundaryConditionType ==
      53              :                         elliptic::BoundaryConditionType::Neumann,
      54              :                 "Unexpected boundary condition type. Supported are Dirichlet "
      55              :                 "and Neumann.");
      56              : 
      57              :  public:
      58            0 :   static std::string name();
      59            0 :   using options = tmpl::list<>;
      60            0 :   static constexpr Options::String help =
      61              :       detail::ZeroHelpString<BoundaryConditionType>::help;
      62              : 
      63            0 :   Zero() = default;
      64            0 :   Zero(const Zero&) = default;
      65            0 :   Zero& operator=(const Zero&) = default;
      66            0 :   Zero(Zero&&) = default;
      67            0 :   Zero& operator=(Zero&&) = default;
      68            0 :   ~Zero() = default;
      69              : 
      70              :   /// \cond
      71              :   explicit Zero(CkMigrateMessage* m) : Base(m) {}
      72              :   using PUP::able::register_constructor;
      73              :   WRAPPED_PUPable_decl_template(Zero);
      74              :   /// \endcond
      75              : 
      76            0 :   std::unique_ptr<domain::BoundaryConditions::BoundaryCondition> get_clone()
      77              :       const override {
      78              :     return std::make_unique<Zero>(*this);
      79              :   }
      80              : 
      81            0 :   std::vector<elliptic::BoundaryConditionType> boundary_condition_types()
      82              :       const override {
      83              :     return {Dim, BoundaryConditionType};
      84              :   }
      85              : 
      86            0 :   using argument_tags = tmpl::list<>;
      87            0 :   using volume_tags = tmpl::list<>;
      88              : 
      89            0 :   static void apply(gsl::not_null<tnsr::I<DataVector, Dim>*> displacement,
      90              :                     gsl::not_null<tnsr::I<DataVector, Dim>*> n_dot_minus_stress,
      91              :                     const tnsr::iJ<DataVector, Dim>& deriv_displacement);
      92              : 
      93            0 :   using argument_tags_linearized = tmpl::list<>;
      94            0 :   using volume_tags_linearized = tmpl::list<>;
      95              : 
      96            0 :   static void apply_linearized(
      97              :       gsl::not_null<tnsr::I<DataVector, Dim>*> displacement,
      98              :       gsl::not_null<tnsr::I<DataVector, Dim>*> n_dot_minus_stress,
      99              :       const tnsr::iJ<DataVector, Dim>& deriv_displacement);
     100              : };
     101              : 
     102              : template <size_t Dim, elliptic::BoundaryConditionType BoundaryConditionType>
     103            0 : bool operator==(const Zero<Dim, BoundaryConditionType>& /*lhs*/,
     104              :                 const Zero<Dim, BoundaryConditionType>& /*rhs*/) {
     105              :   return true;
     106              : }
     107              : 
     108              : template <size_t Dim, elliptic::BoundaryConditionType BoundaryConditionType>
     109            0 : bool operator!=(const Zero<Dim, BoundaryConditionType>& lhs,
     110              :                 const Zero<Dim, BoundaryConditionType>& rhs) {
     111              :   return not(lhs == rhs);
     112              : }
     113              : 
     114              : /// \cond
     115              : template <size_t Dim, elliptic::BoundaryConditionType BoundaryConditionType>
     116              : PUP::able::PUP_ID Zero<Dim, BoundaryConditionType>::my_PUP_ID = 0;  // NOLINT
     117              : /// \endcond
     118              : 
     119              : }  // namespace Elasticity::BoundaryConditions