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/EagerMath/Magnitude.hpp"
      12              : #include "DataStructures/Tensor/TypeAliases.hpp"
      13              : #include "Domain/FaceNormal.hpp"
      14              : #include "Domain/Tags.hpp"
      15              : #include "Elliptic/BoundaryConditions/BoundaryCondition.hpp"
      16              : #include "Elliptic/BoundaryConditions/BoundaryConditionType.hpp"
      17              : #include "Options/String.hpp"
      18              : #include "Utilities/Gsl.hpp"
      19              : #include "Utilities/Serialization/CharmPupable.hpp"
      20              : #include "Utilities/TMPL.hpp"
      21              : 
      22              : /// \cond
      23              : class DataVector;
      24              : /// \endcond
      25              : 
      26              : namespace Elasticity::BoundaryConditions {
      27              : 
      28              : /*!
      29              :  * \brief A laser beam with Gaussian profile normally incident to the surface
      30              :  *
      31              :  * This boundary condition represents a laser beam with Gaussian profile that
      32              :  * exerts pressure normal to the surface of a reflecting material. The pressure
      33              :  * we are considering here is
      34              :  *
      35              :  * \f{align}
      36              :  * n_i T^{ij} = -n^j \frac{e^{-\frac{r^2}{r_0^2}}}{\pi r_0^2}
      37              :  * \f}
      38              :  *
      39              :  * where \f$n_i\f$ is the unit normal pointing _out_ of the surface, \f$r\f$ is
      40              :  * the coordinate distance from the origin in the plane perpendicular to
      41              :  * \f$n_i\f$ and \f$r_0\f$ is the "beam width" parameter. The pressure profile
      42              :  * and the angle of incidence can be generalized in future work. Note that we
      43              :  * follow the convention of \cite Lovelace2007tn, \cite Lovelace2017xyf, and
      44              :  * \cite Vu2023thn in defining the beam width, and other publications may
      45              :  * include a factor of \f$\sqrt{2}\f$ in its definition.
      46              :  *
      47              :  * This boundary condition is used to simulate thermal noise induced in a mirror
      48              :  * by the laser, as detailed for instance in \cite Lovelace2007tn,
      49              :  * \cite Lovelace2017xyf, and \cite Vu2023thn.
      50              :  * See also `Elasticity::Solutions::HalfSpaceMirror` for
      51              :  * an analytic solution that involves this boundary condition.
      52              :  */
      53            1 : class LaserBeam : public elliptic::BoundaryConditions::BoundaryCondition<3> {
      54              :  private:
      55            0 :   using Base = elliptic::BoundaryConditions::BoundaryCondition<3>;
      56              : 
      57              :  public:
      58            0 :   struct BeamWidth {
      59            0 :     using type = double;
      60            0 :     static constexpr Options::String help =
      61              :         "The width r_0 of the Gaussian beam profile, such that FWHM = 2 * "
      62              :         "sqrt(ln 2) * r_0";
      63            0 :     static type lower_bound() { return 0.0; }
      64              :   };
      65              : 
      66            0 :   static constexpr Options::String help =
      67              :       "A laser beam with Gaussian profile normally incident to the surface.";
      68            0 :   using options = tmpl::list<BeamWidth>;
      69              : 
      70            0 :   LaserBeam() = default;
      71            0 :   LaserBeam(const LaserBeam&) = default;
      72            0 :   LaserBeam& operator=(const LaserBeam&) = default;
      73            0 :   LaserBeam(LaserBeam&&) = default;
      74            0 :   LaserBeam& operator=(LaserBeam&&) = default;
      75            0 :   ~LaserBeam() = default;
      76              : 
      77              :   /// \cond
      78              :   explicit LaserBeam(CkMigrateMessage* m) : Base(m) {}
      79              :   using PUP::able::register_constructor;
      80              :   WRAPPED_PUPable_decl_template(LaserBeam);
      81              :   /// \endcond
      82              : 
      83            0 :   std::unique_ptr<domain::BoundaryConditions::BoundaryCondition> get_clone()
      84              :       const override {
      85              :     return std::make_unique<LaserBeam>(*this);
      86              :   }
      87              : 
      88            0 :   LaserBeam(double beam_width) : beam_width_(beam_width) {}
      89              : 
      90            0 :   double beam_width() const { return beam_width_; }
      91              : 
      92            0 :   std::vector<elliptic::BoundaryConditionType> boundary_condition_types()
      93              :       const override {
      94              :     return {3, elliptic::BoundaryConditionType::Neumann};
      95              :   }
      96              : 
      97            0 :   using argument_tags =
      98              :       tmpl::list<domain::Tags::Coordinates<3, Frame::Inertial>,
      99              :                  ::Tags::Normalized<
     100              :                      domain::Tags::UnnormalizedFaceNormal<3, Frame::Inertial>>>;
     101            0 :   using volume_tags = tmpl::list<>;
     102              : 
     103            0 :   void apply(gsl::not_null<tnsr::I<DataVector, 3>*> displacement,
     104              :              gsl::not_null<tnsr::I<DataVector, 3>*> n_dot_minus_stress,
     105              :              const tnsr::iJ<DataVector, 3>& deriv_displacement,
     106              :              const tnsr::I<DataVector, 3>& x,
     107              :              const tnsr::i<DataVector, 3>& face_normal) const;
     108              : 
     109            0 :   using argument_tags_linearized = tmpl::list<>;
     110            0 :   using volume_tags_linearized = tmpl::list<>;
     111              : 
     112            0 :   static void apply_linearized(
     113              :       gsl::not_null<tnsr::I<DataVector, 3>*> displacement,
     114              :       gsl::not_null<tnsr::I<DataVector, 3>*> n_dot_minus_stress,
     115              :       const tnsr::iJ<DataVector, 3>& deriv_displacement);
     116              : 
     117              :   // NOLINTNEXTLINE(google-runtime-references)
     118            0 :   void pup(PUP::er& p) override { p | beam_width_; }
     119              : 
     120              :  private:
     121            0 :   double beam_width_{std::numeric_limits<double>::signaling_NaN()};
     122              : };
     123              : 
     124            0 : bool operator==(const LaserBeam& lhs, const LaserBeam& rhs);
     125              : 
     126            0 : bool operator!=(const LaserBeam& lhs, const LaserBeam& rhs);
     127              : 
     128              : }  // namespace Elasticity::BoundaryConditions