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 <vector> 9 : 10 : #include "DataStructures/DataBox/DataBox.hpp" 11 : #include "Domain/BoundaryConditions/BoundaryCondition.hpp" 12 : #include "Elliptic/BoundaryConditions/BoundaryConditionType.hpp" 13 : #include "Utilities/Serialization/CharmPupable.hpp" 14 : #include "Utilities/TMPL.hpp" 15 : 16 : namespace elliptic { 17 : /// Boundary conditions for elliptic systems 18 : namespace BoundaryConditions { 19 : 20 : /*! 21 : * \brief Base class for boundary conditions for elliptic systems 22 : * 23 : * Boundary conditions for elliptic systems derive from this abstract base 24 : * class. This allows boundary conditions to be factory-created from input-file 25 : * options. Specific systems may implement further abstract base classes that 26 : * derive from this class and add additional requirements. 27 : * 28 : * Each derived class represents one kind of boundary conditions. For example, 29 : * one derived class might implement homogeneous (zero) Dirichlet or Neumann 30 : * boundary conditions, another might implement Dirichlet fields procured from 31 : * an analytic solution, and yet another might set the boundary fields as a 32 : * function of the dynamic variables on the domain boundary (e.g. Robin-type 33 : * boundary conditions). 34 : * 35 : * Note that almost all boundary conditions are actually nonlinear because even 36 : * those that depend only linearly on the dynamic fields typically contribute 37 : * non-zero field values. For example, a standard Dirichlet boundary condition 38 : * \f$u(x=0)=u_0\f$ is nonlinear for any \f$u_0\neq 0\f$. Boundary conditions 39 : * for linear systems may have exactly this nonlinearity (a constant non-zero 40 : * contribution) but must depend at most linearly on the dynamic fields. 41 : * Boundary conditions for nonlinear systems may have any nonlinearity. Either 42 : * must implement their linearization as a separate function (see below). For 43 : * linear systems the nonlinear (constant) contribution is typically added to 44 : * the fixed-source part of the discretized equations and the linearized 45 : * boundary conditions are being employed throughout the solve so the 46 : * discretized operator remains linear. For nonlinear systems we typically solve 47 : * the linearized equations repeatedly for a correction quantity, so we apply 48 : * the linearized boundary conditions when solving for the correction quantity 49 : * and apply the nonlinear boundary conditions when dealing with the nonlinear 50 : * fields that are being corrected (see e.g. 51 : * `NonlinearSolver::newton_raphson::NewtonRaphson`). 52 : * 53 : * Derived classes are expected to implement the following compile-time 54 : * interface: 55 : * 56 : * - They are option-creatable. 57 : * - They have type aliases `argument_tags`, `volume_tags`, 58 : * `argument_tags_linearized` and `volume_tags_linearized`. Those aliases list 59 : * the tags required for computing nonlinear and linearized boundary 60 : * conditions, respectively. The tags are always taken to represent quantities 61 : * on the _interior_ side of the domain boundary, i.e. whenever normal vectors 62 : * are involved they point _out_ of the computational domain. The 63 : * `volume_tags` list the subset of the `argument_tags` that are _not_ 64 : * evaluated on the boundary but taken from the element directly. 65 : * - They have `apply` and `apply_linearized` member functions that take these 66 : * arguments (in this order): 67 : * 68 : * 1. The dynamic fields as not-null pointers. 69 : * 2. The normal-dot-fluxes corresponding to the dynamic fields as not-null 70 : * pointers. These have the same types as the dynamic fields. 71 : * 3. The field derivatives as const-refs. 72 : * 4. The types held by the argument tags. 73 : * 74 : * For example, boundary conditions for a first-order Poisson system might 75 : * have an `apply` function signature that looks like this: 76 : * 77 : * \snippet Elliptic/BoundaryConditions/Test_BoundaryCondition.cpp example_poisson_fields 78 : * 79 : * The fields and normal-dot-fluxes passed to the `apply` and `apply_linearized` 80 : * functions hold data which the implementations of the functions can use, and 81 : * also serve as return variables. Modifying the fields means applying 82 : * Dirichlet-type boundary conditions and modifying the normal-dot-fluxes means 83 : * applying Neumann-type boundary conditions. Just like the arguments evaluated 84 : * on the boundary, the normal-dot-fluxes involve normal vectors that point 85 : * _out_ of the computation domain. Note that linearized boundary conditions, as 86 : * well as nonlinear boundary conditions for linear systems, may only depend 87 : * linearly on the field data, since these are the fields the linearization is 88 : * performed for. 89 : */ 90 : template <size_t Dim> 91 1 : class BoundaryCondition : public domain::BoundaryConditions::BoundaryCondition { 92 : private: 93 0 : using Base = domain::BoundaryConditions::BoundaryCondition; 94 : 95 : public: 96 0 : static constexpr size_t volume_dim = Dim; 97 : 98 0 : BoundaryCondition() = default; 99 0 : BoundaryCondition(const BoundaryCondition&) = default; 100 0 : BoundaryCondition(BoundaryCondition&&) = default; 101 0 : BoundaryCondition& operator=(const BoundaryCondition&) = default; 102 0 : BoundaryCondition& operator=(BoundaryCondition&&) = default; 103 0 : ~BoundaryCondition() override = default; 104 : 105 : /// \cond 106 : explicit BoundaryCondition(CkMigrateMessage* m) : Base(m) {} 107 : WRAPPED_PUPable_abstract(BoundaryCondition); // NOLINT 108 : /// \endcond 109 : 110 : // The type of boundary condition (Dirichlet or Neumann) for every tensor 111 : // component. For example, if the derived class imposes Neumann-type 112 : // conditions on a Scalar and Dirichlet-type conditions on a 2D vector, then 113 : // it should return `{Dirichlet, Neumann, Neumann}`. 114 : virtual std::vector<elliptic::BoundaryConditionType> 115 0 : boundary_condition_types() const = 0; 116 : }; 117 : 118 : } // namespace BoundaryConditions 119 : } // namespace elliptic