4245608534

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #4745 from knelli2/time_dep_dep

Run Details

13 of 13 new or added lines in 4 files covered. (100.0%)

63923 of 66629 relevant lines covered (95.94%)

427287.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.33

/src/Evolution/Systems/GeneralizedHarmonic/GaugeSourceFunctions/DampedWaveHelpers.cpp

// Distributed under the MIT License.
// See LICENSE.txt for details.

#include "Evolution/Systems/GeneralizedHarmonic/GaugeSourceFunctions/DampedWaveHelpers.hpp"

#include <cmath>
#include <cstddef>

#include "DataStructures/DataVector.hpp"
#include "DataStructures/Tags/TempTensor.hpp"
#include "DataStructures/TempBuffer.hpp"
#include "DataStructures/Tensor/EagerMath/DotProduct.hpp"
#include "DataStructures/Tensor/Tensor.hpp"
#include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/SpacetimeDerivOfDetSpatialMetric.hpp"
#include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/SpatialDerivOfLapse.hpp"
#include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/TimeDerivOfLapse.hpp"
#include "Utilities/ConstantExpressions.hpp"
#include "Utilities/ContainerHelpers.hpp"
#include "Utilities/GenerateInstantiations.hpp"
#include "Utilities/Gsl.hpp"
#include "Utilities/TMPL.hpp"

namespace GeneralizedHarmonic::gauges::DampedHarmonicGauge_detail {
template <size_t SpatialDim, typename Frame, typename DataType>
void spatial_weight_function(const gsl::not_null<Scalar<DataType>*> weight,
                             const tnsr::I<DataType, SpatialDim, Frame>& coords,
                             const double sigma_r) {
  destructive_resize_components(weight, get_size(get<0>(coords)));
  const auto r_squared = dot_product(coords, coords);
  get(*weight) = exp(-get(r_squared) / pow<2>(sigma_r));
}

template <size_t SpatialDim, typename Frame, typename DataType>
void spacetime_deriv_of_spatial_weight_function(
    const gsl::not_null<tnsr::a<DataType, SpatialDim, Frame>*> d4_weight,
    const tnsr::I<DataType, SpatialDim, Frame>& coords, const double sigma_r,
    const Scalar<DataType>& weight_function) {
  destructive_resize_components(d4_weight, get_size(get<0>(coords)));
  // use 0th component to avoid allocations
  get<0>(*d4_weight) = get(weight_function) * (-2. / pow<2>(sigma_r));
  for (size_t i = 0; i < SpatialDim; ++i) {
    d4_weight->get(1 + i) = get<0>(*d4_weight) * coords.get(i);
  }
  // time derivative of weight function is zero
  get<0>(*d4_weight) = 0.;
}

template <typename DataType>
void log_factor_metric_lapse(const gsl::not_null<Scalar<DataType>*> logfac,
                             const Scalar<DataType>& lapse,
                             const Scalar<DataType>& sqrt_det_spatial_metric,
                             const double exponent) {
  destructive_resize_components(logfac, get_size(get(lapse)));
  // branching below is to avoid using pow for performance reasons
  if (exponent == 0.) {
    get(*logfac) = -log(get(lapse));
  } else if (exponent == 0.5) {
    get(*logfac) = log(get(sqrt_det_spatial_metric) / get(lapse));
  } else {
    get(*logfac) =
        2. * exponent * log(get(sqrt_det_spatial_metric)) - log(get(lapse));
  }
}

template <typename DataType>
Scalar<DataType> log_factor_metric_lapse(
    const Scalar<DataType>& lapse,
    const Scalar<DataType>& sqrt_det_spatial_metric, const double exponent) {
  Scalar<DataType> logfac{get_size(get(lapse))};
  log_factor_metric_lapse(make_not_null(&logfac), lapse,
                          sqrt_det_spatial_metric, exponent);
  return logfac;
}

template <size_t SpatialDim, typename Frame, typename DataType>
void spacetime_deriv_of_log_factor_metric_lapse(
    const gsl::not_null<tnsr::a<DataType, SpatialDim, Frame>*> d4_logfac,
    const Scalar<DataType>& lapse,
    const tnsr::I<DataType, SpatialDim, Frame>& shift,
    const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
    const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
    const Scalar<DataType>& sqrt_det_spatial_metric,
    const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
    const tnsr::aa<DataType, SpatialDim, Frame>& pi,
    const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double exponent) {
  destructive_resize_components(d4_logfac, get_size(get(lapse)));
  // Use a TempBuffer to reduce total number of allocations. This is especially
  // important in a multithreaded environment.
  TempBuffer<tmpl::list<::Tags::Tempa<0, SpatialDim, Frame, DataType>,
                        ::Tags::Tempi<1, SpatialDim, Frame, DataType>,
                        ::Tags::Tempa<2, SpatialDim, Frame, DataType>,
                        ::Tags::TempScalar<3, DataType>,
                        ::Tags::TempScalar<4, DataType>>>
      buffer(get_size(get(lapse)));
  auto& d_g = get<::Tags::Tempa<0, SpatialDim, Frame, DataType>>(buffer);
  auto& d3_lapse = get<::Tags::Tempi<1, SpatialDim, Frame, DataType>>(buffer);
  auto& d_lapse = get<::Tags::Tempa<2, SpatialDim, Frame, DataType>>(buffer);
  auto& dt_lapse = get<::Tags::TempScalar<3, DataType>>(buffer);
  auto& one_over_lapse = get<::Tags::TempScalar<4, DataType>>(buffer);

  // Get \f$ \partial_a g\f$
  spacetime_deriv_of_det_spatial_metric<SpatialDim, Frame, DataType>(
      make_not_null(&d_g), sqrt_det_spatial_metric, inverse_spatial_metric,
      dt_spatial_metric, phi);
  // Get \f$ \partial_a N\f$
  time_deriv_of_lapse<SpatialDim, Frame, DataType>(
      make_not_null(&dt_lapse), lapse, shift, spacetime_unit_normal, phi, pi);
  spatial_deriv_of_lapse<SpatialDim, Frame, DataType>(
      make_not_null(&d3_lapse), lapse, spacetime_unit_normal, phi);
  get<0>(d_lapse) = get(dt_lapse);
  for (size_t i = 0; i < SpatialDim; ++i) {
    d_lapse.get(1 + i) = d3_lapse.get(i);
  }
  // Compute
  get(one_over_lapse) = 1. / get(lapse);
  if (exponent == 0.) {
    for (size_t a = 0; a < SpatialDim + 1; ++a) {
      d4_logfac->get(a) = -get(one_over_lapse) * d_lapse.get(a);
    }
  } else {
    const auto p_over_g = exponent / square(get(sqrt_det_spatial_metric));
    for (size_t a = 0; a < SpatialDim + 1; ++a) {
      d4_logfac->get(a) =
          p_over_g * d_g.get(a) - get(one_over_lapse) * d_lapse.get(a);
    }
  }
}

template <size_t SpatialDim, typename Frame, typename DataType>
tnsr::a<DataType, SpatialDim, Frame> spacetime_deriv_of_log_factor_metric_lapse(
    const Scalar<DataType>& lapse,
    const tnsr::I<DataType, SpatialDim, Frame>& shift,
    const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
    const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
    const Scalar<DataType>& sqrt_det_spatial_metric,
    const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
    const tnsr::aa<DataType, SpatialDim, Frame>& pi,
    const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double exponent) {
  tnsr::a<DataType, SpatialDim, Frame> d4_logfac{get_size(get(lapse))};
  spacetime_deriv_of_log_factor_metric_lapse(
      make_not_null(&d4_logfac), lapse, shift, spacetime_unit_normal,
      inverse_spatial_metric, sqrt_det_spatial_metric, dt_spatial_metric, pi,
      phi, exponent);
  return d4_logfac;
}

template <size_t SpatialDim, typename Frame, typename DataType>
void spacetime_deriv_of_power_log_factor_metric_lapse(
    const gsl::not_null<tnsr::a<DataType, SpatialDim, Frame>*> d4_powlogfac,
    const Scalar<DataType>& lapse,
    const tnsr::I<DataType, SpatialDim, Frame>& shift,
    const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
    const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
    const Scalar<DataType>& sqrt_det_spatial_metric,
    const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
    const tnsr::aa<DataType, SpatialDim, Frame>& pi,
    const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double g_exponent,
    const int exponent) {
  destructive_resize_components(d4_powlogfac, get_size(get(lapse)));
  // Use a TempBuffer to reduce total number of allocations. This is especially
  // important in a multithreaded environment.
  TempBuffer<tmpl::list<::Tags::Tempa<0, SpatialDim, Frame, DataType>,
                        ::Tags::TempScalar<1, DataType>,
                        ::Tags::TempScalar<2, DataType>>>
      buffer(get_size(get(lapse)));
  auto& dlogfac = get<::Tags::Tempa<0, SpatialDim, Frame, DataType>>(buffer);
  auto& logfac = get<::Tags::TempScalar<1, DataType>>(buffer);
  auto& prefac = get<::Tags::TempScalar<2, DataType>>(buffer);

  // Compute derivative
  spacetime_deriv_of_log_factor_metric_lapse<SpatialDim, Frame, DataType>(
      make_not_null(&dlogfac), lapse, shift, spacetime_unit_normal,
      inverse_spatial_metric, sqrt_det_spatial_metric, dt_spatial_metric, pi,
      phi, g_exponent);
  // Apply pre-factor
  if (UNLIKELY(exponent == 0)) {
    for (size_t a = 0; a < SpatialDim + 1; ++a) {
      d4_powlogfac->get(a) = 0.;
    }
  } else if (UNLIKELY(exponent == 1)) {
    for (size_t a = 0; a < SpatialDim + 1; ++a) {
      d4_powlogfac->get(a) = dlogfac.get(a);
    }
  } else {
    log_factor_metric_lapse<DataType>(make_not_null(&logfac), lapse,
                                      sqrt_det_spatial_metric, g_exponent);
    get(prefac) =
        static_cast<double>(exponent) * pow(get(logfac), exponent - 1);
    for (size_t a = 0; a < SpatialDim + 1; ++a) {
      d4_powlogfac->get(a) = get(prefac) * dlogfac.get(a);
    }
  }
}

template <size_t SpatialDim, typename Frame, typename DataType>
tnsr::a<DataType, SpatialDim, Frame>
spacetime_deriv_of_power_log_factor_metric_lapse(
    const Scalar<DataType>& lapse,
    const tnsr::I<DataType, SpatialDim, Frame>& shift,
    const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
    const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
    const Scalar<DataType>& sqrt_det_spatial_metric,
    const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
    const tnsr::aa<DataType, SpatialDim, Frame>& pi,
    const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double g_exponent,
    const int exponent) {
  tnsr::a<DataType, SpatialDim, Frame> d4_powlogfac{get_size(get(lapse))};
  spacetime_deriv_of_power_log_factor_metric_lapse(
      make_not_null(&d4_powlogfac), lapse, shift, spacetime_unit_normal,
      inverse_spatial_metric, sqrt_det_spatial_metric, dt_spatial_metric, pi,
      phi, g_exponent, exponent);
  return d4_powlogfac;
}

#define DIM(data) BOOST_PP_TUPLE_ELEM(0, data)
#define DTYPE(data) BOOST_PP_TUPLE_ELEM(1, data)
#define FRAME(data) BOOST_PP_TUPLE_ELEM(2, data)
#define DTYPE_SCAL(data) BOOST_PP_TUPLE_ELEM(0, data)

#define INSTANTIATE(_, data)                                                  \
  template void spatial_weight_function(                                      \
      const gsl::not_null<Scalar<DTYPE(data)>*> weight,                       \
      const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& coords,             \
      const double sigma_r);                                                  \
  template void spacetime_deriv_of_spatial_weight_function(                   \
      const gsl::not_null<tnsr::a<DTYPE(data), DIM(data), FRAME(data)>*>      \
          d4_weight,                                                          \
      const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& coords,             \
      const double sigma_r, const Scalar<DTYPE(data)>& weight_function);      \
  template void spacetime_deriv_of_log_factor_metric_lapse(                   \
      const gsl::not_null<tnsr::a<DTYPE(data), DIM(data), FRAME(data)>*>      \
          d4_logfac,                                                          \
      const Scalar<DTYPE(data)>& lapse,                                       \
      const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift,              \
      const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>&                     \
          spacetime_unit_normal,                                              \
      const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>&                    \
          inverse_spatial_metric,                                             \
      const Scalar<DTYPE(data)>& sqrt_det_spatial_metric,                     \
      const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
      const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi,                \
      const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi,              \
      const double exponent);                                                 \
  template tnsr::a<DTYPE(data), DIM(data), FRAME(data)>                       \
  spacetime_deriv_of_log_factor_metric_lapse(                                 \
      const Scalar<DTYPE(data)>& lapse,                                       \
      const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift,              \
      const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>&                     \
          spacetime_unit_normal,                                              \
      const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>&                    \
          inverse_spatial_metric,                                             \
      const Scalar<DTYPE(data)>& sqrt_det_spatial_metric,                     \
      const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
      const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi,                \
      const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi,              \
      const double exponent);                                                 \
  template void spacetime_deriv_of_power_log_factor_metric_lapse(             \
      const gsl::not_null<tnsr::a<DTYPE(data), DIM(data), FRAME(data)>*>      \
          d4_powlogfac,                                                       \
      const Scalar<DTYPE(data)>& lapse,                                       \
      const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift,              \
      const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>&                     \
          spacetime_unit_normal,                                              \
      const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>&                    \
          inverse_spatial_metric,                                             \
      const Scalar<DTYPE(data)>& sqrt_det_spatial_metric,                     \
      const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
      const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi,                \
      const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi,              \
      const double g_exponent, const int exponent);                           \
  template tnsr::a<DTYPE(data), DIM(data), FRAME(data)>                       \
  spacetime_deriv_of_power_log_factor_metric_lapse(                           \
      const Scalar<DTYPE(data)>& lapse,                                       \
      const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift,              \
      const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>&                     \
          spacetime_unit_normal,                                              \
      const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>&                    \
          inverse_spatial_metric,                                             \
      const Scalar<DTYPE(data)>& sqrt_det_spatial_metric,                     \
      const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
      const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi,                \
      const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi,              \
      const double g_exponent, const int exponent);

GENERATE_INSTANTIATIONS(INSTANTIATE, (1, 2, 3), (double, DataVector),
                        (Frame::Inertial))

#undef INSTANTIATE

#define INSTANTIATE(_, data)                                   \
  template void log_factor_metric_lapse(                       \
      const gsl::not_null<Scalar<DTYPE_SCAL(data)>*> logfac,   \
      const Scalar<DTYPE_SCAL(data)>& lapse,                   \
      const Scalar<DTYPE_SCAL(data)>& sqrt_det_spatial_metric, \
      const double exponent);                                  \
  template Scalar<DTYPE_SCAL(data)> log_factor_metric_lapse(   \
      const Scalar<DTYPE_SCAL(data)>& lapse,                   \
      const Scalar<DTYPE_SCAL(data)>& sqrt_det_spatial_metric, \
      const double exponent);

GENERATE_INSTANTIATIONS(INSTANTIATE, (double, DataVector))

#undef INSTANTIATE

#undef DTYPE_SCAL
#undef FRAME
#undef DTYPE
#undef DIM
}  // namespace GeneralizedHarmonic::gauges::DampedHarmonicGauge_detail

1	// Distributed under the MIT License.
2	// See LICENSE.txt for details.
3
4	#include "Evolution/Systems/GeneralizedHarmonic/GaugeSourceFunctions/DampedWaveHelpers.hpp"
5
6	#include <cmath>
7	#include <cstddef>
8
9	#include "DataStructures/DataVector.hpp"
10	#include "DataStructures/Tags/TempTensor.hpp"
11	#include "DataStructures/TempBuffer.hpp"
12	#include "DataStructures/Tensor/EagerMath/DotProduct.hpp"
13	#include "DataStructures/Tensor/Tensor.hpp"
14	#include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/SpacetimeDerivOfDetSpatialMetric.hpp"
15	#include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/SpatialDerivOfLapse.hpp"
16	#include "PointwiseFunctions/GeneralRelativity/GeneralizedHarmonic/TimeDerivOfLapse.hpp"
17	#include "Utilities/ConstantExpressions.hpp"
18	#include "Utilities/ContainerHelpers.hpp"
19	#include "Utilities/GenerateInstantiations.hpp"
20	#include "Utilities/Gsl.hpp"
21	#include "Utilities/TMPL.hpp"
22
23	namespace GeneralizedHarmonic::gauges::DampedHarmonicGauge_detail {
24	template <size_t SpatialDim, typename Frame, typename DataType>
25	void spatial_weight_function(const gsl::not_null<Scalar<DataType>*> weight,	56✔
26	const tnsr::I<DataType, SpatialDim, Frame>& coords,
27	const double sigma_r) {
28	destructive_resize_components(weight, get_size(get<0>(coords)));	112✔
29	const auto r_squared = dot_product(coords, coords);	56✔
30	get(*weight) = exp(-get(r_squared) / pow<2>(sigma_r));	165✔
31	}	56✔
32
33	template <size_t SpatialDim, typename Frame, typename DataType>
34	void spacetime_deriv_of_spatial_weight_function(	56✔
35	const gsl::not_null<tnsr::a<DataType, SpatialDim, Frame>*> d4_weight,
36	const tnsr::I<DataType, SpatialDim, Frame>& coords, const double sigma_r,
37	const Scalar<DataType>& weight_function) {
38	destructive_resize_components(d4_weight, get_size(get<0>(coords)));	168✔
39	// use 0th component to avoid allocations
40	get<0>(d4_weight) = get(weight_function) (-2. / pow<2>(sigma_r));	165✔
41	for (size_t i = 0; i < SpatialDim; ++i) {	176✔
42	d4_weight->get(1 + i) = get<0>(d4_weight) coords.get(i);	240✔
43	}
44	// time derivative of weight function is zero
45	get<0>(*d4_weight) = 0.;	109✔
46	}	56✔
47
48	template <typename DataType>
49	void log_factor_metric_lapse(const gsl::not_null<Scalar<DataType>*> logfac,	262✔
50	const Scalar<DataType>& lapse,
51	const Scalar<DataType>& sqrt_det_spatial_metric,
52	const double exponent) {
53	destructive_resize_components(logfac, get_size(get(lapse)));	524✔
54	// branching below is to avoid using pow for performance reasons
55	if (exponent == 0.) {	262✔
56	get(*logfac) = -log(get(lapse));	200✔
57	} else if (exponent == 0.5) {	162✔
58	get(*logfac) = log(get(sqrt_det_spatial_metric) / get(lapse));	450✔
59	} else {
60	get(*logfac) =	24✔
61	2. * exponent * log(get(sqrt_det_spatial_metric)) - log(get(lapse));	36✔
62	}
63	}	262✔
64
65	template <typename DataType>
66	Scalar<DataType> log_factor_metric_lapse(	6✔
67	const Scalar<DataType>& lapse,
68	const Scalar<DataType>& sqrt_det_spatial_metric, const double exponent) {
69	Scalar<DataType> logfac{get_size(get(lapse))};	12✔
70	log_factor_metric_lapse(make_not_null(&logfac), lapse,	6✔
71	sqrt_det_spatial_metric, exponent);
72	return logfac;	6✔
73	}
74
75	template <size_t SpatialDim, typename Frame, typename DataType>
76	void spacetime_deriv_of_log_factor_metric_lapse(	162✔
77	const gsl::not_null<tnsr::a<DataType, SpatialDim, Frame>*> d4_logfac,
78	const Scalar<DataType>& lapse,
79	const tnsr::I<DataType, SpatialDim, Frame>& shift,
80	const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
81	const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
82	const Scalar<DataType>& sqrt_det_spatial_metric,
83	const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
84	const tnsr::aa<DataType, SpatialDim, Frame>& pi,
85	const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double exponent) {
86	destructive_resize_components(d4_logfac, get_size(get(lapse)));	486✔
87	// Use a TempBuffer to reduce total number of allocations. This is especially
88	// important in a multithreaded environment.
89	TempBuffer<tmpl::list<::Tags::Tempa<0, SpatialDim, Frame, DataType>,
90	::Tags::Tempi<1, SpatialDim, Frame, DataType>,
91	::Tags::Tempa<2, SpatialDim, Frame, DataType>,
92	::Tags::TempScalar<3, DataType>,
93	::Tags::TempScalar<4, DataType>>>
94	buffer(get_size(get(lapse)));	480✔
95	auto& d_g = get<::Tags::Tempa<0, SpatialDim, Frame, DataType>>(buffer);	162✔
96	auto& d3_lapse = get<::Tags::Tempi<1, SpatialDim, Frame, DataType>>(buffer);	162✔
97	auto& d_lapse = get<::Tags::Tempa<2, SpatialDim, Frame, DataType>>(buffer);	162✔
98	auto& dt_lapse = get<::Tags::TempScalar<3, DataType>>(buffer);	162✔
99	auto& one_over_lapse = get<::Tags::TempScalar<4, DataType>>(buffer);	162✔
100
101	// Get \f$ \partial_a g\f$
102	spacetime_deriv_of_det_spatial_metric<SpatialDim, Frame, DataType>(	162✔
103	make_not_null(&d_g), sqrt_det_spatial_metric, inverse_spatial_metric,
104	dt_spatial_metric, phi);
105	// Get \f$ \partial_a N\f$
106	time_deriv_of_lapse<SpatialDim, Frame, DataType>(	162✔
107	make_not_null(&dt_lapse), lapse, shift, spacetime_unit_normal, phi, pi);
108	spatial_deriv_of_lapse<SpatialDim, Frame, DataType>(	162✔
109	make_not_null(&d3_lapse), lapse, spacetime_unit_normal, phi);
110	get<0>(d_lapse) = get(dt_lapse);	318✔
111	for (size_t i = 0; i < SpatialDim; ++i) {	510✔
112	d_lapse.get(1 + i) = d3_lapse.get(i);	348✔
113	}
114	// Compute
115	get(one_over_lapse) = 1. / get(lapse);	318✔
116	if (exponent == 0.) {	162✔
117	for (size_t a = 0; a < SpatialDim + 1; ++a) {	208✔
118	d4_logfac->get(a) = -get(one_over_lapse) * d_lapse.get(a);	316✔
119	}
120	} else {
121	const auto p_over_g = exponent / square(get(sqrt_det_spatial_metric));	218✔
122	for (size_t a = 0; a < SpatialDim + 1; ++a) {	464✔
123	d4_logfac->get(a) =	352✔
124	p_over_g * d_g.get(a) - get(one_over_lapse) * d_lapse.get(a);	1,038✔
125	}
126	}
127	}	162✔
128
129	template <size_t SpatialDim, typename Frame, typename DataType>
130	tnsr::a<DataType, SpatialDim, Frame> spacetime_deriv_of_log_factor_metric_lapse(	6✔
131	const Scalar<DataType>& lapse,
132	const tnsr::I<DataType, SpatialDim, Frame>& shift,
133	const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
134	const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
135	const Scalar<DataType>& sqrt_det_spatial_metric,
136	const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
137	const tnsr::aa<DataType, SpatialDim, Frame>& pi,
138	const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double exponent) {
139	tnsr::a<DataType, SpatialDim, Frame> d4_logfac{get_size(get(lapse))};	12✔
140	spacetime_deriv_of_log_factor_metric_lapse(	6✔
141	make_not_null(&d4_logfac), lapse, shift, spacetime_unit_normal,
142	inverse_spatial_metric, sqrt_det_spatial_metric, dt_spatial_metric, pi,
143	phi, exponent);
144	return d4_logfac;	6✔
145	}
146
147	template <size_t SpatialDim, typename Frame, typename DataType>
148	void spacetime_deriv_of_power_log_factor_metric_lapse(	156✔
149	const gsl::not_null<tnsr::a<DataType, SpatialDim, Frame>*> d4_powlogfac,
150	const Scalar<DataType>& lapse,
151	const tnsr::I<DataType, SpatialDim, Frame>& shift,
152	const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
153	const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
154	const Scalar<DataType>& sqrt_det_spatial_metric,
155	const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
156	const tnsr::aa<DataType, SpatialDim, Frame>& pi,
157	const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double g_exponent,
158	const int exponent) {
159	destructive_resize_components(d4_powlogfac, get_size(get(lapse)));	468✔
160	// Use a TempBuffer to reduce total number of allocations. This is especially
161	// important in a multithreaded environment.
162	TempBuffer<tmpl::list<::Tags::Tempa<0, SpatialDim, Frame, DataType>,
163	::Tags::TempScalar<1, DataType>,
164	::Tags::TempScalar<2, DataType>>>
165	buffer(get_size(get(lapse)));	465✔
166	auto& dlogfac = get<::Tags::Tempa<0, SpatialDim, Frame, DataType>>(buffer);	156✔
167	auto& logfac = get<::Tags::TempScalar<1, DataType>>(buffer);	156✔
168	auto& prefac = get<::Tags::TempScalar<2, DataType>>(buffer);	156✔
169
170	// Compute derivative
171	spacetime_deriv_of_log_factor_metric_lapse<SpatialDim, Frame, DataType>(	156✔
172	make_not_null(&dlogfac), lapse, shift, spacetime_unit_normal,
173	inverse_spatial_metric, sqrt_det_spatial_metric, dt_spatial_metric, pi,
174	phi, g_exponent);
175	// Apply pre-factor
176	if (UNLIKELY(exponent == 0)) {	156✔
177	for (size_t a = 0; a < SpatialDim + 1; ++a) {	×
178	d4_powlogfac->get(a) = 0.;	×
179	}
180	} else if (UNLIKELY(exponent == 1)) {	156✔
181	for (size_t a = 0; a < SpatialDim + 1; ++a) {	×
182	d4_powlogfac->get(a) = dlogfac.get(a);	×
183	}
184	} else {
185	log_factor_metric_lapse<DataType>(make_not_null(&logfac), lapse,	156✔
186	sqrt_det_spatial_metric, g_exponent);
187	get(prefac) =	156✔
188	static_cast<double>(exponent) * pow(get(logfac), exponent - 1);	312✔
189	for (size_t a = 0; a < SpatialDim + 1; ++a) {	648✔
190	d4_powlogfac->get(a) = get(prefac) * dlogfac.get(a);	975✔
191	}
192	}
193	}	156✔
194
195	template <size_t SpatialDim, typename Frame, typename DataType>
196	tnsr::a<DataType, SpatialDim, Frame>
197	spacetime_deriv_of_power_log_factor_metric_lapse(	×
198	const Scalar<DataType>& lapse,
199	const tnsr::I<DataType, SpatialDim, Frame>& shift,
200	const tnsr::A<DataType, SpatialDim, Frame>& spacetime_unit_normal,
201	const tnsr::II<DataType, SpatialDim, Frame>& inverse_spatial_metric,
202	const Scalar<DataType>& sqrt_det_spatial_metric,
203	const tnsr::ii<DataType, SpatialDim, Frame>& dt_spatial_metric,
204	const tnsr::aa<DataType, SpatialDim, Frame>& pi,
205	const tnsr::iaa<DataType, SpatialDim, Frame>& phi, const double g_exponent,
206	const int exponent) {
207	tnsr::a<DataType, SpatialDim, Frame> d4_powlogfac{get_size(get(lapse))};	×
208	spacetime_deriv_of_power_log_factor_metric_lapse(	×
209	make_not_null(&d4_powlogfac), lapse, shift, spacetime_unit_normal,
210	inverse_spatial_metric, sqrt_det_spatial_metric, dt_spatial_metric, pi,
211	phi, g_exponent, exponent);
212	return d4_powlogfac;	×
213	}
214
215	#define DIM(data) BOOST_PP_TUPLE_ELEM(0, data)
216	#define DTYPE(data) BOOST_PP_TUPLE_ELEM(1, data)
217	#define FRAME(data) BOOST_PP_TUPLE_ELEM(2, data)
218	#define DTYPE_SCAL(data) BOOST_PP_TUPLE_ELEM(0, data)
219
220	#define INSTANTIATE(_, data) \
221	template void spatial_weight_function( \
222	const gsl::not_null<Scalar<DTYPE(data)>*> weight, \
223	const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& coords, \
224	const double sigma_r); \
225	template void spacetime_deriv_of_spatial_weight_function( \
226	const gsl::not_null<tnsr::a<DTYPE(data), DIM(data), FRAME(data)>*> \
227	d4_weight, \
228	const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& coords, \
229	const double sigma_r, const Scalar<DTYPE(data)>& weight_function); \
230	template void spacetime_deriv_of_log_factor_metric_lapse( \
231	const gsl::not_null<tnsr::a<DTYPE(data), DIM(data), FRAME(data)>*> \
232	d4_logfac, \
233	const Scalar<DTYPE(data)>& lapse, \
234	const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift, \
235	const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>& \
236	spacetime_unit_normal, \
237	const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>& \
238	inverse_spatial_metric, \
239	const Scalar<DTYPE(data)>& sqrt_det_spatial_metric, \
240	const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
241	const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi, \
242	const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi, \
243	const double exponent); \
244	template tnsr::a<DTYPE(data), DIM(data), FRAME(data)> \
245	spacetime_deriv_of_log_factor_metric_lapse( \
246	const Scalar<DTYPE(data)>& lapse, \
247	const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift, \
248	const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>& \
249	spacetime_unit_normal, \
250	const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>& \
251	inverse_spatial_metric, \
252	const Scalar<DTYPE(data)>& sqrt_det_spatial_metric, \
253	const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
254	const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi, \
255	const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi, \
256	const double exponent); \
257	template void spacetime_deriv_of_power_log_factor_metric_lapse( \
258	const gsl::not_null<tnsr::a<DTYPE(data), DIM(data), FRAME(data)>*> \
259	d4_powlogfac, \
260	const Scalar<DTYPE(data)>& lapse, \
261	const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift, \
262	const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>& \
263	spacetime_unit_normal, \
264	const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>& \
265	inverse_spatial_metric, \
266	const Scalar<DTYPE(data)>& sqrt_det_spatial_metric, \
267	const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
268	const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi, \
269	const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi, \
270	const double g_exponent, const int exponent); \
271	template tnsr::a<DTYPE(data), DIM(data), FRAME(data)> \
272	spacetime_deriv_of_power_log_factor_metric_lapse( \
273	const Scalar<DTYPE(data)>& lapse, \
274	const tnsr::I<DTYPE(data), DIM(data), FRAME(data)>& shift, \
275	const tnsr::A<DTYPE(data), DIM(data), FRAME(data)>& \
276	spacetime_unit_normal, \
277	const tnsr::II<DTYPE(data), DIM(data), FRAME(data)>& \
278	inverse_spatial_metric, \
279	const Scalar<DTYPE(data)>& sqrt_det_spatial_metric, \
280	const tnsr::ii<DTYPE(data), DIM(data), FRAME(data)>& dt_spatial_metric, \
281	const tnsr::aa<DTYPE(data), DIM(data), FRAME(data)>& pi, \
282	const tnsr::iaa<DTYPE(data), DIM(data), FRAME(data)>& phi, \
283	const double g_exponent, const int exponent);
284
285	GENERATE_INSTANTIATIONS(INSTANTIATE, (1, 2, 3), (double, DataVector),
286	(Frame::Inertial))
287
288	#undef INSTANTIATE
289
290	#define INSTANTIATE(_, data) \
291	template void log_factor_metric_lapse( \
292	const gsl::not_null<Scalar<DTYPE_SCAL(data)>*> logfac, \
293	const Scalar<DTYPE_SCAL(data)>& lapse, \
294	const Scalar<DTYPE_SCAL(data)>& sqrt_det_spatial_metric, \
295	const double exponent); \
296	template Scalar<DTYPE_SCAL(data)> log_factor_metric_lapse( \
297	const Scalar<DTYPE_SCAL(data)>& lapse, \
298	const Scalar<DTYPE_SCAL(data)>& sqrt_det_spatial_metric, \
299	const double exponent);
300
301	GENERATE_INSTANTIATIONS(INSTANTIATE, (double, DataVector))
302
303	#undef INSTANTIATE
304
305	#undef DTYPE_SCAL
306	#undef FRAME
307	#undef DTYPE
308	#undef DIM
309	} // namespace GeneralizedHarmonic::gauges::DampedHarmonicGauge_detail

sxs-collaboration / spectre / 4245608534

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous