23 #include <gsl/gsl_errno.h>
24 #include <gsl/gsl_spline.h>
25 #include <gsl/gsl_math.h>
26 #include <gsl/gsl_sf_trig.h>
29 #include <lal/FrequencySeries.h>
30 #include <lal/LALAtomicDatatypes.h>
31 #include <lal/LALConstants.h>
32 #include <lal/LALDatatypes.h>
33 #include <lal/LALSimInspiral.h>
34 #include <lal/Units.h>
35 #include <lal/XLALError.h>
36 #include <lal/SphericalHarmonics.h>
37 #include <lal/Sequence.h>
38 #include <lal/LALStdlib.h>
39 #include <lal/LALStddef.h>
54 #define ROTATEZ(angle, vx, vy, vz)\
55 tmp1 = vx*cos(angle) - vy*sin(angle);\
56 tmp2 = vx*sin(angle) + vy*cos(angle);\
60 #define ROTATEY(angle, vx, vy, vz)\
61 tmp1 = vx*cos(angle) + vz*sin(angle);\
62 tmp2 = - vx*sin(angle) + vz*cos(angle);\
66 const double sqrt_6 = 2.44948974278317788;
109 if (fabs(
a) < tol && fabs(b) < tol)
160 XLAL_CHECK(fabs(lnhatx*lnhatx + lnhaty*lnhaty + lnhatz*lnhatz - 1) < 1
e-10,
XLAL_EDOM,
"Lnhat must be a unit vector.\n");
161 XLAL_CHECK(fabs(s1x*s1x + s1y*s1y + s1z*s1z) <= 1.0,
XLAL_EDOM,
"|S1/m1^2| must be <= 1.\n");
162 XLAL_CHECK(fabs(s2x*s2x + s2y*s2y + s2z*s2z) <= 1.0,
XLAL_EDOM,
"|S2/m2^2| must be <= 1.\n");
167 const REAL8 m1_2 = m1*m1;
168 const REAL8 m2_2 = m2*m2;
169 const REAL8 eta = m1 * m2 / (
M*
M);
172 *chi1_l = lnhatx*s1x + lnhaty*s1y + lnhatz*s1z;
173 *chi2_l = lnhatx*s2x + lnhaty*s2y + lnhatz*s2z;
176 const REAL8 S1_perp_x = (s1x - *chi1_l*lnhatx) * m1_2;
177 const REAL8 S1_perp_y = (s1y - *chi1_l*lnhaty) * m1_2;
178 const REAL8 S1_perp_z = (s1z - *chi1_l*lnhatz) * m1_2;
179 const REAL8 S2_perp_x = (s2x - *chi2_l*lnhatx) * m2_2;
180 const REAL8 S2_perp_y = (s2y - *chi2_l*lnhaty) * m2_2;
181 const REAL8 S2_perp_z = (s2z - *chi2_l*lnhatz) * m2_2;
182 const REAL8 S1_perp = sqrt(S1_perp_x*S1_perp_x + S1_perp_y*S1_perp_y + S1_perp_z*S1_perp_z);
183 const REAL8 S2_perp = sqrt(S2_perp_x*S2_perp_x + S2_perp_y*S2_perp_y + S2_perp_z*S2_perp_z);
185 const REAL8 A1 = 2 + (3*m2) / (2*m1);
186 const REAL8 A2 = 2 + (3*m1) / (2*m2);
187 const REAL8 ASp1 = A1*S1_perp;
188 const REAL8 ASp2 = A2*S2_perp;
189 const REAL8 num = (ASp2 > ASp1) ? ASp2 : ASp1;
190 const REAL8 den = (m2 > m1) ? A2*m2_2 : A1*m1_2;
196 const REAL8 v_ref = cbrt(piM * f_ref);
199 switch (IMRPhenomP_version) {
211 const REAL8 Jx0 = L0 * lnhatx + m1_2*s1x + m2_2*s2x;
212 const REAL8 Jy0 = L0 * lnhaty + m1_2*s1y + m2_2*s2y;
213 const REAL8 Jz0 = L0 * lnhatz + m1_2*s1z + m2_2*s2z;
214 const REAL8 J0 = sqrt(Jx0*Jx0 + Jy0*Jy0 + Jz0*Jz0);
221 *thetaJ = acos(Jz0 / J0);
238 const REAL8 rotLx = -lnhatx*cos(*thetaJ)*cos(phiJ) - lnhaty*cos(*thetaJ)*sin(phiJ) + lnhatz*sin(*thetaJ);
239 const REAL8 rotLy = lnhatx*sin(phiJ) - lnhaty*cos(phiJ);
297 XLAL_CHECK(fabs(s1x*s1x + s1y*s1y + s1z*s1z) <= 1.0,
XLAL_EDOM,
"|S1/m1^2| must be <= 1.\n");
298 XLAL_CHECK(fabs(s2x*s2x + s2y*s2y + s2z*s2z) <= 1.0,
XLAL_EDOM,
"|S2/m2^2| must be <= 1.\n");
303 const REAL8 m1_2 = m1*m1;
304 const REAL8 m2_2 = m2*m2;
305 const REAL8 eta = m1 * m2 / (
M*
M);
317 const REAL8 S1_perp = m1_2*sqrt(s1x*s1x + s1y*s1y);
318 const REAL8 S2_perp = m2_2*sqrt(s2x*s2x + s2y*s2y);
320 const REAL8 A1 = 2 + (3*m2) / (2*m1);
321 const REAL8 A2 = 2 + (3*m1) / (2*m2);
322 const REAL8 ASp1 = A1*S1_perp;
323 const REAL8 ASp2 = A2*S2_perp;
324 const REAL8 num = (ASp2 > ASp1) ? ASp2 : ASp1;
325 const REAL8 den = (m2 > m1) ? A2*m2_2 : A1*m1_2;
331 const REAL8 v_ref = cbrt(piM * f_ref);
333 const int ExpansionOrder = 5;
336 switch (IMRPhenomP_version) {
345 if ((s1x == 0. && s1y == 0. && s2x == 0. && s2y == 0.))
347 L0 =
M *
M *
L2PNR(v_ref, eta);
349 L0 =
M *
M *
PhenomInternal_OrbAngMom3PN(f_ref / 2., m1_SI, m2_SI, s1x, s1y, s1z, s2x, s2y, s2z, f_ref, ExpansionOrder);
357 const REAL8 J0x_sf = m1_2*s1x + m2_2*s2x;
358 const REAL8 J0y_sf = m1_2*s1y + m2_2*s2y;
359 const REAL8 J0z_sf = L0 + m1_2*s1z + m2_2*s2z;
360 const REAL8 J0 = sqrt(J0x_sf*J0x_sf + J0y_sf*J0y_sf + J0z_sf*J0z_sf);
368 thetaJ_sf = acos(J0z_sf / J0);
373 phiJ_sf =
LAL_PI/2. - phiRef;
375 phiJ_sf = atan2(J0y_sf, J0x_sf);
377 *phi_aligned = - phiJ_sf;
394 REAL8 Nz_sf = cos(incl);
398 ROTATEZ(-phiJ_sf, tmp_x, tmp_y, tmp_z);
399 ROTATEY(-thetaJ_sf, tmp_x, tmp_y, tmp_z);
407 ROTATEZ(-phiJ_sf, tmp_x, tmp_y, tmp_z);
408 ROTATEY(-thetaJ_sf, tmp_x, tmp_y, tmp_z);
409 ROTATEZ(kappa, tmp_x, tmp_y, tmp_z);
413 *alpha0 = atan2(tmp_y,tmp_x);
419 ROTATEZ(-phiJ_sf, tmp_x, tmp_y, tmp_z);
420 ROTATEY(-thetaJ_sf, tmp_x, tmp_y, tmp_z);
421 ROTATEZ(kappa, tmp_x, tmp_y, tmp_z);
424 *thetaJN = acos(Nz_Jf);
436 REAL8 Xx_sf = -cos(incl)*sin(phiRef);
437 REAL8 Xy_sf = -cos(incl)*cos(phiRef);
438 REAL8 Xz_sf = sin(incl);
442 ROTATEZ(-phiJ_sf, tmp_x, tmp_y, tmp_z);
443 ROTATEY(-thetaJ_sf, tmp_x, tmp_y, tmp_z);
444 ROTATEZ(kappa, tmp_x, tmp_y, tmp_z);
448 REAL8 PArunx_Jf = 0.;
449 REAL8 PAruny_Jf = -1.;
450 REAL8 PArunz_Jf = 0.;
452 REAL8 QArunx_Jf = Nz_Jf;
453 REAL8 QAruny_Jf = 0.;
454 REAL8 QArunz_Jf = -Nx_Jf;
455 REAL8 XdotPArun = tmp_x*PArunx_Jf+tmp_y*PAruny_Jf+tmp_z*PArunz_Jf;
456 REAL8 XdotQArun = tmp_x*QArunx_Jf+tmp_y*QAruny_Jf+tmp_z*QArunz_Jf;
457 *zeta_polariz = atan2(XdotQArun , XdotPArun);
486 const REAL8 distance,
495 LALDict *extraParams)
513 chi1_l, chi2_l, chip, thetaJ, m1_SI, m2_SI, distance, alpha0, phic, f_ref, freqs, deltaF, IMRPhenomP_version, NRTidal_version, extraParams);
544 const REAL8 distance,
550 LALDict *extraParams)
559 chi1_l, chi2_l, chip, thetaJ, m1_SI, m2_SI, distance, alpha0, phic, f_ref, freqs, 0, IMRPhenomP_version, NRTidal_version, extraParams);
578 const REAL8 chi1_l_in,
579 const REAL8 chi2_l_in,
582 const REAL8 m1_SI_in,
583 const REAL8 m2_SI_in,
584 const REAL8 distance,
608 XLAL_CHECK(fabs(chi1_l_in) <= 1.0,
XLAL_EDOM,
"Aligned spin chi1_l=%g must be <= 1 in magnitude!\n", chi1_l_in);
609 XLAL_CHECK(fabs(chi2_l_in) <= 1.0,
XLAL_EDOM,
"Aligned spin chi2_l=%g must be <= 1 in magnitude!\n", chi2_l_in);
610 XLAL_CHECK(fabs(chip) <= 1.0,
XLAL_EDOM,
"In-plane spin chip =%g must be <= 1 in magnitude!\n", chip);
621 gsl_interp_accel *acc_fixed = NULL;
622 gsl_spline *phiI_fixed = NULL;
627 LALDict *extraParams_in = extraParams;
638 REAL8 chi1_l, chi2_l;
640 REAL8 lambda1_in = 0.0;
641 REAL8 lambda2_in = 0.0;
642 REAL8 quadparam1_in = 1.0;
643 REAL8 quadparam2_in = 1.0;
655 REAL8 lambda1, lambda2;
656 REAL8 quadparam1, quadparam2;
658 REAL8 SS_3p5PN = 0., SSS_3p5PN = 0.;
659 REAL8 SS_3p5PN_n = 0., SSS_3p5PN_n = 0.;
661 if (m2_SI_in >= m1_SI_in) {
666 lambda1 = lambda1_in;
667 lambda2 = lambda2_in;
668 quadparam1 = quadparam1_in;
669 quadparam2 = quadparam2_in;
676 lambda1 = lambda2_in;
677 lambda2 = lambda1_in;
678 quadparam1 = quadparam2_in;
679 quadparam2 = quadparam1_in;
703 REAL8 pn_fac = 3.*pow(piM,2./3.)/(128.*eta);
710 const REAL8 chi_eff = (m1*chi1_l + m2*chi2_l) /
M;
711 const REAL8 chil = (1.0+
q)/
q * chi_eff;
713 switch (IMRPhenomP_version) {
717 XLAL_ERROR(
XLAL_EDOM,
"IMRPhenomP(v1): Mass ratio is way outside the calibration range. m1/m2 should be <= 20.\n");
719 XLAL_PRINT_WARNING(
"IMRPhenomP(v1): Warning: The model is only calibrated for m1/m2 <= 4.\n");
722 if (chi_eff > 0.9 || chi_eff < -0.9)
723 XLAL_ERROR(
XLAL_EDOM,
"IMRPhenomP(v1): Effective spin chi_eff = %g outside the range [-0.9,0.9] is not supported!\n", chi_eff);
728 XLAL_PRINT_WARNING(
"IMRPhenomPv2: Warning: The underlying non-precessing model is calibrated up to m1/m2 <= 18.\n");
730 XLAL_ERROR(
XLAL_EDOM,
"IMRPhenomPv2: Mass ratio q > 100 which is way outside the calibration range q <= 18.\n");
731 if ((
q < 1.5) && (lambda1 > 2000.0) && (lambda2 > 2000.0))
732 XLAL_PRINT_WARNING(
"NRTidal: Warning: Entering region of parameter space where waveform might not be reliable; q=%g,lambda1=%g, lambda2=%g\n",
q, lambda1, lambda2);
740 if (eta > 0.25 ||
q < 1.0) {
749 const REAL8 omega_ref = piM * f_ref;
750 const REAL8 logomega_ref = log(omega_ref);
751 const REAL8 omega_ref_cbrt = cbrt(piM * f_ref);
752 const REAL8 omega_ref_cbrt2 = omega_ref_cbrt*omega_ref_cbrt;
767 const REAL8 ytheta = thetaJ;
768 const REAL8 yphi = 0;
780 switch (IMRPhenomP_version) {
789 fCut = PCparams->
fCut;
798 if( fabs(finspin) > 1.0 ) {
799 XLAL_PRINT_WARNING(
"Warning: final spin magnitude %g > 1. Setting final spin magnitude = 1.", finspin);
800 finspin = copysign(1.0, finspin);
807 if (extraParams==NULL)
823 if (!pAmp || !pPhi || !
pn) {
839 fCut =
f_CUT / m_sec;
840 f_final = pAmp->
fRD / m_sec;
843 XLALPrintError(
"XLAL Error - %s: Unknown IMRPhenomP version!\nAt present only v1 and v2 are available.\n", __func__);
853 f_max_prime = (f_max_prime > fCut) ? fCut : f_max_prime;
854 if (f_max_prime <=
f_min){
867 if (f_max_prime <
f_max)
870 n =
NextPow2(f_max_prime / deltaF) + 1;
874 "Failed to shift coalescence time by -1.0/deltaF with deltaF=%g.", deltaF);
888 size_t i_min = (size_t) (
f_min / deltaF);
889 size_t i_max = (size_t) (f_max_prime / deltaF);
893 XLALPrintError(
"XLAL Error - %s: Frequency array allocation failed.", __func__);
897 freqs->
data[
i-i_min] =
i*deltaF;
905 XLALPrintError(
"XLAL Error - %s: Failed to allocate frequency series for hptilde polarization with f_min=%f and %tu bins.", __func__,
f_min, n);
911 XLALPrintError(
"XLAL Error - %s: Failed to allocate frequency series for hctilde polarization with f_min=%f and %tu bins.", __func__,
f_min, n);
921 if (!(freqs_in->
data[
i] > freqs_in->
data[
i-1]))
923 XLALPrintError(
"XLAL Error - %s: Frequency sequence must be strictly increasing!\n", __func__);
931 XLALPrintError(
"XLAL Error - %s: Frequency array allocation failed.", __func__);
937 if (freqs_in->
data[
i] <= fCut) {
944 memset((*hptilde)->data->data, 0, n *
sizeof(
COMPLEX16));
945 memset((*hctilde)->data->data, 0, n *
sizeof(
COMPLEX16));
990 #pragma omp parallel for
996 double f = freqs->
data[
i];
999 int per_thread_errcode=0;
1001 #pragma omp flush(errcode)
1008 double window = planck_taper->
data[
i];
1012 &hPhenom, &phasing, &_prefactors, &phi_prefactors);
1015 double ampTidal = amp_tidal->
data[
i];
1016 double window = planck_taper->
data[
i];
1022 REAL8 phaseTidal = phi_tidal->
data[
i] + pn_fac*(SS_3p5PN + SSS_3p5PN)*pow(f,2./3.);
1026 &hPhenom, &phasing, &_prefactors, &phi_prefactors);
1030 pAmp, pPhi, PCparams,
pn,
1031 &hPhenom, &phasing, IMRPhenomP_version, &_prefactors, &phi_prefactors);
1035 errcode = per_thread_errcode;
1040 alphaNNLOoffset - alpha0, epsilonNNLOoffset,
1041 &hp_val, &hc_val, IMRPhenomP_version);
1044 errcode = per_thread_errcode;
1045 #pragma omp flush(errcode)
1048 ((*hptilde)->data->data)[j] = hp_val;
1049 ((*hctilde)->data->data)[j] = hc_val;
1060 const int n_fixed = 10;
1075 REAL8 freqs_fixed_start = 0.8*f_final;
1076 REAL8 freqs_fixed_stop = 1.2*f_final;
1077 if (freqs_fixed_stop > fCut)
1078 freqs_fixed_stop = fCut;
1079 REAL8 delta_freqs_fixed = (freqs_fixed_stop - freqs_fixed_start) / (n_fixed - 1);
1080 for (
int i=0;
i < n_fixed;
i++)
1081 freqs_fixed->
data[
i] = freqs_fixed_start +
i*delta_freqs_fixed;
1091 freqs_fixed, m1_SI, m2_SI, lambda1, lambda2, NRTidal_version);
1098 for (
int i=0;
i<n_fixed;
i++) {
1101 double f = freqs_fixed->
data[
i];
1102 int per_thread_errcode = 0;
1111 double window = planck_taper_fixed->
data[
i];
1115 &hPhenom, &phasing, &_prefactors, &phi_prefactors);
1118 double ampTidal = amp_tidal_fixed->
data[
i];
1119 double window = planck_taper_fixed->
data[
i];
1120 REAL8 phaseTidal = phi_tidal_fixed->
data[
i] + pn_fac*(SS_3p5PN_n + SSS_3p5PN_n)*pow(f,2./3.);
1123 &hPhenom, &phasing, &_prefactors, &phi_prefactors);
1128 pAmp, pPhi, PCparams,
pn,
1129 &hPhenom, &phasing, IMRPhenomP_version, &_prefactors, &phi_prefactors);
1133 errcode = per_thread_errcode;
1136 phase_fixed->
data[
i] = phasing;
1145 acc_fixed = gsl_interp_accel_alloc();
1146 phiI_fixed = gsl_spline_alloc(gsl_interp_cspline, n_fixed);
1147 XLAL_CHECK(phiI_fixed,
XLAL_ENOMEM,
"Failed to allocate GSL spline with %d points for phase.", n_fixed);
1148 REAL8 t_corr_fixed = 0.0;
1149 gsl_spline_init(phiI_fixed, freqs_fixed->
data, phase_fixed->
data, n_fixed);
1151 t_corr_fixed = gsl_spline_eval_deriv(phiI_fixed, f_final, acc_fixed) / (2*
LAL_PI);
1156 double f = freqs->
data[
i];
1159 ((*hptilde)->data->data)[j] *= phase_corr;
1160 ((*hctilde)->data->data)[j] *= phase_corr;
1167 if (phiI_fixed) gsl_spline_free(phiI_fixed);
1168 if (acc_fixed) gsl_interp_accel_free(acc_fixed);
1267 const REAL8 distance,
1286 REAL8 aPhenom = 0.0;
1287 REAL8 phPhenom = 0.0;
1292 switch (IMRPhenomP_version) {
1306 phPhenom =
IMRPhenDPhase(f, pPhi, PNparams, &powers_of_f, phi_prefactors, 1.0, 1.0);
1309 XLAL_ERROR(
XLAL_EINVAL,
"Only v1 and v2 are valid IMRPhenomP versions here! The tidal version of IMRPhenomPv2 uses a separate internal function function to generate polarizations and phasing." );
1316 phPhenom -= 2.*phic;
1318 *hPhenom = amp0 * aPhenom * (cos(phPhenom) - I*sin(phPhenom));
1321 *phasing = -phPhenom;
1329 const REAL8 phaseTidal,
1330 const REAL8 ampTidal,
1331 const REAL8 distance,
1349 REAL8 aPhenom = 0.0;
1350 REAL8 phPhenom = 0.0;
1363 phPhenom =
IMRPhenDPhase(f, pPhi, PNparams, &powers_of_f, phi_prefactors, 1.0, 1.0);
1365 phPhenom -= 2.*phic;
1367 *hPhenom = amp0 * (aPhenom + 2*sqrt(
LAL_PI/5.) * ampTidal) * cexp(-I*(phPhenom+phaseTidal)) * window;
1370 phPhenom += phaseTidal;
1371 *phasing = -phPhenom;
1386 const REAL8 alphaoffset,
1387 const REAL8 epsilonoffset,
1401 const REAL8 q = (1.0 + sqrt(1.0 - 4.0*eta) - 2.0*eta)/(2.0*eta);
1402 const REAL8 m1 = 1.0/(1.0+
q);
1404 const REAL8 Sperp = chip*(m2*m2);
1406 const REAL8 chi_eff = (m1*chi1_l + m2*chi2_l);
1409 switch (IMRPhenomP_version) {
1415 SL = chi1_l*m1*m1 + chi2_l*m2*m2;
1417 XLAL_ERROR(
XLAL_EINVAL,
"Unknown IMRPhenomP version!\nAt present only v1 and v2 and tidal are available." );
1423 const REAL8 logomega = log(omega);
1424 const REAL8 omega_cbrt = cbrt(omega);
1425 const REAL8 omega_cbrt2 = omega_cbrt*omega_cbrt;
1431 + angcoeffs->
alphacoeff5*omega_cbrt) - alphaoffset;
1440 REAL8 cBetah, sBetah;
1441 switch (IMRPhenomP_version) {
1450 XLAL_ERROR(
XLAL_EINVAL,
" Unknown IMRPhenomP version!\nAt present only v1 and v2 and tidal are available." );
1454 const REAL8 cBetah2 = cBetah*cBetah;
1455 const REAL8 cBetah3 = cBetah2*cBetah;
1456 const REAL8 cBetah4 = cBetah3*cBetah;
1457 const REAL8 sBetah2 = sBetah*sBetah;
1458 const REAL8 sBetah3 = sBetah2*sBetah;
1459 const REAL8 sBetah4 = sBetah3*sBetah;
1466 COMPLEX16 d2[5] = {sBetah4, 2*cBetah*sBetah3,
sqrt_6*sBetah2*cBetah2, 2*cBetah3*sBetah, cBetah4};
1467 COMPLEX16 dm2[5] = {d2[4], -d2[3], d2[2], -d2[1], d2[0]};
1476 COMPLEX16 cexp_2i_alpha = cexp_i_alpha*cexp_i_alpha;
1477 COMPLEX16 cexp_mi_alpha = 1.0/cexp_i_alpha;
1478 COMPLEX16 cexp_m2i_alpha = cexp_mi_alpha*cexp_mi_alpha;
1479 COMPLEX16 cexp_im_alpha[5] = {cexp_m2i_alpha, cexp_mi_alpha, 1.0, cexp_i_alpha, cexp_2i_alpha};
1480 for(
int m=-2;
m<=2;
m++) {
1481 COMPLEX16 T2m = cexp_im_alpha[-
m+2] * dm2[
m+2] * Y2mA[
m+2];
1482 COMPLEX16 Tm2m = cexp_im_alpha[
m+2] * d2[
m+2] * conj(Y2mA[
m+2]);
1483 hp_sum += T2m + Tm2m;
1484 hc_sum += +I*(T2m - Tm2m);
1487 COMPLEX16 eps_phase_hP = cexp(-2*I*epsilon) * hPhenom / 2.0;
1488 *hp = eps_phase_hP * hp_sum;
1489 *hc = eps_phase_hP * hc_sum;
1506 const REAL8 m1 = 1./(1. +
q);
1507 const REAL8 dm = m1 - m2;
1508 const REAL8 mtot = 1.;
1509 const REAL8 eta = m1*m2;
1510 const REAL8 eta2 = eta*eta;
1511 const REAL8 eta3 = eta2*eta;
1512 const REAL8 eta4 = eta3*eta;
1513 const REAL8 mtot2 = mtot*mtot;
1514 const REAL8 mtot4 = mtot2*mtot2;
1515 const REAL8 mtot6 = mtot4*mtot2;
1516 const REAL8 mtot8 = mtot6*mtot2;
1517 const REAL8 chil2 = chil*chil;
1518 const REAL8 chip2 = chip*chip;
1519 const REAL8 chip4 = chip2*chip2;
1520 const REAL8 dm2 = dm*dm;
1521 const REAL8 dm3 = dm2*dm;
1522 const REAL8 m2_2 = m2*m2;
1523 const REAL8 m2_3 = m2_2*m2;
1524 const REAL8 m2_4 = m2_3*m2;
1525 const REAL8 m2_5 = m2_4*m2;
1526 const REAL8 m2_6 = m2_5*m2;
1527 const REAL8 m2_7 = m2_6*m2;
1528 const REAL8 m2_8 = m2_7*m2;
1532 angcoeffs->
alphacoeff1 = (-0.18229166666666666 - (5*dm)/(64.*m2));
1534 angcoeffs->
alphacoeff2 = ((-15*dm*m2*chil)/(128.*mtot2*eta) - (35*m2_2*chil)/(128.*mtot2*eta));
1536 angcoeffs->
alphacoeff3 = (-1.7952473958333333 - (4555*dm)/(7168.*m2) -
1537 (15*chip2*dm*m2_3)/(128.*mtot4*eta2) -
1538 (35*chip2*m2_4)/(128.*mtot4*eta2) - (515*eta)/384. - (15*dm2*eta)/(256.*m2_2) -
1539 (175*dm*eta)/(256.*m2));
1542 (5*dm2*chil)/(16.*mtot2) + (5*dm*m2*chil)/(3.*mtot2) +
1543 (2545*m2_2*chil)/(1152.*mtot2) -
1544 (5*chip2*dm*m2_5*chil)/(128.*mtot6*eta3) -
1545 (35*chip2*m2_6*chil)/(384.*mtot6*eta3) + (2035*dm*m2*chil)/(21504.*mtot2*eta) +
1546 (2995*m2_2*chil)/(9216.*mtot2*eta);
1548 angcoeffs->
alphacoeff5 = (4.318908476114694 + (27895885*dm)/(2.1676032e7*m2) -
1549 (15*chip4*dm*m2_7)/(512.*mtot8*eta4) -
1550 (35*chip4*m2_8)/(512.*mtot8*eta4) -
1551 (485*chip2*dm*m2_3)/(14336.*mtot4*eta2) +
1552 (475*chip2*m2_4)/(6144.*mtot4*eta2) +
1553 (15*chip2*dm2*m2_2)/(256.*mtot4*eta) + (145*chip2*dm*m2_3)/(512.*mtot4*eta) +
1554 (575*chip2*m2_4)/(1536.*mtot4*eta) + (39695*eta)/86016. + (1615*dm2*eta)/(28672.*m2_2) -
1555 (265*dm*eta)/(14336.*m2) + (955*eta2)/576. + (15*dm3*eta2)/(1024.*m2_3) +
1556 (35*dm2*eta2)/(256.*m2_2) + (2725*dm*eta2)/(3072.*m2) - (15*dm*m2*
LAL_PI*chil)/(16.*mtot2*eta) -
1557 (35*m2_2*
LAL_PI*chil)/(16.*mtot2*eta) + (15*chip2*dm*m2_7*chil2)/(128.*mtot8*eta4) +
1558 (35*chip2*m2_8*chil2)/(128.*mtot8*eta4) +
1559 (375*dm2*m2_2*chil2)/(256.*mtot4*eta) + (1815*dm*m2_3*chil2)/(256.*mtot4*eta) +
1560 (1645*m2_4*chil2)/(192.*mtot4*eta));
1562 angcoeffs->
epsiloncoeff1 = (-0.18229166666666666 - (5*dm)/(64.*m2));
1564 angcoeffs->
epsiloncoeff2 = ((-15*dm*m2*chil)/(128.*mtot2*eta) - (35*m2_2*chil)/(128.*mtot2*eta));
1566 angcoeffs->
epsiloncoeff3 = (-1.7952473958333333 - (4555*dm)/(7168.*m2) - (515*eta)/384. -
1567 (15*dm2*eta)/(256.*m2_2) - (175*dm*eta)/(256.*m2));
1570 (5*dm2*chil)/(16.*mtot2) + (5*dm*m2*chil)/(3.*mtot2) +
1571 (2545*m2_2*chil)/(1152.*mtot2) + (2035*dm*m2*chil)/(21504.*mtot2*eta) +
1572 (2995*m2_2*chil)/(9216.*mtot2*eta);
1574 angcoeffs->
epsiloncoeff5 = (4.318908476114694 + (27895885*dm)/(2.1676032e7*m2) + (39695*eta)/86016. +
1575 (1615*dm2*eta)/(28672.*m2_2) - (265*dm*eta)/(14336.*m2) + (955*eta2)/576. +
1576 (15*dm3*eta2)/(1024.*m2_3) + (35*dm2*eta2)/(256.*m2_2) +
1577 (2725*dm*eta2)/(3072.*m2) - (15*dm*m2*
LAL_PI*chil)/(16.*mtot2*eta) - (35*m2_2*
LAL_PI*chil)/(16.*mtot2*eta) +
1578 (375*dm2*m2_2*chil2)/(256.*mtot4*eta) + (1815*dm*m2_3*chil2)/(256.*mtot4*eta) +
1579 (1645*m2_4*chil2)/(192.*mtot4*eta));
1594 const REAL8 eta2 = eta*eta;
1597 return (eta*(1.0 + (1.5 + eta/6.0)*
x + (3.375 - (19.0*eta)/8. - eta2/24.0)*x2)) / sqrt(
x);
1613 const REAL8 v2 = v*v;
1614 const REAL8 v3 = v2*v;
1615 const REAL8 v4 = v3*v;
1616 const REAL8 eta2 = eta*eta;
1617 const REAL8 b = (4.75 + eta/9.)*eta*v4;
1620 return mu*sqrt((1 - ((3 - eta)*v2)/3. + b)/v2)*
1621 (1 + ((1 - 3*eta)*v2)/2. + (3*(1 - 7*eta + 13*eta2)*v4)/8. +
1622 ((14 - 41*eta + 4*eta2)*v4)/(4.*
pow_2_of(1 - ((3 - eta)*v2)/3. + b)) +
1623 ((3 + eta)*v2)/(1 - ((3 - eta)*v2)/3. + b) +
1624 ((7 - 10*eta - 9*eta2)*v4)/(2.*(1 - ((3 - eta)*v2)/3. + b)));
1638 REAL8 *cos_beta_half,
1639 REAL8 *sin_beta_half,
1652 REAL8 cos_beta = 1.0 / sqrt(1.0 + s2);
1653 *cos_beta_half = + sqrt( (1.0 + cos_beta) / 2.0 );
1654 *sin_beta_half = + sqrt( (1.0 - cos_beta) / 2.0 );
1671 REAL8 *cos_beta_half,
1672 REAL8 *sin_beta_half,
1682 *cos_beta_half = 1.0/sqrt(1.0 + s2/4.0);
1683 *sin_beta_half = sqrt(1.0 - 1.0/(1.0 + s2/4.0));
1698 REAL8 m1_normalized = m1/
M;
1699 REAL8 m2_normalized = m2/
M;
1700 REAL8 eta = m1_normalized*m2_normalized;
1701 REAL8 v_at_max_beta = sqrt( 2*(9. + eta - sqrt(1539 - 1008*eta - 17*eta*eta)) / 3. / (eta*eta + 57.*eta - 81.) );
1703 REAL8 SL = m1_normalized*m1_normalized*chi1_l + m2_normalized*m2_normalized*chi2_l;
1704 REAL8 Sperp = m2_normalized*m2_normalized * chip;
1705 REAL8 cBetah, sBetah;
1708 REAL8 max_beta = 2*acos(cBetah);
1714 if (L_min + SL < 0. && chip > 0.)
1715 XLAL_PRINT_WARNING(
"The maximum opening angle exceeds Pi/2.\nThe model may be pathological in this regime.");
1717 XLAL_PRINT_WARNING(
"The maximum opening angle %g is larger than Pi/4.\nThe model has not been tested against NR in this regime.", max_beta);
1738 if (eta > 0.25)
nudge(&eta, 0.25, 1
e-6);
1740 REAL8 af_parallel, q_factor;
1750 REAL8 Sperp = chip * q_factor*q_factor;
1751 REAL8 af = copysign(1.0, af_parallel) * sqrt(Sperp*Sperp + af_parallel*af_parallel);
1771 const REAL8 a1_x = chip;
1772 const REAL8 a1_y = 0;
1773 const REAL8 a1_z = chi;
1774 const REAL8 a2_x = 0;
1775 const REAL8 a2_y = 0;
1776 const REAL8 a2_z = 0;
1778 const REAL8 a1 = sqrt(a1_x*a1_x + a1_y*a1_y + a1_z*a1_z);
1779 const REAL8 a2 = sqrt(a2_x*a2_x + a2_y*a2_y + a2_z*a2_z);
1781 const REAL8 cos_alpha = (a1*
a2 == 0) ? 0.0 : a1_z*a2_z/(a1*
a2);
1782 const REAL8 cos_beta_tilde = (a1 == 0) ? 0.0 : a1_z/a1;
1783 const REAL8 cos_gamma_tilde = (
a2 == 0) ? 0.0 : a2_z/
a2;
1799 const REAL8 cos_alpha,
1800 const REAL8 cos_beta_tilde,
1801 const REAL8 cos_gamma_tilde)
1803 REAL8 q = (2*nu)/(1 + sqrt(1 - 4*nu) - 2*nu);
1806 const REAL8 s4 = -0.1229;
1807 const REAL8 s5 = 0.4537;
1808 const REAL8 t0 = -2.8904;
1809 const REAL8 t2 = -3.5171;
1810 const REAL8 t3 = 2.5763;
1813 const REAL8 nu2 = nu*nu;
1817 const REAL8 q2p2 = q2p*q2p;
1819 const REAL8 qp2 = qp*qp;
1820 const REAL8 a1_2 = a1*a1;
1824 const REAL8 l = 2*sqrt(3.0) + t2*nu + t3*nu2
1825 + (s4 / q2p2) * (a1_2 + a2_2*
q4 + 2*a1*
a2*
q2*cos_alpha)
1826 + ((s5*nu + t0 + 2)/q2p) * (a1*cos_beta_tilde +
a2*cos_gamma_tilde*
q2);
1830 const REAL8 a_fin = (1.0 / qp2) * sqrt(a1_2 + a2_2*
q4 + 2*a1*
a2*
q2*cos_alpha + 2*(a1*cos_beta_tilde +
a2*
q2*cos_gamma_tilde)*
l*
q + l2*
q2);
1846 LALDict *extraParams)
1855 const REAL8 eta = m1 * m2 / (
M *
M);
1858 if( fabs(finspin) > 1.0 ) {
1859 XLAL_PRINT_WARNING(
"Warning: final spin magnitude %g > 1. Setting final spin magnitude = 1.", finspin);
1860 finspin = copysign(1.0, finspin);
1871 p->fRingDown = (prefac * (
k1 +
k2 * pow(1. - fabs(finspin),
k3)));
1872 p->MfRingDown =
p->m_sec *
p->fRingDown;
1875 p->Qual = (0.7000 + (1.4187 * pow(1.0 - fabs(finspin), -0.4990)) );
1879 p->f1 = 0.1 *
p->fRingDown;
1880 p->f2 =
p->fRingDown;
1881 p->f0 = 0.98 *
p->fRingDown;
1887 REAL8 Mfrd =
p->MfRingDown;
1889 p->b2 = ((-5./3.)*
p->a1 * pow(Mfrd,(-8./3.)) -
p->a2/(Mfrd*Mfrd) -
1890 (
p->a3/3.)*pow(Mfrd,(-4./3.)) + (2./3.)*
p->a5 * pow(Mfrd,(-1./3.)) +
p->a6)/eta;
1894 p->b1 = psiPMrd - (
p->b2 * Mfrd);
1898 p->fCut = 0.15 /
p->m_sec;
1907 return !gsl_fcmp(
x,
y, epsilon);
1920 if (fabs(*
x - X) < epsilon)
void XLALDestroyDict(LALDict *dict)
LALDict * XLALCreateDict(void)
void XLALSimInspiralGetHOSpinTerms(REAL8 *SS_3p5PN, REAL8 *SSS_3p5PN, REAL8 X_A, REAL8 X_B, REAL8 chi1, REAL8 chi2, REAL8 quadparam1, REAL8 quadparam2)
Function to add 3.5PN spin-squared and 3.5PN spin-cubed terms.
int XLALSimNRTunedTidesFDTidalPhaseFrequencySeries(const REAL8Sequence *phi_tidal, const REAL8Sequence *amp_tidal, const REAL8Sequence *planck_taper, const REAL8Sequence *fHz, REAL8 m1_SI, REAL8 m2_SI, REAL8 lambda1, REAL8 lambda2, NRTidal_version_type NRTidal_version)
Function to call the frequency domain tidal correction over an array of input frequencies.
double XLALSimNRTunedTidesMergerFrequency(const REAL8 mtot_MSUN, const REAL8 kappa2T, const REAL8 q)
compute the merger frequency of a BNS system.
double XLALSimNRTunedTidesComputeKappa2T(REAL8 m1_SI, REAL8 m2_SI, REAL8 lambda1, REAL8 lambda2)
convenient function to compute tidal coupling constant.
static size_t NextPow2(const size_t n)
static int IMRPhenomCGenerateAmpPhase(REAL8 *amplitude, REAL8 *phasing, REAL8 f, REAL8 eta, const BBHPhenomCParams *params)
static REAL8 IMRPhenomCGeneratePhasePM(REAL8 f, REAL8 eta, const BBHPhenomCParams *params)
main functions
static BBHPhenomCParams * ComputeIMRPhenomCParams(const REAL8 m1, const REAL8 m2, const REAL8 chi, LALDict *extraParams)
UsefulPowers powers_of_pi
useful powers of LAL_PI, calculated once and kept constant - to be initied with a call to init_useful...
#define f_CUT
Dimensionless frequency (Mf) at which define the end of the waveform.
Internal function for IMRPhenomD phenomenological waveform model. See LALSimIMRPhenom....
static void ComputeIMRPhenDPhaseConnectionCoefficients(IMRPhenomDPhaseCoefficients *p, PNPhasingSeries *pn, PhiInsPrefactors *prefactors, double Rholm, double Taulm)
This function aligns the three phase parts (inspiral, intermediate and merger-rindown) such that they...
static double IMRPhenDPhase(double f, IMRPhenomDPhaseCoefficients *p, PNPhasingSeries *pn, UsefulPowers *powers_of_f, PhiInsPrefactors *prefactors, double Rholm, double Taulm)
This function computes the IMR phase given phenom coefficients.
static int init_phi_ins_prefactors(PhiInsPrefactors *prefactors, IMRPhenomDPhaseCoefficients *p, PNPhasingSeries *pn)
static double FinalSpin0815(double eta, double chi1, double chi2)
Wrapper function for FinalSpin0815_s.
static void ComputeIMRPhenomDPhaseCoefficients(IMRPhenomDPhaseCoefficients *p, double eta, double chi1, double chi2, double finspin, LALDict *extraParams)
A struct containing all the parameters that need to be calculated to compute the phenomenological pha...
static void ComputeIMRPhenomDAmplitudeCoefficients(IMRPhenomDAmplitudeCoefficients *p, double eta, double chi1, double chi2, double finspin)
A struct containing all the parameters that need to be calculated to compute the phenomenological amp...
static double Subtract3PNSS(double m1, double m2, double M, double eta, double chi1, double chi2)
Subtract 3PN spin-spin term below as this is in LAL's TaylorF2 implementation (LALSimInspiralPNCoeffi...
static double IMRPhenDAmplitude(double f, IMRPhenomDAmplitudeCoefficients *p, UsefulPowers *powers_of_f, AmpInsPrefactors *prefactors)
This function computes the IMR amplitude given phenom coefficients.
static int init_amp_ins_prefactors(AmpInsPrefactors *prefactors, IMRPhenomDAmplitudeCoefficients *p)
static int init_useful_powers(UsefulPowers *p, REAL8 number)
static double pow_2_of(double number)
calc square of number without floating point 'pow'
double PhenomInternal_OrbAngMom3PN(const double f_orb_hz, const double m1, const double m2, const double s1x, const double s1y, const double s1z, const double s2x, const double s2y, const double s2z, const double f_0, const int ExpansionOrder)
Wrapper function for XLALOrbitalAngMom3PNSpinning.
static void ComputeNNLOanglecoeffs(NNLOanglecoeffs *angcoeffs, const REAL8 q, const REAL8 chil, const REAL8 chip)
Next-to-next-to-leading order PN coefficients for Euler angles and .
static int PhenomPCore(COMPLEX16FrequencySeries **hptilde, COMPLEX16FrequencySeries **hctilde, const REAL8 chi1_l_in, const REAL8 chi2_l_in, const REAL8 chip, const REAL8 thetaJ, const REAL8 m1_SI_in, const REAL8 m2_SI_in, const REAL8 distance, const REAL8 alpha0, const REAL8 phic, const REAL8 f_ref, const REAL8Sequence *freqs_in, double deltaF, IMRPhenomP_version_type IMRPhenomP_version, NRTidal_version_type NRTidal_version, LALDict *extraParams)
Internal core function to calculate plus and cross polarizations of the PhenomP model for a set of fr...
#define ROTATEZ(angle, vx, vy, vz)
static void nudge(REAL8 *x, REAL8 X, REAL8 epsilon)
static void WignerdCoefficients(REAL8 *cos_beta_half, REAL8 *sin_beta_half, const REAL8 v, const REAL8 SL, const REAL8 eta, const REAL8 Sp)
Expressions used for the WignerD symbol with full expressions for the angles.
static void CheckMaxOpeningAngle(const REAL8 m1, const REAL8 m2, const REAL8 chi1_l, const REAL8 chi2_l, const REAL8 chip)
In this helper function we check whether the maximum opening angle during the evolution becomes large...
static int PhenomPCoreTwistUp(const REAL8 fHz, COMPLEX16 hPhenom, const REAL8 eta, const REAL8 chi1_l, const REAL8 chi2_l, const REAL8 chip, const REAL8 M, NNLOanglecoeffs *angcoeffs, SpinWeightedSphericalHarmonic_l2 *Y2m, const REAL8 alphaoffset, const REAL8 epsilonoffset, COMPLEX16 *hp, COMPLEX16 *hc, IMRPhenomP_version_type IMRPhenomP_version)
static int PhenomPCoreOneFrequency(const REAL8 fHz, const REAL8 eta, const REAL8 distance, const REAL8 M, const REAL8 phic, IMRPhenomDAmplitudeCoefficients *pAmp, IMRPhenomDPhaseCoefficients *pPhi, BBHPhenomCParams *PCparams, PNPhasingSeries *PNparams, COMPLEX16 *hPhenom, REAL8 *phasing, IMRPhenomP_version_type IMRPhenomP_version, AmpInsPrefactors *amp_prefactors, PhiInsPrefactors *phi_prefactors)
static REAL8 L2PNR_v1(const REAL8 v, const REAL8 eta)
Simple 2PN version of the orbital angular momentum L, without any spin terms expressed as a function ...
static UNUSED BBHPhenomCParams * ComputeIMRPhenomCParamsRDmod(const REAL8 m1, const REAL8 m2, const REAL8 chi, const REAL8 chip, LALDict *extraParams)
PhenomC parameters for modified ringdown, uses final spin formula of:
static REAL8 FinalSpinBarausse2009(const REAL8 nu, const REAL8 a1, const REAL8 a2, const REAL8 cos_alpha, const REAL8 cos_beta_tilde, const REAL8 cos_gamma_tilde)
Final-spin formula based on:
static REAL8 L2PNR(const REAL8 v, const REAL8 eta)
Simple 2PN version of the orbital angular momentum L, without any spin terms expressed as a function ...
static REAL8 FinalSpinBarausse2009_all_spin_on_larger_BH(const REAL8 nu, const REAL8 chi, const REAL8 chip)
Wrapper for final-spin formula based on:
static REAL8 FinalSpinIMRPhenomD_all_in_plane_spin_on_larger_BH(const REAL8 m1, const REAL8 m2, const REAL8 chi1_l, const REAL8 chi2_l, const REAL8 chip)
Wrapper for final-spin formula based on:
#define ROTATEY(angle, vx, vy, vz)
static void WignerdCoefficients_SmallAngleApproximation(REAL8 *cos_beta_half, REAL8 *sin_beta_half, const REAL8 v, const REAL8 SL, const REAL8 eta, const REAL8 Sp)
Expressions used for the WignerD symbol with small angle approximation.
static int PhenomPCoreOneFrequency_withTides(const REAL8 fHz, const REAL8 window, const REAL8 phaseTidal, const REAL8 ampTidal, const REAL8 distance, const REAL8 M, const REAL8 phic, IMRPhenomDAmplitudeCoefficients *pAmp, IMRPhenomDPhaseCoefficients *pPhi, PNPhasingSeries *PNparams, COMPLEX16 *hPhenom, REAL8 *phasing, AmpInsPrefactors *amp_prefactors, PhiInsPrefactors *phi_prefactors)
static bool approximately_equal(REAL8 x, REAL8 y, REAL8 epsilon)
#define MAX_TOL_ATAN
Tolerance used below which numbers are treated as zero for the calculation of atan2.
int XLALSimInspiralSetQuadMonParamsFromLambdas(LALDict *LALparams)
if you do NOT provide a quadparam[1,2] term and you DO provide lamdba[1,2] then we calculate quad-mon...
static REAL8 UNUSED q2(REAL8 e0, REAL8 f0, REAL8 inc, REAL8 bet, REAL8 FPlus, REAL8 FCross)
static REAL8 UNUSED q4(REAL8 e0, REAL8 f0, REAL8 inc, REAL8 bet, REAL8 FPlus, REAL8 FCross)
COMPLEX16FrequencySeries * XLALCreateCOMPLEX16FrequencySeries(const CHAR *name, const LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits, size_t length)
void XLALDestroyCOMPLEX16FrequencySeries(COMPLEX16FrequencySeries *series)
void * XLALMalloc(size_t n)
@ IMRPhenomPv3_V
version 3: based on IMRPhenomD and the precession angles from Katerina Chatziioannou PhysRevD....
@ IMRPhenomPv1_V
version 1: based on IMRPhenomC
@ IMRPhenomPv2_V
version 2: based on IMRPhenomD
@ IMRPhenomPv2NRTidal_V
version Pv2_NRTidal: based on IMRPhenomPv2; NRTides added before precession; can be used with both NR...
@ NRTidal_V
version NRTidal: based on https://arxiv.org/pdf/1706.02969.pdf
@ NRTidalv2_V
version NRTidalv2: https://arxiv.org/abs/1905.06011
static REAL8 atan2tol(REAL8 a, REAL8 b, REAL8 tol)
int XLALSimIMRPhenomP(COMPLEX16FrequencySeries **hptilde, COMPLEX16FrequencySeries **hctilde, const REAL8 chi1_l, const REAL8 chi2_l, const REAL8 chip, const REAL8 thetaJ, const REAL8 m1_SI, const REAL8 m2_SI, const REAL8 distance, const REAL8 alpha0, const REAL8 phic, const REAL8 deltaF, const REAL8 f_min, const REAL8 f_max, const REAL8 f_ref, IMRPhenomP_version_type IMRPhenomP_version, NRTidal_version_type NRTidal_version, LALDict *extraParams)
Driver routine to compute the precessing inspiral-merger-ringdown phenomenological waveform IMRPhenom...
int XLALSimIMRPhenomPCalculateModelParametersFromSourceFrame(REAL8 *chi1_l, REAL8 *chi2_l, REAL8 *chip, REAL8 *thetaJN, REAL8 *alpha0, REAL8 *phi_aligned, REAL8 *zeta_polariz, const REAL8 m1_SI, const REAL8 m2_SI, const REAL8 f_ref, const REAL8 phiRef, const REAL8 incl, const REAL8 s1x, const REAL8 s1y, const REAL8 s1z, const REAL8 s2x, const REAL8 s2y, const REAL8 s2z, IMRPhenomP_version_type IMRPhenomP_version)
Function to map LAL parameters (masses, 6 spin components, phiRef and inclination at f_ref) (assumed ...
int XLALSimIMRPhenomPCalculateModelParametersOld(REAL8 *chi1_l, REAL8 *chi2_l, REAL8 *chip, REAL8 *thetaJ, REAL8 *alpha0, const REAL8 m1_SI, const REAL8 m2_SI, const REAL8 f_ref, const REAL8 lnhatx, const REAL8 lnhaty, const REAL8 lnhatz, const REAL8 s1x, const REAL8 s1y, const REAL8 s1z, const REAL8 s2x, const REAL8 s2y, const REAL8 s2z, IMRPhenomP_version_type IMRPhenomP_version)
Deprecated : used the old convention (view frame for the spins) Function to map LAL parameters (masse...
int XLALSimIMRPhenomPFrequencySequence(COMPLEX16FrequencySeries **hptilde, COMPLEX16FrequencySeries **hctilde, const REAL8Sequence *freqs, const REAL8 chi1_l, const REAL8 chi2_l, const REAL8 chip, const REAL8 thetaJ, const REAL8 m1_SI, const REAL8 m2_SI, const REAL8 distance, const REAL8 alpha0, const REAL8 phic, const REAL8 f_ref, IMRPhenomP_version_type IMRPhenomP_version, NRTidal_version_type NRTidal_version, LALDict *extraParams)
Driver routine to compute the precessing inspiral-merger-ringdown phenomenological waveform IMRPhenom...
@ LAL_SIM_INSPIRAL_SPIN_ORDER_35PN
int XLALSimInspiralTaylorF2AlignedPhasing(PNPhasingSeries **pfa, const REAL8 m1, const REAL8 m2, const REAL8 chi1, const REAL8 chi2, LALDict *extraPars)
Returns structure containing TaylorF2 phasing coefficients for given physical parameters.
void XLALDestroyREAL8Sequence(REAL8Sequence *sequence)
REAL8Sequence * XLALCreateREAL8Sequence(size_t length)
COMPLEX16 XLALSpinWeightedSphericalHarmonic(REAL8 theta, REAL8 phi, int s, int l, int m)
const LALUnit lalStrainUnit
const LALUnit lalSecondUnit
LALUnit * XLALUnitMultiply(LALUnit *output, const LALUnit *unit1, const LALUnit *unit2)
#define XLAL_PRINT_INFO(...)
#define XLAL_ERROR_NULL(...)
#define XLAL_CHECK(assertion,...)
#define XLAL_CHECK_VOID(assertion,...)
#define XLAL_PRINT_WARNING(...)
int XLALPrintError(const char *fmt,...) _LAL_GCC_PRINTF_FORMAT_(1
LIGOTimeGPS * XLALGPSAdd(LIGOTimeGPS *epoch, REAL8 dt)
used to cache the recurring (frequency-independent) prefactors of AmpInsAnsatz.
Structure holding all coefficients for the amplitude.
Structure holding all coefficients for the phase.
used to cache the recurring (frequency-independent) prefactors of PhiInsAnsatzInt.
useful powers in GW waveforms: 1/6, 1/3, 2/3, 4/3, 5/3, 2, 7/3, 8/3, -1, -1/6, -7/6,...