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              : 
       8              : #include "DataStructures/DataVector.hpp"
       9              : #include "DataStructures/Tensor/Tensor.hpp"
      10              : #include "Domain/Structure/Direction.hpp"
      11              : #include "Utilities/Gsl.hpp"
      12              : 
      13              : /// @{
      14              : /*!
      15              :  * \brief Compute the Euclidean area element from the inverse jacobian.
      16              :  *
      17              :  * \details The Euclidean area element of a surface \f$\Sigma\f$ with
      18              :  * constant logical coordinate \f$\xi^i\f$ is given by:
      19              :  *
      20              :  * \f{equation}
      21              :  * J^\Sigma = J \sqrt{\delta^{jk} (J^{-1})^i_j (J^{-1})^i_k}
      22              :  * \f}
      23              :  *
      24              :  * where \f$J^i_j = \partial x^i / \xi^j\f$ is the volume Jacobian with
      25              :  * determinant \f$J\f$ and inverse \f$(J^{-1})^i_j = \partial \xi^i / \partial
      26              :  * x^j\f$. The determinant of the inverse Jacobian can be passed as an argument
      27              :  * as an overload, otherwise it will be calculated.
      28              :  *
      29              :  * \note Time dependent maps are not implemented yet but can be added on
      30              :  * demand.
      31              :  *
      32              :  * \param inverse_jacobian_face The inverse Jacobian from the ElementLogical
      33              :  * frame to the Target frame sliced to the surface.
      34              :  * \param inverse_jacobian_determinant_face The determinant of the inverse
      35              :  * Jacobian sliced onto the surface. If not availabe, there exists an overload
      36              :  * that will calculate it from the inverse Jacobian.
      37              :  * \param direction The direction of the surface in the element.
      38              :  * */
      39              : template <size_t VolumeDim, typename TargetFrame>
      40            1 : void euclidean_area_element(
      41              :     const gsl::not_null<Scalar<DataVector>*> result,
      42              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
      43              :                           TargetFrame>& inverse_jacobian_face,
      44              :     const Scalar<DataVector>& inverse_jacobian_determinant_face,
      45              :     const Direction<VolumeDim>& direction);
      46              : 
      47              : template <size_t VolumeDim, typename TargetFrame>
      48            1 : void euclidean_area_element(
      49              :     const gsl::not_null<Scalar<DataVector>*> result,
      50              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
      51              :                           TargetFrame>& inverse_jacobian_face,
      52              :     const Direction<VolumeDim>& direction);
      53              : 
      54              : template <size_t VolumeDim, typename TargetFrame>
      55            1 : Scalar<DataVector> euclidean_area_element(
      56              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
      57              :                           TargetFrame>& inverse_jacobian_face,
      58              :     const Scalar<DataVector>& inverse_jacobian_determinant_face,
      59              :     const Direction<VolumeDim>& direction);
      60              : 
      61              : template <size_t VolumeDim, typename TargetFrame>
      62            1 : Scalar<DataVector> euclidean_area_element(
      63              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
      64              :                           TargetFrame>& inverse_jacobian_face,
      65              :     const Direction<VolumeDim>& direction);
      66              : /// @}
      67              : 
      68              : /// @{
      69              : /*!
      70              :  * \brief Compute the curved area element from the inverse jacobian.
      71              :  *
      72              :  * \details The area element of a surface \f$\Sigma\f$ with
      73              :  * constant logical coordinate \f$\xi^i\f$ is given by:
      74              :  *
      75              :  * \f{equation}
      76              :  * J^\Sigma = J \sqrt{\gamma} \sqrt{\gamma^{jk} (J^{-1})^i_j (J^{-1})^i_k}
      77              :  * \f}
      78              :  *
      79              :  * where \f$\sqrt{\gamma}\f$ is the determinant of the spatial metric and
      80              :  * \f$J^i_j = \partial x^i / \xi^j\f$ is the volume Jacobian with determinant
      81              :  * \f$J\f$ and inverse \f$(J^{-1})^i_j = \partial \xi^i / \partial x^j\f$. Note
      82              :  * that the square root in the expression above is the magnitude of the
      83              :  * unnormalized face normal, where \f$\gamma^{jk}\f$ is the inverse spatial
      84              :  * metric. The determinant of the inverse Jacobian can be passed as an argument
      85              :  * as an overload, otherwise it will be calculated.
      86              :  *
      87              :  * \param inverse_jacobian_face The inverse Jacobian from the ElementLogical
      88              :  * frame to the Target frame sliced to the surface.
      89              :  * \param inverse_jacobian_determinant_face The determinant of the inverse
      90              :  * Jacobian sliced onto the surface. If not availabe, there exists an overload
      91              :  * that will calculate it from the inverse Jacobian.
      92              :  * \param direction The direction of the surface in the element.
      93              :  * \param inverse_spatial_metric The inverse spatial metric sliced to the
      94              :  * surface.
      95              :  * \param sqrt_det_spatial_metric The square root of the determinant of the
      96              :  * spatial metric, see \ref gr::Tags::SqrtDetSpatialMetric.
      97              :  */
      98              : template <size_t VolumeDim, typename TargetFrame>
      99            1 : void area_element(
     100              :     const gsl::not_null<Scalar<DataVector>*> result,
     101              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
     102              :                           TargetFrame>& inverse_jacobian_face,
     103              :     const Scalar<DataVector>& inverse_jacobian_determinant_face,
     104              :     const Direction<VolumeDim>& direction,
     105              :     const tnsr::II<DataVector, VolumeDim, TargetFrame>& inverse_spatial_metric,
     106              :     const Scalar<DataVector>& sqrt_det_spatial_metric);
     107              : 
     108              : template <size_t VolumeDim, typename TargetFrame>
     109            1 : void area_element(
     110              :     const gsl::not_null<Scalar<DataVector>*> result,
     111              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
     112              :                           TargetFrame>& inverse_jacobian_face,
     113              :     const Direction<VolumeDim>& direction,
     114              :     const tnsr::II<DataVector, VolumeDim, TargetFrame>& inverse_spatial_metric,
     115              :     const Scalar<DataVector>& sqrt_det_spatial_metric);
     116              : 
     117              : template <size_t VolumeDim, typename TargetFrame>
     118            1 : Scalar<DataVector> area_element(
     119              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
     120              :                           TargetFrame>& inverse_jacobian_face,
     121              :     const Scalar<DataVector>& inverse_jacobian_determinant_face,
     122              :     const Direction<VolumeDim>& direction,
     123              :     const tnsr::II<DataVector, VolumeDim, TargetFrame>& inverse_spatial_metric,
     124              :     const Scalar<DataVector>& sqrt_det_spatial_metric);
     125              : 
     126              : template <size_t VolumeDim, typename TargetFrame>
     127            1 : Scalar<DataVector> area_element(
     128              :     const InverseJacobian<DataVector, VolumeDim, Frame::ElementLogical,
     129              :                           TargetFrame>& inverse_jacobian_face,
     130              :     const Direction<VolumeDim>& direction,
     131              :     const tnsr::II<DataVector, VolumeDim, TargetFrame>& inverse_spatial_metric,
     132              :     const Scalar<DataVector>& sqrt_det_spatial_metric);
     133              : /// @}