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 <optional>
       8             : #include <vector>
       9             : 
      10             : #include "DataStructures/DataBox/Tag.hpp"
      11             : #include "DataStructures/DataVector.hpp"
      12             : #include "DataStructures/Tensor/Slice.hpp"
      13             : #include "DataStructures/Variables.hpp"
      14             : #include "Evolution/Systems/CurvedScalarWave/Tags.hpp"
      15             : #include "Evolution/Systems/CurvedScalarWave/Worldtube/ElementActions/SendToWorldtube.hpp"
      16             : #include "Evolution/Systems/CurvedScalarWave/Worldtube/Inboxes.hpp"
      17             : #include "Evolution/Systems/CurvedScalarWave/Worldtube/PunctureField.hpp"
      18             : #include "Evolution/Systems/CurvedScalarWave/Worldtube/Tags.hpp"
      19             : #include "Parallel/AlgorithmExecution.hpp"
      20             : #include "Parallel/GlobalCache.hpp"
      21             : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      22             : #include "Utilities/ErrorHandling/Assert.hpp"
      23             : #include "Utilities/Gsl.hpp"
      24             : 
      25             : namespace CurvedScalarWave::Worldtube::Actions {
      26             : /*!
      27             :  * \brief Computes an updated iteration of the puncture field given the current
      28             :  * acceleration of the charge sent by the worldtube singleton.
      29             :  */
      30           1 : struct IteratePunctureField {
      31           0 :   static constexpr size_t Dim = 3;
      32             : 
      33           0 :   using inbox_tags = tmpl::list<Tags::SelfForceInbox<Dim>>;
      34           0 :   using simple_tags = tmpl::list<Tags::IteratedPunctureField<Dim>>;
      35             : 
      36             :   template <typename DbTagsList, typename... InboxTags, typename Metavariables,
      37             :             typename ArrayIndex, typename ActionList,
      38             :             typename ParallelComponent>
      39           0 :   static Parallel::iterable_action_return_t apply(
      40             :       db::DataBox<DbTagsList>& box, tuples::TaggedTuple<InboxTags...>& inboxes,
      41             :       Parallel::GlobalCache<Metavariables>& /*cache*/,
      42             :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
      43             :       const ParallelComponent* const /*meta*/) {
      44             :     const auto& centered_face_coordinates =
      45             :         db::get<Tags::FaceCoordinates<Dim, Frame::Inertial, true>>(box);
      46             :     if (not centered_face_coordinates.has_value()) {
      47             :       return {Parallel::AlgorithmExecution::Continue, std::nullopt};
      48             :     }
      49             :     const auto& time_step_id = db::get<::Tags::TimeStepId>(box);
      50             :     auto& inbox = get<Tags::SelfForceInbox<Dim>>(inboxes);
      51             :     if (not inbox.count(time_step_id)) {
      52             :       return {Parallel::AlgorithmExecution::Retry, std::nullopt};
      53             :     }
      54             :     db::mutate<Tags::IteratedPunctureField<Dim>>(
      55             :         [&self_force_data = get(inbox.at(time_step_id)),
      56             :          &position_velocity = db::get<Tags::ParticlePositionVelocity<Dim>>(box),
      57             :          &centered_face_coordinates, charge = db::get<Tags::Charge>(box),
      58             :          order = db::get<Tags::ExpansionOrder>(box)](
      59             :             const auto iterated_puncture_field) {
      60             :           tnsr::I<double, Dim> iterated_acceleration{
      61             :               {self_force_data[0], self_force_data[1], self_force_data[2]}};
      62             :           const size_t face_size =
      63             :               get<0>(centered_face_coordinates.value()).size();
      64             : 
      65             :           if (not iterated_puncture_field->has_value()) {
      66             :             iterated_puncture_field->emplace(face_size);
      67             :           }
      68             : 
      69             :           puncture_field(make_not_null(&iterated_puncture_field->value()),
      70             :                          centered_face_coordinates.value(),
      71             :                          position_velocity[0], position_velocity[1],
      72             :                          iterated_acceleration, 1., order);
      73             :           Variables<tmpl::list<CurvedScalarWave::Tags::Psi,
      74             :                                ::Tags::dt<CurvedScalarWave::Tags::Psi>,
      75             :                                ::Tags::deriv<CurvedScalarWave::Tags::Psi,
      76             :                                              tmpl::size_t<3>, Frame::Inertial>>>
      77             :               acceleration_terms(face_size);
      78             :           acceleration_terms_1(
      79             :               make_not_null(&acceleration_terms),
      80             :               centered_face_coordinates.value(), position_velocity[0],
      81             :               position_velocity[1], iterated_acceleration, self_force_data[3],
      82             :               self_force_data[4], self_force_data[5], self_force_data[6],
      83             :               self_force_data[7], self_force_data[8], self_force_data[9],
      84             :               self_force_data[10], self_force_data[11], self_force_data[12],
      85             :               self_force_data[13], self_force_data[14], 1.);
      86             :           iterated_puncture_field->value() += acceleration_terms;
      87             :           iterated_puncture_field->value() *= charge;
      88             :         },
      89             :         make_not_null(&box));
      90             :     inbox.erase(time_step_id);
      91             :     return {Parallel::AlgorithmExecution::Continue,
      92             :             tmpl::index_of<ActionList, SendToWorldtube>::value};
      93             :   }
      94             : };
      95             : }  // namespace CurvedScalarWave::Worldtube::Actions