Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Defines class Poisson::FirstOrderSystem
       6              : 
       7              : #pragma once
       8              : 
       9              : #include <cstddef>
      10              : 
      11              : #include "DataStructures/DataBox/PrefixHelpers.hpp"
      12              : #include "DataStructures/DataBox/Prefixes.hpp"
      13              : #include "Elliptic/BoundaryConditions/BoundaryCondition.hpp"
      14              : #include "Elliptic/Protocols/FirstOrderSystem.hpp"
      15              : #include "Elliptic/Systems/Poisson/Equations.hpp"
      16              : #include "Elliptic/Systems/Poisson/Geometry.hpp"
      17              : #include "Elliptic/Systems/Poisson/Tags.hpp"
      18              : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      19              : #include "PointwiseFunctions/GeneralRelativity/TagsDeclarations.hpp"
      20              : #include "Utilities/ProtocolHelpers.hpp"
      21              : #include "Utilities/TMPL.hpp"
      22              : 
      23              : namespace Poisson {
      24              : 
      25              : /*!
      26              :  * \brief The Poisson equation formulated as a set of coupled first-order PDEs.
      27              :  *
      28              :  * \details This system formulates the Poisson equation \f$-\Delta_\gamma u(x) =
      29              :  * f(x)\f$ on a background metric \f$\gamma_{ij}\f$ as the set of coupled
      30              :  * first-order PDEs
      31              :  *
      32              :  * \f{align*}
      33              :  * -\partial_i v^i - \Gamma^i_{ij} v^j = f(x) \\
      34              :  * v^i = \gamma^{ij} \partial_j u(x)
      35              :  * \f}
      36              :  *
      37              :  * where \f$\Gamma^i_{jk}=\frac{1}{2}\gamma^{il}\left(\partial_j\gamma_{kl}
      38              :  * +\partial_k\gamma_{jl}-\partial_l\gamma_{jk}\right)\f$ are the Christoffel
      39              :  * symbols of the second kind of the background metric \f$\gamma_{ij}\f$. The
      40              :  * background metric \f$\gamma_{ij}\f$ and the Christoffel symbols derived from
      41              :  * it are assumed to be independent of the variables \f$u\f$, i.e.
      42              :  * constant throughout an iterative elliptic solve.
      43              :  *
      44              :  * The system can be formulated in terms of these fluxes and sources (see
      45              :  * `elliptic::protocols::FirstOrderSystem`):
      46              :  *
      47              :  * \f{align*}
      48              :  * F^i &= v^i = \gamma^{ij} \partial_j u \\
      49              :  * S &= -\Gamma^i_{ij} v^j \\
      50              :  * f &= f(x) \text{.}
      51              :  * \f}
      52              :  *
      53              :  * The fluxes and sources simplify significantly when the background metric is
      54              :  * flat and we employ Cartesian coordinates so \f$\gamma_{ij} = \delta_{ij}\f$
      55              :  * and \f$\Gamma^i_{jk} = 0\f$. Set the template parameter `BackgroundGeometry`
      56              :  * to `Poisson::Geometry::FlatCartesian` to specialize the system for this case.
      57              :  * Set it to `Poisson::Geometry::Curved` for the general case.
      58              :  *
      59              :  * ## Complex Poisson equation
      60              :  *
      61              :  * This system can also be used to solve the complex Poisson equation where
      62              :  * $u(x)$ and $f(x)$ are complex-valued, by setting the `DataType` template
      63              :  * parameter to `ComplexDataVector`. Note that the real and imaginary sectors of
      64              :  * the equations decouple, so they are essentially two independent Poisson
      65              :  * equations. This is useful for testing the elliptic solver with complex-valued
      66              :  * fields, and also as building blocks for other Poisson-like systems of
      67              :  * equations that have additional complex-valued source terms.
      68              :  */
      69              : template <size_t Dim, Geometry BackgroundGeometry,
      70              :           typename DataType = DataVector>
      71            1 : struct FirstOrderSystem
      72              :     : tt::ConformsTo<elliptic::protocols::FirstOrderSystem> {
      73            0 :   static constexpr size_t volume_dim = Dim;
      74              : 
      75            0 :   using primal_fields = tmpl::list<Tags::Field<DataType>>;
      76              :   // We just use the standard `Flux` prefix because the fluxes don't have
      77              :   // symmetries and we don't need to give them a particular meaning.
      78            0 :   using primal_fluxes = tmpl::list<
      79              :       ::Tags::Flux<Tags::Field<DataType>, tmpl::size_t<Dim>, Frame::Inertial>>;
      80              : 
      81            0 :   using background_fields = tmpl::conditional_t<
      82              :       BackgroundGeometry == Geometry::FlatCartesian, tmpl::list<>,
      83              :       tmpl::list<
      84              :           gr::Tags::InverseSpatialMetric<DataVector, Dim>,
      85              :           gr::Tags::SpatialChristoffelSecondKindContracted<DataVector, Dim>>>;
      86            0 :   using inv_metric_tag =
      87              :       tmpl::conditional_t<BackgroundGeometry == Geometry::FlatCartesian, void,
      88              :                           gr::Tags::InverseSpatialMetric<DataVector, Dim>>;
      89              : 
      90            0 :   using fluxes_computer = Fluxes<Dim, BackgroundGeometry, DataType>;
      91            0 :   using sources_computer =
      92              :       tmpl::conditional_t<BackgroundGeometry == Geometry::FlatCartesian, void,
      93              :                           Sources<Dim, BackgroundGeometry, DataType>>;
      94              : 
      95            0 :   using boundary_conditions_base =
      96              :       elliptic::BoundaryConditions::BoundaryCondition<Dim>;
      97            0 :   using modify_boundary_data = void;
      98              : };
      99              : }  // namespace Poisson