Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALSimulation 6.2.0.1-b246709
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
LALSimIMRTEOBResumS_Internals.c
Go to the documentation of this file.
1
2/*
3 * This file is part of TEOBResumS
4 *
5 * Copyright (C) 2017-2018 Alessandro Nagar, Sebastiano Bernuzzi,
6 * Sarp Ackay, Gregorio Carullo, Walter Del Pozzo, Ka Wa Tsang, Michalis Agathos
7 * LALSimulation implementation by Michalis Agathos
8 *
9 * TEOBResumS is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * TEOBResumS is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see http://www.gnu.org/licenses/.
21 *
22 */
23
24#ifdef __GNUC__
25#define UNUSED __attribute__ ((unused))
26#else
27#define UNUSED
28#endif
29
30#include <complex.h>
31#include <math.h>
32
33#include <gsl/gsl_const.h>
34#include <gsl/gsl_errno.h>
35#include <gsl/gsl_math.h>
36#include <gsl/gsl_odeiv.h>
37
38#include "LALSimTEOBResumS.h"
39
40
41#define TEOB_NV (21) /* temp arrays */
42
43/* hlmNewt coefficients for amplitude */
44static const REAL8 ChlmNewt_ampli[35] = {2.1137745587232057, 6.341323676169617, 0.1412325034218127, 1.7864655618418102, 4.9229202032627635, 0.023872650234580958, 0.2250735048768909, 1.7053495827316825, 4.763908164911493, 0.001122165903318321, 0.06333806741197714, 0.2945348827200268, 1.755276012972272, 5.0817902739730565, 0.00014954736544380072, 0.005296595280255638, 0.10342548105284892, 0.3713362832603404, 1.8983258440274462, 5.727111757630886, 5.184622059790144e-06, 0.0012191691413436815, 0.011783593824950922, 0.14639129995388936, 0.4653654097044924, 2.125638973894669, 6.685178460621457, 5.54485779151375621e-7, 0.0000763473331250837455, 0.00353250998285463003,
45 0.0204988821800401766, 0.19579402814926015, 0.584571015778149663, 2.44207899966355693, 7.9955401278763745};
46
47/* hlmNewt additive coefficients for phase */
48static const REAL8 ChlmNewt_phase[35] = {4.71238898038469, 3.141592653589793, 4.71238898038469, 0.0, 1.5707963267948966, 1.5707963267948966, 0.0, 4.71238898038469, 3.141592653589793, 1.5707963267948966, 3.141592653589793, 4.71238898038469, 0.0, 1.5707963267948966, 4.71238898038469, 3.141592653589793, 1.5707963267948966, 0.0, 4.71238898038469, 3.141592653589793, 4.71238898038469, 0.0, 1.5707963267948966, 3.141592653589793, 4.71238898038469, 0.0, 1.5707963267948966, 4.7123889803846898577, 0.0, 1.5707963267948966192, 3.1415926535897932385,
49 4.7123889803846898577, 0.0, 1.5707963267948966192, 3.1415926535897932385};
50
51/* Coefficients for Newtonian flux */
52static const double CNlm[35] = {
53 0.17777777777777778, 6.4,
54 0.0007936507936507937, 0.5079365079365079, 8.678571428571429,
55 2.2675736961451248e-05, 0.008062484252960444, 1.0414285714285714, 14.447971781305114,
56 5.010421677088344e-08, 0.0006384836014465644, 0.03106534090909091, 1.9614216236438458, 25.688197074915823,
57 8.898517797026696e-10, 4.464920289836115e-06, 0.003830520129221428, 0.08778390483440988, 3.584607999290539, 46.98226573426573,
58 1.0695333890657086e-12, 2.3656367312710969e-07, 4.972309783123969e-05, 0.013643024456211269, 0.21542115380351798, 6.472046810332524, 87.1329124642076,
59 1.2233225038333268e-14, 9.27700678929842e-10, 4.468579053461083e-06, 0.0002675102834551229, 0.03813282951314997, 0.4894825318738884, 11.627213264559293, 162.79300083906728
60};
61
62/* EOB nonspinning Hamiltonian */
63void eob_ham(REAL8 nu, REAL8 r, REAL8 pphi, REAL8 prstar, REAL8 A, REAL8 dA,
64 REAL8 *H, /* real EOB Hamiltonian divided by mu=m1m2/(m1+m2) */
65 REAL8 *Heff, /* effective EOB Hamiltonian (divided by mu) */
66 REAL8 *dHeff_dr, /* drvt Heff,r */
67 REAL8 *dHeff_dprstar, /* drvt Heff,prstar */
68 REAL8 *dHeff_dpphi /* drvt Heff,pphi */
69)
70{
71 const REAL8 z3 = 2.0*nu*(4.0-3.0*nu);
72 const REAL8 pphi2 = SQ(pphi);
73 const REAL8 u = 1./r;
74 const REAL8 u2 = SQ(u);
75 const REAL8 u3 = u2*u;
76 const REAL8 prstar2 = SQ(prstar);
77 const REAL8 prstar3 = prstar2*prstar;
78 const REAL8 prstar4 = prstar2*prstar2;
79
80 *Heff = sqrt(A*(1.0 + pphi2*u2) + prstar2 + z3*A*u2*prstar4);
81 *H = sqrt( 1.0 + 2.0*nu*(*Heff - 1) )/nu;
82
83 if (dHeff_dr != NULL) *dHeff_dr = 0.5*(dA + (pphi2 + z3*prstar4)*(dA*u2 - 2*A*u3))/(*Heff);
84 if (dHeff_dprstar != NULL) *dHeff_dprstar = (prstar + z3*2.0*A*u2*prstar3)/(*Heff);
85 if (dHeff_dpphi != NULL) *dHeff_dpphi = A*pphi*u2/(*Heff);
86 return;
87}
88
89/* EOB spinning Hamiltonian */
91 REAL8 r,
92 REAL8 rc,
93 REAL8 drc_dr,
94 REAL8 pphi,
95 REAL8 prstar,
96 REAL8 S,
97 REAL8 Sstar,
98 REAL8 chi1,
99 REAL8 chi2,
100 REAL8 X1,
101 REAL8 X2,
102 REAL8 aK2,
103 REAL8 c3,
104 REAL8 A,
105 REAL8 dA,
106 REAL8 *H, /* real EOB Hamiltonian divided by mu=m1m2/(m1+m2) */
107 REAL8 *Heff, /* effective EOB Hamiltonian (divided by mu) */
108 REAL8 *Heff_orb,
109 REAL8 *dHeff_dr, /* drvt Heff,r */
110 REAL8 *dHeff_dprstar, /* drvt Heff,prstar */
111 REAL8 *dHeff_dpphi, /* drvt Heff,pphi */
112 REAL8 *d2Heff_dprstar20
113 )
114{
115 /* Shorthands */
116 const REAL8 z3 = 2.0*nu*(4.0-3.0*nu);
117 const REAL8 pphi2 = SQ(pphi);
118 const REAL8 prstar2 = SQ(prstar);
119 const REAL8 UNUSED prstar3 = prstar2*prstar;
120 const REAL8 prstar4 = prstar2*prstar2;
121 const REAL8 uc = 1./rc;
122 const REAL8 uc2 = uc*uc;
123 const REAL8 uc3 = uc2*uc;
124
125 /* Compute spin-related functions*/
126 REAL8 ggm[14];
127 eob_dyn_s_GS(r, rc, drc_dr, aK2, prstar, pphi, nu, chi1, chi2, X1, X2, c3, ggm);
128 const REAL8 GS = ggm[2];
129 const REAL8 GSs = ggm[3];
130 const REAL8 dGS_dprstar = ggm[4];
131 const REAL8 dGSs_dprstar = ggm[5];
132 const REAL8 dGS_dr = ggm[6];
133 const REAL8 dGSs_dr = ggm[7];
134 const REAL8 dGSs_dpphi = ggm[9];
135 const REAL8 d2GS_dprstar20 = ggm[12];
136 const REAL8 d2GSs_dprstar20 = ggm[13];
137
138 /* Compute Hamiltonian and its derivatives */
139 *Heff_orb = sqrt( prstar2+A*(1. + pphi2*uc2 + z3*prstar4*uc2) );
140 *Heff = *Heff_orb + (GS*S + GSs*Sstar)*pphi;
141 *H = sqrt( 1. + 2.*nu*(*Heff - 1.) )/nu;
142 if (dHeff_dr != NULL) *dHeff_dr = pphi*(dGS_dr*S + dGSs_dr*Sstar) + 1./(2.*(*Heff_orb))*( dA*(1. + pphi2*uc2 + z3*prstar4*uc2) - 2.*A*uc3*drc_dr*(pphi2 + z3*prstar4) );
143 if (dHeff_dprstar != NULL) *dHeff_dprstar = pphi*(dGS_dprstar*S + dGSs_dprstar*Sstar) + (prstar/(*Heff_orb))*(1. + 2.*A*uc2*z3*prstar2);
144 if (d2Heff_dprstar20 != NULL) *d2Heff_dprstar20 = pphi*(d2GS_dprstar20*S + d2GSs_dprstar20*Sstar) + (1./(*Heff_orb))*(1. + 2.*A*uc2*z3*prstar2); /* second derivative of Heff wrt to pr_star neglecting all pr_star^2 terms */
145 if (dHeff_dpphi != NULL) *dHeff_dpphi = GS*S + (GSs + pphi*dGSs_dpphi)*Sstar + pphi*A*uc2/(*Heff_orb);
146
147 return;
148}
149
150
151/* Function for root finder: Derivative of the effective Hamiltonian */
153{
155};
156
157
159{
160
161 struct DHeff0_tmp_params *p
162 = (struct DHeff0_tmp_params *) params;
163
164 REAL8 rorb = p->rorb;
165 REAL8 A = p->A;
166 REAL8 dA = p->dA;
167 REAL8 rc = p->rc;
168 REAL8 drc_dr = p->drc_dr;
169 REAL8 ak2 = p->ak2;
170 REAL8 S = p->S;
171 REAL8 Ss = p->Ss;
172 REAL8 nu = p->nu;
173 REAL8 chi1 = p->chi1;
174 REAL8 chi2 = p->chi2;
175 REAL8 X1 = p->X1;
176 REAL8 X2 = p->X2;
177 REAL8 c3 = p->c3;
178
179 REAL8 ggm0[14];
180 eob_dyn_s_GS(rorb, rc, drc_dr, ak2, 0., x, nu, chi1, chi2, X1, X2, c3, ggm0);
181 REAL8 dGS_dr = ggm0[6];
182 REAL8 dGSs_dr = ggm0[7];
183
184 REAL8 x2 = SQ(x);
185 REAL8 uc = 1./rc;
186 REAL8 uc2 = SQ(uc);
187 REAL8 uc3 = uc2*uc;
188
189 /* Orbital circular effective Hamiltonian */
190 REAL8 Horbeff0 = sqrt(A*(1. + x2*uc2));
191 REAL8 dHeff_dr = x*(dGS_dr*S + dGSs_dr*Ss) + 1./(2.*Horbeff0)*( dA*(1. + x2*uc2) - 2.*A*uc3*drc_dr*x2);
192 return dHeff_dr;
193}
194
195
196/* Root finder: Compute minimum of Heff0 */
198 REAL8 chi1,
199 REAL8 chi2,
200 REAL8 X1,
201 REAL8 X2,
202 REAL8 c3,
203 REAL8 pph,
204 REAL8 rorb,
205 REAL8 A,
206 REAL8 dA,
207 REAL8 rc,
209 REAL8 ak2,
210 REAL8 S,
211 REAL8 Ss)
212{
213
214 int status;
215 INT4 iter = 0;
216 const gsl_root_fsolver_type *T;
217 gsl_root_fsolver *s;
218
219 double r;
220 double x_lo = 0.5*(double) pph, x_hi = 1.5*(double) pph;
221
222 gsl_function F;
224 F.function = &eob_dyn_DHeff0;
225
226 F.params = &p;
227 T = gsl_root_fsolver_bisection;
228 s = gsl_root_fsolver_alloc (T);
229 gsl_root_fsolver_set (s, &F, x_lo, x_hi);
230 do
231 {
232 iter++;
233 status = gsl_root_fsolver_iterate (s);
234 r = gsl_root_fsolver_root (s);
235 x_lo = gsl_root_fsolver_x_lower (s);
236 x_hi = gsl_root_fsolver_x_upper (s);
237 status = gsl_root_test_interval (x_lo, x_hi, 0, TOLERANCE);
238 }
239 while (status == GSL_CONTINUE && iter < MAX_ITER);
240 gsl_root_fsolver_free (s);
241
242 return (REAL8) r;
243}
244
245/* Initial radius from initial frequency using Kepler's law */
247{
248 const REAL8 omg_orb0 = LAL_PI*f0; // =2*LAL_PI*(f_orb0/2)
249 return pow(omg_orb0, -2./3.);
250}
251
252/* Initial radius from initial frequency using EOB circular dynamics */
254{
255 const REAL8 omg_orb0 = LAL_PI*f0;
256 const REAL8 r0_kepl = eob_dyn_r0_Kepler(f0);
257 return eob_dyn_bisecOmegaorb0(dyn, omg_orb0, r0_kepl);
258}
259
260/* Function for root finder: omega = omega_circ */
264};
265
267{
268
269 /* Unpack parameters */
271 REAL8 omg_orb0 = p->omg_orb0;
273
274 const REAL8 nu = dyn->nu;
275 const REAL8 X1 = dyn->X1;
276 const REAL8 X2 = dyn->X2;
277 const REAL8 chi1 = dyn->chi1;
278 const REAL8 chi2 = dyn->chi2;
279 const REAL8 a1 = dyn->a1;
280 const REAL8 a2 = dyn->a2;
281 const REAL8 aK2 = dyn->aK2;
282 const REAL8 S = dyn->S;
283 const REAL8 Sstar = dyn->Sstar;
284 const REAL8 c3 = dyn->cN3LO;
285 const REAL8 C_Q1 = dyn->C_Q1;
286 const REAL8 C_Q2 = dyn->C_Q2;
287 const REAL8 C_Oct1 = dyn->C_Oct1;
288 const REAL8 C_Oct2 = dyn->C_Oct2;
289 const REAL8 C_Hex1 = dyn->C_Hex1;
290 const REAL8 C_Hex2 = dyn->C_Hex2;
291
292 const int usetidal = dyn->use_tidal;
293 const int usespins = dyn->use_spins;
294
295 REAL8 A,B,dA,rc,drc_dr,G,dG_dr,uc,uc2,dAuc2_dr,j02,j0,H,Heff,Heff_orb,dHeff_dj0,omg_orb;
296 REAL8 pl_hold,a_coeff,b_coeff,c_coeff,Delta,sol_p,sol_m;
297 REAL8 ggm[14];
298
299 /* Computing metric, centrifugal radius and ggm functions*/
300 if(usespins)
301 {
302 eob_metric_s(r,dyn, &A, &B, &dA, &pl_hold, &pl_hold);
303 dyn->eob_dyn_s_get_rc(r, nu, a1, a2, aK2, C_Q1, C_Q2, C_Oct1, C_Oct2, C_Hex1, C_Hex2, usetidal, &rc, &drc_dr, &pl_hold);
304 eob_dyn_s_GS(r, rc, drc_dr, aK2, 0.0, 0.0, nu, chi1, chi2, X1, X2, c3, ggm);
305 G = ggm[2]*S + ggm[3]*Sstar; // tildeG = GS*S+GSs*Ss
306 dG_dr = ggm[6]*S + ggm[7]*Sstar;
307 }
308 else
309 {
310 eob_metric(r ,dyn, &A, &B, &dA, &pl_hold, &pl_hold);
311 rc = r; //Nonspinning case: rc = r; G = 0;
312 drc_dr = 1;
313 G = 0.0;
314 dG_dr = 0.0;
315 }
316
317 /* Auxiliary variables*/
318 uc = 1./rc;
319 uc2 = uc*uc;
320 dAuc2_dr = uc2*(dA-2*A*uc*drc_dr);
321
322 /* Circular angular momentum */
323 if (usespins)
324 {
325
326 /* Quadratic equation \f$a*x^2+b*x+c=0\f$ */
327 a_coeff = SQ(dAuc2_dr) - 4*A*uc2*SQ(dG_dr);
328 b_coeff = 2*dA*dAuc2_dr - 4*A*SQ(dG_dr);
329 c_coeff = SQ(dA);
330
331 Delta = SQ(b_coeff) - 4*a_coeff*c_coeff;
332
333 if (S==0 && Sstar==0)
334 Delta=0; // dG_dr=0 -> Set Delta=0 to avoid num. errors
335
336 sol_p = (-b_coeff + sqrt(Delta))/(2*a_coeff);
337 sol_m = (-b_coeff - sqrt(Delta))/(2*a_coeff);
338
339 if (dG_dr > 0)
340 j02 = sol_p;
341 else
342 j02 = sol_m;
343
344 } else {
345 /* Linear equation \f$a*x+b=0\f$ */
346 a_coeff = dAuc2_dr;
347 b_coeff = dA;
348 j02 = -b_coeff/a_coeff;
349 }
350
351 j0 = sqrt(j02);
352
353 /* Circular Hamiltonians */
354 Heff_orb = sqrt(A*(1+j02*uc2));
355 Heff = Heff_orb + j0*G;
356 H = sqrt(1+2*nu*(Heff-1))/nu;
357
358 /* Circular orbital frequency */
359 dHeff_dj0 = G + A*j0*uc2/Heff_orb;
360 omg_orb = dHeff_dj0/nu/H;
361
362 /* Subtraction of initial evolution frequency */
363 return (omg_orb - omg_orb0);
364}
365
366/* Root finder: Compute r0 such that omg_orb = omg_orb0 */
368{
369 int status;
370 INT4 iter = 0;
371 const gsl_root_fsolver_type *T;
372 gsl_root_fsolver *s;
373 REAL8 r0;
374 double x_lo = 0.5*r0_kepl, x_hi = 1.5*r0_kepl;
375 gsl_function F;
376
378
379 F.function = &eob_dyn_Omegaorb0;
380 F.params = &p;
381 T = gsl_root_fsolver_bisection;
382 s = gsl_root_fsolver_alloc (T);
383 gsl_root_fsolver_set (s, &F, x_lo, x_hi);
384 do {
385 iter++;
386 status = gsl_root_fsolver_iterate (s);
387 r0 = (REAL8) gsl_root_fsolver_root (s);
388 x_lo = gsl_root_fsolver_x_lower (s);
389 x_hi = gsl_root_fsolver_x_upper (s);
390 status = gsl_root_test_interval (x_lo, x_hi, 0, TOLERANCE);
391 }
392 while (status == GSL_CONTINUE && iter < MAX_ITER);
393 gsl_root_fsolver_free (s);
394
395 return r0;
396}
397
398/* Initial conditions calculation for non-spinning systems */
399/* Post-post-circular initial data at separation r0
400 r0 => relative separation
401 pph0 => post-post-circular angular momentum
402 pr => post-circular radial momentum
403 pprstar0 => post-circular r*-conjugate radial momentum
404 j0 => circular angular momentum
405
406 Three-step procedure
407 1. Compute j0 => circular ID, j!=0, pr =0
408 2. From j0, compute pr* => post circular ID, j!=0, pr !=0
409 3. From pr* and j0, re-compute pph0 => post-post-circular ID, pph0!=j!=0, pr !=0
410 */
412{
413 const REAL8 nu = dyn->nu;
414 const REAL8 z3 = 2.0*nu*(4.0-3.0*nu);
415
416 /* Build a small grid */
417#define TEOB_IC_N (6)
418 const REAL8 dr = 1e-10;
419
420 REAL8 r[2*TEOB_IC_N], dA[2*TEOB_IC_N], j[2*TEOB_IC_N], j2[2*TEOB_IC_N], djdr[2*TEOB_IC_N]; /* j:angular momentum */
421 REAL8 E0[2*TEOB_IC_N], Omega_j[2*TEOB_IC_N];
422 REAL8 Fphi[2*TEOB_IC_N], Ctmp[2*TEOB_IC_N], prstar[2*TEOB_IC_N], pr[2*TEOB_IC_N], pph[2*TEOB_IC_N], dprstardr[2*TEOB_IC_N];
423
424 REAL8 A, B, d2A, dB;
425 REAL8 r2, r3, j3;
426 REAL8 H0eff, H0, psi, r_omega, v_phi, jhat, x, dprstardt;
427
428 for (int i = 0; i < 2*TEOB_IC_N; i++) {
429 r[i] = r0+(i-TEOB_IC_N+1)*dr;
430 r2 = SQ(r[i]);
431 r3 = r2*r[i];
432
433 /* Compute metric */
434 eob_metric(r[i], dyn, &A, &B, &dA[i], &d2A, &dB);
435
436 /* Angular momentum for circular orbit: circular ID */
437 j2[i] = r3*dA[i]/(2.*A-r[i]*dA[i]);
438 j[i] = sqrt(j2[i]);
439 j3 = j2[i]*j[i];
440 djdr[i] = -j3/r3*( 2.0 - 3.0*A/(r[i]*dA[i]) - A*d2A/(dA[i]*dA[i]) );
441
442 /* For circular orbit at r0=r(TEOB_IC_N) */
443 H0eff = sqrt(A*(1.0 + j2[i]/r2)); /* effective Hamiltonian H_0^eff */
444 E0[i] = sqrt(1.0 + 2.0*nu*(H0eff - 1.0) ); /* real Hamiltonian H_0 */
445 H0 = E0[i]/nu; /* H_0/nu */
446 Omega_j[i] = A*j[i]/(nu*r2*H0*H0eff); /* Orbital frequency (from Hamilton's equation) */
447 psi = 2.*(1.0 + 2.0*nu*(H0eff - 1.0))/(r2*dA[i]); /* correction factor to the radius */
448 r_omega = r[i]*cbrt(psi); /* EOB-corrected radius */
449 v_phi = Omega_j[i]*r_omega; /* "corrected" azimuthal velocity such that Kepler's law is satisfied, r_omg^3 Omg_i^2 = 1 */
450 x = v_phi * v_phi;
451 jhat = j[i]/(r_omega*v_phi); /* Newton-normalized angular momentum */
452
453 Fphi[i] = eob_flx_Flux(x,Omega_j[i],r_omega,E0[i],H0eff,jhat,r[i], 0,0,dyn);
454
455 /* Radial momentum conjugate to r*: post-circular ID */
456 Ctmp[i] = sqrt(B/A)*nu*H0*H0eff;
457 prstar[i] = Ctmp[i]*Fphi[i]/djdr[i];
458
459 /* Radial momentum conjugate to r */
460 pr[i] = prstar[i]*sqrt(B/A);
461
462 }
463
464 /* prstar by finite diff. */
465 D0(prstar, dr, 2*TEOB_IC_N, dprstardr);
466
467 int i = TEOB_IC_N-1;
468 dprstardt = dprstardr[i] * Fphi[i]/djdr[i];
469 pph[i] = j[i]*sqrt(1. + 2.*Ctmp[i]/dA[i]*dprstardt - z3*gsl_pow_int(prstar[i],4)/j2[i]);
470
471 y_init[TEOB_ID_RAD] = r[TEOB_IC_N-1];
472 y_init[TEOB_ID_PHI] = 0.;
473 y_init[TEOB_ID_PPHI] = pph[TEOB_IC_N-1];
474 y_init[TEOB_ID_PRSTAR] = prstar[TEOB_IC_N-1];
475 y_init[TEOB_ID_PR] = pr[TEOB_IC_N-1];
476 y_init[TEOB_ID_J] = j[TEOB_IC_N-1];
477 y_init[TEOB_ID_E0] = E0[TEOB_IC_N-1];
478 y_init[TEOB_ID_OMGJ] = Omega_j[TEOB_IC_N-1];
479
480}
481
482
483/* Initial conditions calculation for spinning systems */
485{
486 const REAL8 nu = dyn->nu;
487 const REAL8 chi1 = dyn->chi1;
488 const REAL8 chi2 = dyn->chi2;
489 const REAL8 S1 = dyn->S1;
490 const REAL8 S2 = dyn->S2;
491 const REAL8 c3 = dyn->cN3LO;
492 const REAL8 X1 = dyn->X1;
493 const REAL8 X2 = dyn->X2;
494 const REAL8 a1 = dyn->a1;
495 const REAL8 a2 = dyn->a2;
496 const REAL8 aK2 = dyn->aK2;
497 const REAL8 C_Q1 = dyn->C_Q1;
498 const REAL8 C_Q2 = dyn->C_Q2;
499 const REAL8 C_Oct1 = dyn->C_Oct1;
500 const REAL8 C_Oct2 = dyn->C_Oct2;
501 const REAL8 C_Hex1 = dyn->C_Hex1;
502 const REAL8 C_Hex2 = dyn->C_Hex2;
503
504 const REAL8 S = S1 + S2;
505 const REAL8 Ss = X2*a1 + X1*a2;
506 const REAL8 z3 = 2.0*nu*(4.0-3.0*nu);
507
508 /* Build a small grid */
509#define TEOB_IC_S_N (6)
510 const REAL8 dr = 1e-4; /* do not change this */
511
512 REAL8 r[2*TEOB_IC_S_N], dA[2*TEOB_IC_S_N], j[2*TEOB_IC_S_N]; /* j:angular momentum */
513 REAL8 E0[2*TEOB_IC_S_N], Omega_j[2*TEOB_IC_S_N];
514 REAL8 Fphi[2*TEOB_IC_S_N], UNUSED Ctmp[2*TEOB_IC_S_N], prstar[2*TEOB_IC_S_N], pr[2*TEOB_IC_S_N], pph[2*TEOB_IC_S_N];
515 REAL8 rc[2*TEOB_IC_S_N], drc_dr[2*TEOB_IC_S_N], d2rc_dr2[2*TEOB_IC_S_N]; //, drc[2*TEOB_IC_S_N];
516 REAL8 A[2*TEOB_IC_S_N],B[2*TEOB_IC_S_N],d2A[2*TEOB_IC_S_N],dB, sqrtAbyB;
517 REAL8 pphorb, uc, uc2, psic, r_omg, v_phi, jhat, x, Omg;
518 REAL8 UNUSED H0eff, H0, Horbeff0, Heff0, one_H0, dHeff_dprstarbyprstar, dHeff_dpph, Heff, H, Horbeff;
519 REAL8 ggm0[14], GS_0, GSs_0, dGS_dr_0, dGSs_dr_0, dGSs_dpph_0, dGS_dprstarbyprstar_0, dGSs_dprstarbyprstar_0, GS, GSs, dGS_dr, dGSs_dr;
520 REAL8 C0;
521 REAL8 Gtilde, dGtilde_dr, duc_dr;
522
523 int i;
524 for (i = 0; i < 2*TEOB_IC_S_N; i++) {
525 r[i] = r0+(i-TEOB_IC_S_N+1)*dr;
526
527 /* Compute metric */
528 eob_metric_s(r[i], dyn, &A[i],&B[i],&dA[i],&d2A[i],&dB);
529
530 /* Compute minimum of Heff0 using bisection method */
531 pphorb = r[i]/sqrt(r[i]-3.);
532 dyn->eob_dyn_s_get_rc(r[i], nu, a1, a2, aK2, C_Q1, C_Q2, C_Oct1, C_Oct2, C_Hex1,
533 C_Hex2, dyn->use_tidal, &rc[i], &drc_dr[i], &d2rc_dr2[i]);
534 pph[i] = eob_dyn_bisecHeff0_s(nu,chi1,chi2,X1,X2,c3, pphorb, r[i], A[i],
535 dA[i], rc[i], drc_dr[i], aK2, S, Ss);
536
537 }
538
539 /* Post-circular initial conditions */
540
541 /* pph by finite diff. */
542 REAL8 dpph_dr[2*TEOB_IC_S_N];
543 D0(pph, dr, 2*TEOB_IC_S_N, dpph_dr);
544
545 for (i = 0; i < 2*TEOB_IC_S_N; i++) {
546
547 sqrtAbyB = sqrt(A[i]/B[i]);
548 uc = 1./rc[i];
549 uc2 = uc*uc;
550
551 /* Orbital effective Hamiltonian */
552 Horbeff0 = sqrt(A[i]*(1. + SQ(pph[i])*uc2));
553
554 /* Compute gyro-gravitomagnetic coupling functions */
555 eob_dyn_s_GS(r[i], rc[i], drc_dr[i], aK2, 0, pph[i], nu, chi1, chi2, X1, X2, c3, ggm0);
556 GS_0 = ggm0[2];
557 GSs_0 = ggm0[3];
558 dGS_dr_0 = ggm0[6];
559 dGSs_dr_0 = ggm0[7];
560 dGSs_dpph_0 = ggm0[9];
561 dGS_dprstarbyprstar_0 = ggm0[10];
562 dGSs_dprstarbyprstar_0 = ggm0[11];
563
564 /* Final effective Hamiltonian */
565 Heff0 = (GS_0*S + GSs_0*Ss)*pph[i] + Horbeff0;
566
567 /* Real Hamiltonian: beware that this is NOT divided by nu */
568 H0 = sqrt( 1. + 2.*nu*(Heff0 - 1.));
569 one_H0 = 1./H0;
570
571 /* Get gyro-gravitomagnetic (derivative) functions */
572 dHeff_dprstarbyprstar = pph[i]*(dGS_dprstarbyprstar_0*S + dGSs_dprstarbyprstar_0*Ss) + 1./Horbeff0;
573
574 C0 = sqrtAbyB*one_H0*dHeff_dprstarbyprstar;
575
576 /* Orbital frequency for circular orbit */
577 dHeff_dpph = GS_0*S + (GSs_0 + pph[i]*dGSs_dpph_0)*Ss + pph[i]*A[i]*uc2/Horbeff0;
578 Omg = one_H0*dHeff_dpph;
579
580 /* Flux */
581 Gtilde = GS_0*S + GSs_0*Ss;
582 dGtilde_dr = dGS_dr_0*S + dGSs_dr_0*Ss;
583 duc_dr = -uc2*drc_dr[i];
584 psic = (duc_dr + dGtilde_dr*rc[i]*sqrt(A[i]/(SQ(pph[i])) + A[i]*uc2)/A[i])/(-0.5*dA[i]);
585 r_omg = pow((pow(rc[i]*rc[i]*rc[i]*psic,-1./2)+Gtilde)*one_H0,-2./3.);
586 v_phi = r_omg*Omg;
587 x = v_phi*v_phi;
588 jhat = pph[i]/(r_omg*v_phi); /* Newton-normalized angular momentum */
589
590 Fphi[i] = eob_flx_Flux_s(x, Omg, r_omg, H0, Heff0, jhat, r[i], 0., 0., dyn);
591 prstar[i] = Fphi[i]/(dpph_dr[i]*C0);
592 pr[i] = prstar[i]/sqrtAbyB;
593
594 j[i] = pph[i];
595 E0[i] = H0;
596 Omega_j[i] = Omg;
597
598 }
599
600#if (POSTPOSTCIRCULAR)
601
602 /* Post-post-circular initial data */
603
604 REAL8 dpi1bydj, dprstardr[2*TEOB_IC_S_N],djdr[2*TEOB_IC_S_N];
605 D0(prstar, dr, 2*TEOB_IC_S_N, dprstardr);
606 D0(j, dr, 2*TEOB_IC_S_N, djdr);
607
608 REAL8 dpi1dt, prstar4, a,b,c;
609
610 //for (i = 0; i < 2*TEOB_IC_S_N; i++) { //No need of the loop here
611 i = TEOB_IC_S_N-1;
612
613 sqrtAbyB = sqrt(A[i]/B[i]);
614 uc = 1./rc[i];
615 uc2 = uc*uc;
616
617 dpi1bydj = dprstardr[i]/djdr[i];
618 dpi1dt = dpi1bydj*Fphi[i];
619 prstar4 = prstar[i]*prstar[i]*prstar[i]*prstar[i];
620
621 /* Still circular, no pr* dependence here */
622 Horbeff = sqrt(A[i]*(1. + SQ(pph[i])*uc2));
623
624 eob_dyn_s_GS(r[i], rc[i], drc_dr[i], aK2, 0, pph[i], nu, chi1, chi2, X1, X2, c3, ggm0);
625 GS = ggm0[2];
626 GSs = ggm0[3];
627 dGS_dr = ggm0[6];
628 dGSs_dr = ggm0[7];
629
630 /* Effective EOB energy */
631 Heff = (GS*S + GSs*Ss)*pph[i] + Horbeff;
632
633 /* Total EOB energy */
634 H = sqrt( 1. + 2.*nu*(Heff - 1.));
635
636 /* Setting up second order equation for the orbital angular momentum */
637 a = -sqrtAbyB*uc2/(2.*H*Horbeff)*(dA[i] - 2.*A[i]*uc*drc_dr[i]);
638 b = -sqrtAbyB/H*(dGS_dr*S + dGSs_dr*Ss);
639 c = -dpi1dt - sqrtAbyB/(2.*H*Horbeff)*(dA[i] + z3*prstar4*uc2*(dA[i] - 2.*A[i]*uc*drc_dr[i]));
640
641 /* Fill out the array of the post-circular angular momentum */
642 pph[i] = 0.5*(-b + sqrt(b*b-4*a*c))/a;
643
644 // }
645
646#endif
647
648 y_init[TEOB_ID_RAD] = r[TEOB_IC_S_N-1];
649 y_init[TEOB_ID_PHI] = 0.;
650 y_init[TEOB_ID_PPHI] = pph[TEOB_IC_S_N-1];
651 y_init[TEOB_ID_PRSTAR] = prstar[TEOB_IC_S_N-1];
652 y_init[TEOB_ID_PR] = pr[TEOB_IC_S_N-1];
653 y_init[TEOB_ID_J] = j[TEOB_IC_S_N-1];
654 y_init[TEOB_ID_E0] = E0[TEOB_IC_S_N-1];
655 y_init[TEOB_ID_OMGJ] = Omega_j[TEOB_IC_S_N-1];
656
657 return;
658}
659
660
661/* r.h.s. of EOB Hamiltonian dynamics, no spins version */
662int eob_dyn_rhs(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
663{
664
665 (void)(t); /* avoid unused parameter warning */
667
668 const REAL8 nu = dyn->nu;
669 const REAL8 z3 = 2.0*nu*(4.0-3.0*nu);
670
671 /* Unpack y */
672 const REAL8 UNUSED phi = y[TEOB_EVOLVE_PHI];
673 const REAL8 r = y[TEOB_EVOLVE_RAD];
674 const REAL8 pphi = y[TEOB_EVOLVE_PPHI];
675 const REAL8 prstar = y[TEOB_EVOLVE_PRSTAR];
676
677 /* Compute EOB Metric */
678 REAL8 A, B, dA, d2A, dB;
679 eob_metric(r, d, &A, &B, &dA, &d2A, &dB);
680
681 /* Compute Hamiltonian */
682 REAL8 H, Heff, dHeff_dr,dHeff_dprstar;
683 eob_ham(nu, r,pphi,prstar,A,dA, &H,&Heff,&dHeff_dr,&dHeff_dprstar,NULL);
684 REAL8 E = nu*H;
685
686 /* Shorthands */
687 const REAL8 u = 1./r;
688 const REAL8 u2 = u*u;
689 const REAL8 u3 = u2*u;
690 const REAL8 pphi2 = SQ(pphi);
691 const REAL8 prstar2 = prstar*prstar;
692 const REAL8 prstar3 = prstar2*prstar;
693 const REAL8 prstar4 = prstar3*prstar;
694 const REAL8 sqrtAbyB = sqrt(A/B);
695 const REAL8 divHE = 1./(Heff*E);
696 const REAL8 Omega = A*pphi*u2*divHE;
697
698 /* \f$d\phi/dt\f$ */
699 dy[TEOB_EVOLVE_PHI] = Omega;
700
701 /* \f$dr/dt\f$ (conservative part of) */
702 dy[TEOB_EVOLVE_RAD] = sqrtAbyB*(prstar+4.0*nu*(4.0-3.0*nu)*A*u2*prstar3)*divHE;
703
704 /* \f$dp_{r*}/dt\f$ (conservative part of) */
705 dy[TEOB_EVOLVE_PRSTAR] = - 0.5*sqrtAbyB*( pphi2*u2*(dA-2.0*A*u) + dA + 2.0*nu*(4.0-3.0*nu)*(dA*u2 - 2.0*A*u3)*prstar4 )*divHE;
706
707 /* Compute flux */
708 const REAL8 sqrtW = sqrt(A*(1. + pphi2*u2));
709 const REAL8 psi = 2.*(1.0 + 2.0*nu*(sqrtW - 1.0))/(SQ(r)*dA);
710 /*const REAL8 psi = 2.*(1.0 + 2.0*nu*(Heff - 1.0))/(r2*dA); */
711 const REAL8 r_omega = r*cbrt(psi);
712 const REAL8 v_phi = r_omega*Omega;
713 const REAL8 x = v_phi * v_phi;
714 const REAL8 jhat = pphi/(r_omega*v_phi);
715 const REAL8 tmpE = 1./Heff+nu/(E*E);
716 const REAL8 dprstar_dt = dy[TEOB_EVOLVE_PRSTAR];
717 const REAL8 dr_dt = dy[TEOB_EVOLVE_RAD];
718 const REAL8 ddotr_dr = sqrtAbyB*( (prstar + z3*2.*A*u2*prstar3)*(0.5*(dA/A-dB/B)-dHeff_dr*tmpE)+ 2.0*z3*(dA*u2 - 2.*A*u3)*prstar3)*divHE;
719 const REAL8 ddotr_dprstar = sqrtAbyB*( 1.+z3*6.*A*u2*prstar2-(prstar + z3*2.*A*u2*prstar3)*dHeff_dprstar*tmpE)*divHE;
720
721 /* Approximate ddot(r) without Flux */
722 const REAL8 ddotr = dprstar_dt*ddotr_dprstar + dr_dt*ddotr_dr;
723
724 /* Compute flux and \f$dp_{\phi}/dt\f$ */
725 if (dyn->noflux) dy[TEOB_EVOLVE_PPHI] = 0.;
726 else dy[TEOB_EVOLVE_PPHI] = eob_flx_Flux(x,Omega,r_omega,E,Heff,jhat,r, prstar,ddotr,dyn);
727
728 if(dyn->store) {
729 /* Store values */
730 dyn->t = t;
731 dyn->r = r;
733 dyn->pphi = pphi;
734 dyn->prstar = prstar;
735 dyn->Omg = Omega;
736 dyn->Omg_orb = Omega;
737 dyn->H = H;
738 dyn->E = E;
739 dyn->Heff = Heff;
740 dyn->A = A;
741 dyn->dA = dA;
742 dyn->d2A = d2A;
743 dyn->B = B;
744 dyn->dB = dB;
745 dyn->psi = psi;
746 dyn->r_omega = r_omega;
747 dyn->v_phi = v_phi;
748 dyn->jhat = jhat;
749 dyn->ddotr = ddotr;
750 }
751
752 return GSL_SUCCESS;
753
754}
755
756
757/* r.h.s. of EOB Hamiltonian dynamics, spins version */
758int eob_dyn_rhs_s(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
759{
760
761 (void)(t); /* avoid unused parameter warning */
763
764 /* Unpack values */
765 const REAL8 nu = dyn->nu;
766 const REAL8 S = dyn->S;
767 const REAL8 Sstar = dyn->Sstar;
768 const REAL8 chi1 = dyn->chi1;
769 const REAL8 chi2 = dyn->chi2;
770 const REAL8 X1 = dyn->X1;
771 const REAL8 X2 = dyn->X2;
772 const REAL8 c3 = dyn->cN3LO;
773 const REAL8 aK2 = dyn->aK2;
774 const REAL8 a1 = dyn->a1;
775 const REAL8 a2 = dyn->a2;
776 const REAL8 C_Q1 = dyn->C_Q1;
777 const REAL8 C_Q2 = dyn->C_Q2;
778 const REAL8 C_Oct1 = dyn->C_Oct1;
779 const REAL8 C_Oct2 = dyn->C_Oct2;
780 const REAL8 C_Hex1 = dyn->C_Hex1;
781 const REAL8 C_Hex2 = dyn->C_Hex2;
782 const int usetidal = dyn->use_tidal;
783 const int UNUSED usespins = dyn->use_spins;
784
785 /* Shorthands */
786 const REAL8 r = y[TEOB_EVOLVE_RAD];
787 const REAL8 prstar = y[TEOB_EVOLVE_PRSTAR];
788 const REAL8 pphi = y[TEOB_EVOLVE_PPHI];
789 const REAL8 pphi2 = pphi*pphi;
790
791 /* Compute Metric */
792 REAL8 A, B, dA, d2A, dB;
793 eob_metric_s(r, d, &A, &B, &dA, &d2A, &dB);
794
795 /* Compute centrifugal radius */
796 REAL8 rc, drc_dr, d2rc_dr;
797 dyn->eob_dyn_s_get_rc(r, nu, a1, a2, aK2, C_Q1, C_Q2, C_Oct1, C_Oct2, C_Hex1, C_Hex2, usetidal, &rc, &drc_dr, &d2rc_dr);
798 const REAL8 uc = 1./rc;
799 const REAL8 uc2 = uc*uc;
800 const REAL8 UNUSED uc3 = uc2*uc;
801
802 /* Compute Hamiltonian */
803 REAL8 Heff_orb, Heff, H, dHeff_dr, dHeff_dprstar, d2Heff_dprstar20, dHeff_dpphi;
804 eob_ham_s(nu, r, rc, drc_dr, pphi, prstar, S, Sstar, chi1, chi2, X1, X2, aK2, c3, A, dA,
805 &H, &Heff, &Heff_orb, &dHeff_dr, &dHeff_dprstar, &dHeff_dpphi, &d2Heff_dprstar20);
806
807 /* H follows the same convention of Heff, i.e. it is the energy per unit mass,
808 while E is the real energy.*/
809 REAL8 E = nu*H;
810 const REAL8 ooH = 1./E;
811
812 const REAL8 sqrtAbyB = sqrt(A/B);
813 const REAL8 dp_rstar_dt_0 = - sqrtAbyB*dHeff_dr*ooH;
814 const REAL8 ddotr_dp_rstar = sqrtAbyB*d2Heff_dprstar20*ooH;
815 const REAL8 Omg = dHeff_dpphi*ooH;
816 const REAL8 ddotr = dp_rstar_dt_0*ddotr_dp_rstar; /* approximate ddot(r)_0 without Fphi, order pr_star^2 neglected */
817
818 /* r evol eqn rhs */
819 dy[TEOB_EVOLVE_RAD] = sqrtAbyB*dHeff_dprstar*ooH;
820
821 /* phi evol eqn rhs */
822 dy[TEOB_EVOLVE_PHI] = Omg;
823
824 /* dp_{r*}/dt */
825 dy[TEOB_EVOLVE_PRSTAR] = -sqrtAbyB*dHeff_dr*ooH;
826
827 /* Compute here the new r_omg radius
828 Compute same quantities with prstar=0. This to obtain psi.
829 Procedure consistent with the nonspinning case. */
830 REAL8 ggm0[14];
831 eob_dyn_s_GS(r, rc, drc_dr, aK2, 0., pphi, nu, chi1, chi2, X1, X2, c3, ggm0);
832
833 const REAL8 GS_0 = ggm0[2];
834 const REAL8 GSs_0 = ggm0[3];
835 const REAL8 dGS_dr_0 = ggm0[6];
836 const REAL8 dGSs_dr_0 = ggm0[7];
837 const REAL8 Heff_orb_0 = sqrt(A*(1.0 + pphi2*uc2)); /* effective Hamiltonian H_0^eff */
838 const REAL8 Heff_0 = Heff_orb_0 + (GS_0*S + GSs_0*Sstar)*pphi;
839 const REAL8 H0 = sqrt(1.0 + 2.0*nu*(Heff_0 - 1.0) );
840 const REAL8 ooH0 = 1./H0;
841 const REAL8 Gtilde = GS_0*S + GSs_0*Sstar;
842 const REAL8 dGtilde_dr = dGS_dr_0*S + dGSs_dr_0*Sstar;
843 const REAL8 duc_dr = -uc2*drc_dr;
844 const REAL8 psic = (duc_dr + dGtilde_dr*rc*sqrt(A/pphi2 + A*uc2)/A)/(-0.5*dA);
845 const REAL8 r_omg = pow( ((1./sqrt(rc*rc*rc*psic))+Gtilde)*ooH0, -2./3. );
846 const REAL8 v_phi = r_omg*Omg;
847 const REAL8 x = v_phi*v_phi;
848 const REAL8 jhat = pphi/(r_omg*v_phi);
849
850 /* Compute flux and \f$dp_{\phi}/dt\f$ */
851 if (dyn->noflux) dy[TEOB_EVOLVE_PPHI] = 0.;
852 else dy[TEOB_EVOLVE_PPHI] = eob_flx_Flux_s(x,Omg,r_omg,E,Heff,jhat,r,prstar,ddotr,dyn);
853
854 if (dyn->store) {
855 /* Store values */
856 dyn->t = t;
857 dyn->r = r;
859 dyn->pphi = pphi;
860 dyn->prstar = prstar;
861 dyn->Omg = Omg;
862 dyn->Omg_orb = ooH*pphi*A*uc2/Heff_orb;
863 dyn->H = H;
864 dyn->E = E;
865 dyn->Heff = Heff;
866 dyn->A = A;
867 dyn->dA = dA;
868 dyn->d2A = d2A;
869 dyn->B = B;
870 dyn->dB = dB;
871 // dyn->psi = psi;
872 dyn->r_omega = r_omg;
873 dyn->v_phi = v_phi;
874 dyn->jhat = jhat;
875 dyn->ddotr = ddotr;
876 }
877
878 return GSL_SUCCESS;
879}
880
881
882/* Computes the gyro-gravitomagnetic functions GS and GS*, that are called GS and GSs.
883 r => BL radius
884 aK2 => squared Kerr parameter
885 prstar => r* conjugate momentum
886 nu => symmetric mass ratio
887 the CN3LO parameter is hard-coded in this routine
888 ggm is the output structure. */
889
891 REAL8 rc,
892 REAL8 drc_dr,
893 REAL8 UNUSED aK2,
894 REAL8 prstar,
895 REAL8 UNUSED pph,
896 REAL8 nu,
897 REAL8 UNUSED chi1,
898 REAL8 UNUSED chi2,
899 REAL8 UNUSED X1,
900 REAL8 UNUSED X2,
901 REAL8 cN3LO,
902 REAL8 *ggm)
903{
904// static REAL8 c10,c20,c30,c02,c12,c04;
905// static REAL8 cs10,cs20,cs30,cs40,cs02,cs12,cs04;
906 REAL8 c10,c20,c30,c02,c12,c04;
907 REAL8 cs10,cs20,cs30,cs40,cs02,cs12,cs04;
908
909 /* Compute the nu-dep. coefficient at first call only */
910 // MA: FIXME: is this dangerous for lalinference?
911// static int firstcall = 1;
912// if (firstcall) {
913// firstcall = 0;
914 REAL8 nu2 = nu*nu;
915 /* coefficients of hat{GS} */
916 c10 = 5./16.*nu;
917 c20 = 51./8.*nu + 41./256.*nu2;
918 c30 = nu*cN3LO;
919 c02 = 27./16.*nu;
920 c12 = 12.*nu - 49./128.*nu2;
921 c04 = -5./16.*nu + 169./256.*nu2;
922 /* coefficients of hat{GS*} */
923 cs10 = 3./4. + nu/2.;
924 cs20 = 27./16. + 29./4.*nu + 3./8.*nu2;
925 cs02 = 5./4. + 3./2.*nu;
926 cs12 = 4. + 11.*nu - 7./8.*nu2;
927 cs04 = 5./48. + 25./12.*nu + 3./8.*nu2;
928 cs30 = nu*cN3LO + 135./32.;
929 cs40 = 2835./256.;
930// }
931
932 REAL8 u = 1./r;
933 REAL8 u2 = u*u;
934
935 REAL8 uc = 1./rc;
936 REAL8 uc2 = uc*uc;
937 REAL8 uc3 = uc2*uc;
938 REAL8 uc4 = uc3*uc;
939 REAL8 prstar2 = prstar*prstar;
940 REAL8 prstar4 = prstar2*prstar2;
941
942 REAL8 GS0 = 2.*u*uc2;
943 REAL8 dGS0_duc = 2.*u2/drc_dr + 4.*u*uc;
944
945 REAL8 GSs0 = 3./2.*uc3;
946 REAL8 dGSs0_duc = 9./2.*uc2;
947 REAL8 dGSs0_dprstar = 0.0;
948 REAL8 dGSs0_dpph = 0.0;
949
950 REAL8 hGS = 1./(1. + c10*uc + c20*uc2 + c30*uc3 + c02*prstar2 + c12*uc*prstar2 + c04*prstar4);
951 REAL8 hGSs = 1./(1. + cs10*uc + cs20*uc2 + cs30*uc3 + cs40*uc4 + cs02*prstar2 + cs12*uc*prstar2 + cs04*prstar4);
952
953 /* complete gyro-gravitomagnetic functions */
954 REAL8 GS = GS0*hGS;
955 REAL8 GSs = GSs0*hGSs;
956
957 /* Get derivatives of gyro-gravitomagnetic functions */
958 REAL8 dhGS_dprstar = -2.*prstar*hGS*hGS *( c02 + c12*uc + 2.*c04*prstar2);
959 REAL8 dhGSs_dprstar = -2.*prstar*hGSs*hGSs*(cs02 + cs12*uc + 2.*cs04*prstar2);
960
961 REAL8 dGS_dprstar = GS0 *dhGS_dprstar;
962 REAL8 dGSs_dprstar = GSs0*dhGSs_dprstar + dGSs0_dprstar*hGSs;
963
964 /* derivatives of hat{G} with respect to uc */
965 REAL8 dhGS_duc = -hGS*hGS*(c10 + 2.*c20*uc + 3.*c30*uc2 + c12*prstar2);
966 REAL8 dhGSs_duc = -hGSs*hGSs*(cs10 + 2.*cs20*uc + 3.*cs30*uc2 + 4.*cs40*uc3 + cs12*prstar2);
967
968 /* derivatives of G with respect to uc */
969 REAL8 dGS_duc = dGS0_duc*hGS + GS0*dhGS_duc;
970 REAL8 dGSs_duc = dGSs0_duc*hGSs + GSs0*dhGSs_duc;
971
972 /* derivatives of (G,G*) with respect to r */
973 REAL8 dGS_dr = -drc_dr*uc2*dGS_duc;
974 REAL8 dGSs_dr = -drc_dr*uc2*dGSs_duc;
975
976 /* derivatives of (G,G*) with respect to pph */
977 REAL8 dGS_dpph = 0.;
978 REAL8 dGSs_dpph = dGSs0_dpph*hGSs;
979
980 /* For initial data: compute the two ratios of ggm.dG_dprstar/prstar for GS and GSs */
981 const REAL8 dGS_dprstarbyprstar = -2.*GS0*hGS*hGS *( c02 + c12*uc + 2.*c04*prstar2);
982 const REAL8 dGSs_dprstarbyprstar = -2.*GSs0*hGSs*hGSs*(cs02 + cs12*uc + 2.*cs04*prstar2);
983
984 /* For NQC: Second derivatives neglecting all pr_star^2 terms */
985 const REAL8 d2GS_dprstar20 = GS0*(-2.*hGS*hGS *( c02 + c12*uc + 2.*c04*prstar2));
986 const REAL8 d2GSs_dprstar20 = GSs0*(-2.*hGSs*hGSs*(cs02 + cs12*uc + 2.*cs04*prstar2));
987
988 ggm[0]=hGS;
989 ggm[1]=hGSs;
990 ggm[2]=GS;
991 ggm[3]=GSs;
992 ggm[4]=dGS_dprstar;
993 ggm[5]=dGSs_dprstar;
994 ggm[6]=dGS_dr;
995 ggm[7]=dGSs_dr;
996 ggm[8]=dGS_dpph;
997 ggm[9]=dGSs_dpph;
998 ggm[10]=dGS_dprstarbyprstar;
999 ggm[11]=dGSs_dprstarbyprstar;
1000 ggm[12]=d2GS_dprstar20;
1001 ggm[13]=d2GSs_dprstar20;
1002
1003 return;
1004}
1005
1006
1007/* Define radius rc that includes of LO spin-square coupling. */
1008/*
1009 The S1*S2 term coincides with the BBH one, no effect of structure.
1010 The self-spin couplings, S1*S1 and S2*S2 get a EOS-dependent coefficient, CQ, that describe the quadrupole
1011 deformation due to spin. Notation of Levi-Steinhoff, JCAP 1412 (2014), no.12, 003. Notation analogous to
1012 the parameter a of Poisson, PRD 57, (1998) 5287-5290 or C_ES^2 in Porto & Rothstein, PRD 78 (2008), 044013
1013
1014 The implementation uses the I-Love-Q fits of Table I of Yunes-Yagi
1015 paper, PRD 88, 023009, the \f$bar{Q}(bar{\lambda)^{tid})\f$ relation, line 3 of the table.
1016 The dimensionless \f$bar{\lambda}\f$ love number is related to our apsidal constant as \f$lambda = 2/3 k2/(C^5)\f$ so that both quantities have to appear here.
1017 */
1019 REAL8 nu,
1020 REAL8 at1,
1021 REAL8 at2,
1022 REAL8 aK2,
1023 REAL8 C_Q1,
1024 REAL8 C_Q2,
1025 REAL8 UNUSED C_Oct1,
1026 REAL8 UNUSED C_Oct2,
1027 REAL8 UNUSED C_Hex1,
1028 REAL8 UNUSED C_Hex2,
1029 int usetidal,
1030 REAL8 *rc,
1031 REAL8 *drc_dr,
1032 REAL8 *d2rc_dr2)
1033{
1034
1035 REAL8 u = 1./r;
1036 REAL8 u2 = u*u;
1037 REAL8 u3 = u*u2;
1038 REAL8 r2 = r*r;
1039
1040 if (usetidal) {
1041#if (RC_EXCLUDESPINSPINTIDES)
1042 /* Switch off spin-spin-tidal couplings */
1043 /* See also: eob_wav_flm_s() */
1044 REAL8 rc2 = r2;
1045 *rc = r;
1046 *drc_dr = 1;
1047 *d2rc_dr2 = 0;
1048 /* Above code switch off everything,
1049 Alt. one can set C_Q1=C_Q2=0, but keep centrifugal radius */
1050 /*
1051 REAL8 a02 = 2.*at1*at2;
1052 REAL8 rc2 = r2 + a02*(1.+2.*u);
1053 *rc = sqrt(rc2);
1054 *drc_dr = r/(*rc)*(1.-a02*u3);
1055 *d2rc_dr2 = 1./(*rc)*(1.-(*drc_dr)*r/(*rc)*(1.-a02*u3)+2.*a02*u3);
1056 */
1057#else
1058 /* BNS effective spin parameter */
1059 REAL8 a02 = C_Q1*at1*at1 + 2.*at1*at2 + C_Q2*at2*at2;
1060 REAL8 rc2 = r2 + a02*(1.+2.*u); /* tidally-modified centrifugal radius */
1061 *rc = sqrt(rc2);
1062 *drc_dr = r/(*rc)*(1.-a02*u3);
1063 *d2rc_dr2 = 1./(*rc)*(1.-(*drc_dr)*r/(*rc)*(1.-a02*u3)+2.*a02*u3);
1064#endif
1065 } else {
1066 /*
1067 REAL8 X12 = sqrt(1.-4.*nu);
1068 REAL8 alphanu2 = 1. + 0.5/aK2*(- at2*at2*(5./4. + 5./4.*X12 + nu/2.) - at1*at1*(5./4. - 5./4.*X12 +nu/2.) + at1*at2*(-2.+nu));
1069 REAL8 rc2 = r2 + aK2*(1. + 2.*alphanu2/r);
1070 *rc = sqrt(rc2);
1071 *drc_dr = r/(*rc)*(1.+aK2*(-alphanu2*u3 ));
1072 *d2rc_dr2 = 1./(*rc)*(1.-(*drc_dr)*r/(*rc)*(1.-alphanu2*aK2*u3)+ 2.*alphanu2*aK2*u3);
1073 */
1074 /* Following implementation is regular (avoids 1/aK2) */
1075 REAL8 X12 = sqrt(1.-4.*nu);
1076 REAL8 c_ss_nlo = (- at2*at2*(1.25 + 1.25*X12 + 0.5*nu) - at1*at1*(1.25 - 1.25*X12 + 0.5*nu) + at1*at2*(-2.+nu));
1077 REAL8 rc2 = r2 + aK2*(1. + 2.*u) + u*c_ss_nlo;
1078 *rc = sqrt(rc2);
1079 REAL8 divrc = 1.0/(*rc);
1080 *drc_dr = r*divrc*(1-(aK2 + 0.5*c_ss_nlo)*u3);
1081 *d2rc_dr2 = divrc*(1.-(*drc_dr)*r*divrc*(1.-(aK2+0.5*c_ss_nlo)*u3)+ (2.*aK2 + c_ss_nlo)*u3);
1082 }
1083
1084 return;
1085}
1086
1087/* tidal rc with NLO coefficient that depends on C_Qi */
1089 REAL8 nu,
1090 REAL8 at1,
1091 REAL8 at2,
1092 REAL8 aK2,
1093 REAL8 C_Q1,
1094 REAL8 C_Q2,
1095 REAL8 UNUSED C_Oct1,
1096 REAL8 UNUSED C_Oct2,
1097 REAL8 UNUSED C_Hex1,
1098 REAL8 UNUSED C_Hex2,
1099 int usetidal,
1100 REAL8 *rc,
1101 REAL8 *drc_dr,
1102 REAL8 *d2rc_dr2)
1103{
1104
1105 REAL8 u = 1./r;
1106 REAL8 u2 = u*u;
1107 REAL8 u3 = u*u2;
1108 REAL8 r2 = r*r;
1109 REAL8 X12 = sqrt(1.-4.*nu);
1110
1111 if (usetidal) {
1112
1113 /* BNS effective spin parameter */
1114 REAL8 a02 = C_Q1*at1*at1 + 2.*at1*at2 + C_Q2*at2*at2;
1115
1116 REAL8 delta_a2 = X12*(at1*at1*(C_Q1+0.25) - at2*at2*(C_Q2+0.25))
1117 + at1*at1*(-17./4.+3.*C_Q1-0.5*nu)
1118 + at2*at2*(-17./4.+3.*C_Q2-0.5*nu)
1119 + at1*at2*(nu-2.0);
1120
1121 REAL8 rc2 = r2 + a02*(1. + 2.*u) + delta_a2*u;
1122 *rc = sqrt(rc2);
1123 REAL8 divrc = 1.0/(*rc);
1124 *drc_dr = divrc*(r - (a02 + 0.5*delta_a2)*u2);
1125 *d2rc_dr2 = divrc*(1 + (2.*a02 + delta_a2)*u3 - (*drc_dr)*(*drc_dr));
1126
1127 }
1128 else {
1129
1130 REAL8 c_ss_nlo = (- at2*at2*(1.25 + 1.25*X12 + 0.5*nu) - at1*at1*(1.25 - 1.25*X12 + 0.5*nu) + at1*at2*(-2.+nu));
1131 REAL8 rc2 = r2 + aK2*(1. + 2.*u) + u*c_ss_nlo;
1132 *rc = sqrt(rc2);
1133 REAL8 divrc = 1.0/(*rc);
1134 *drc_dr = r*divrc*(1-(aK2 + 0.5*c_ss_nlo)*u3);
1135 *d2rc_dr2 = divrc*(1.-(*drc_dr)*r*divrc*(1.-(aK2+0.5*c_ss_nlo)*u3)+ (2.*aK2 + c_ss_nlo)*u3);
1136
1137 }
1138
1139}
1140
1141/* tidal rc with NNLO coefficient that depends on C_Qi */
1143 REAL8 nu,
1144 REAL8 at1,
1145 REAL8 at2,
1146 REAL8 aK2,
1147 REAL8 C_Q1,
1148 REAL8 C_Q2,
1149 REAL8 UNUSED C_Oct1,
1150 REAL8 UNUSED C_Oct2,
1151 REAL8 UNUSED C_Hex1,
1152 REAL8 UNUSED C_Hex2,
1153 int usetidal,
1154 REAL8 *rc,
1155 REAL8 *drc_dr,
1156 REAL8 *d2rc_dr2)
1157{
1158
1159 REAL8 u = 1./r;
1160 REAL8 u2 = u*u;
1161 REAL8 u3 = u*u2;
1162 REAL8 u4 = u*u3;
1163 REAL8 u5 = u*u4;
1164 REAL8 r2 = r*r;
1165 REAL8 X12 = sqrt(1.-4.*nu);
1166
1167 if (usetidal)
1168 {
1169
1170 /* BNS effective spin parameter */
1171 REAL8 a02 = C_Q1*at1*at1 + 2.*at1*at2 + C_Q2*at2*at2;
1172
1173 REAL8 delta_a2 = X12*(at1*at1*(C_Q1+0.25) - at2*at2*(C_Q2+0.25))
1174 + at1*at1*(-17./4.+3.*C_Q1-0.5*nu)
1175 + at2*at2*(-17./4.+3.*C_Q2-0.5*nu)
1176 + at1*at2*(nu-2.0);
1177
1178 REAL8 delta_a2_nnlo =
1179 ( 387./28. - 207./28.*nu ) *a02
1180 + (-2171./212. - 269./28.*nu + 0.375*nu*nu) *(at1*at1+at2*at2)
1181 + (- 281./7 - 187./56.*nu - 0.75 *nu*nu) *at1*at2
1182 + 163./28. *X12*(C_Q1*at1*at1-C_Q2*at2*at2)
1183 + ( -29./112. - 2.625 *nu ) *X12*(at1*at1-at2*at2);
1184
1185 REAL8 rc2 = r2 + a02*(1. + 2.*u) + delta_a2*u + delta_a2_nnlo*u2;
1186 *rc = sqrt(rc2);
1187 REAL8 divrc = 1.0/(*rc);
1188 *drc_dr = divrc*(r - (a02 + 0.5*delta_a2)*u2 - delta_a2_nnlo*u3);
1189 *d2rc_dr2 = divrc*(1 + (2.*a02 + delta_a2)*u3
1190 + 3*delta_a2_nnlo*u4 - (*drc_dr)*(*drc_dr));
1191
1192 }
1193 else
1194 {
1195
1196 REAL8 a0 = at1 + at2;
1197 REAL8 a12 = at1 - at2;
1198
1199 REAL8 c_ss_nlo = -1.125*a0*a0 -(0.125+0.5+nu)*a12*a12 + 1.25*X12*a0*a12;
1200
1201 REAL8 c_ss_nnlo = - (189./32. + 417.32*nu) *a0 *a0
1202 + ( 11./32. - 127.32*nu + 0.375*nu*nu) *a12*a12
1203 + ( 87.16 - 2.625*nu )*X12 *a0 *a12;
1204
1205
1206 REAL8 rc2 = r2 + aK2*(1. + 2.*u) + u*c_ss_nlo + u2*c_ss_nnlo;
1207 *rc = sqrt(rc2);
1208 REAL8 divrc = 1.0/(*rc);
1209 *drc_dr = r*divrc*(1-(aK2 + 0.5*c_ss_nlo)*u3 - 0.5*u4*c_ss_nnlo);
1210 *d2rc_dr2 = 1./r*(*drc_dr) + r*divrc*((3.*aK2+c_ss_nlo)*u4 + 2.*c_ss_nnlo*u5);
1211
1212 }
1213
1214}
1215
1216/* tidal rc @ NNLO with the addition of the LO spin^4 coefficient that depends on C_Q, C_Oct and C_Hex */
1218 REAL8 nu,
1219 REAL8 at1,
1220 REAL8 at2,
1221 REAL8 aK2,
1222 REAL8 C_Q1,
1223 REAL8 C_Q2,
1224 REAL8 C_Oct1,
1225 REAL8 C_Oct2,
1226 REAL8 C_Hex1,
1227 REAL8 C_Hex2,
1228 int usetidal,
1229 REAL8 *rc,
1230 REAL8 *drc_dr,
1231 REAL8 *d2rc_dr2)
1232{
1233
1234 REAL8 u = 1./r;
1235 REAL8 u2 = u*u;
1236 REAL8 u3 = u*u2;
1237 REAL8 u4 = u*u3;
1238 REAL8 u5 = u*u4;
1239 REAL8 r2 = r*r;
1240 REAL8 X12 = sqrt(1.-4.*nu);
1241
1242 if (usetidal)
1243 {
1244
1245 /* BNS effective spin parameter */
1246 REAL8 a02 = C_Q1*at1*at1 + 2.*at1*at2 + C_Q2*at2*at2;
1247
1248 REAL8 delta_a2 = X12*(at1*at1*(C_Q1+0.25) - at2*at2*(C_Q2+0.25))
1249 + at1*at1*(-17./4.+3.*C_Q1-0.5*nu)
1250 + at2*at2*(-17./4.+3.*C_Q2-0.5*nu)
1251 + at1*at2*(nu-2.0);
1252
1253 REAL8 delta_a2_nnlo =
1254 ( 387./28. - 207./28.*nu ) *a02
1255 + (-2171./212. - 269./28.*nu + 0.375*nu*nu) *(at1*at1+at2*at2)
1256 + (- 281./7 - 187./56.*nu - 0.75 *nu*nu) *at1*at2
1257 + 163./28. *X12*(C_Q1*at1*at1-C_Q2*at2*at2)
1258 + ( -29./112. - 2.625 *nu ) *X12*(at1*at1-at2*at2);
1259
1260 REAL8 delta_a4_lo = 0.75*(C_Hex1 - C_Q1*C_Q1)*at1*at1*at1*at1
1261 + 3.*(C_Oct1 - C_Q1) *at1*at1*at1*at2
1262 + 3.*(C_Q1*C_Q2 - 1) *at1*at1*at2*at2
1263 + 3.*(C_Oct2 - C_Q2) *at1*at2*at2*at2
1264 + 0.75*(C_Hex2 - C_Q2*C_Q2)*at2*at2*at2*at2;
1265
1266 REAL8 rc2 = r2 + a02*(1. + 2.*u) + delta_a2*u + (delta_a2_nnlo+delta_a4_lo)*u2;
1267 *rc = sqrt(rc2);
1268 REAL8 divrc = 1.0/(*rc);
1269 *drc_dr = divrc*(r - (a02 + 0.5*delta_a2)*u2 - (delta_a2_nnlo+delta_a4_lo)*u3);
1270 *d2rc_dr2 = divrc*(1 + (2.*a02 + delta_a2)*u3
1271 + 3*(delta_a2_nnlo+delta_a4_lo)*u4 - (*drc_dr)*(*drc_dr));
1272
1273 }
1274 else
1275 {
1276
1277 REAL8 a0 = at1 + at2;
1278 REAL8 a12 = at1 - at2;
1279
1280 REAL8 c_ss_nlo = -1.125*a0*a0 -(0.125+0.5+nu)*a12*a12 + 1.25*X12*a0*a12;
1281
1282 REAL8 c_ss_nnlo = - (189./32. + 417.32*nu ) *a0 *a0
1283 + ( 11./32. - 127.32*nu + 0.375*nu*nu) *a12*a12
1284 + ( 87.16 - 2.625*nu )*X12*a0 *a12;
1285
1286
1287 REAL8 rc2 = r2 + aK2*(1. + 2.*u) + u*c_ss_nlo + u2*c_ss_nnlo;
1288 *rc = sqrt(rc2);
1289 REAL8 divrc = 1.0/(*rc);
1290 *drc_dr = r*divrc*(1-(aK2 + 0.5*c_ss_nlo)*u3 - 0.5*u4*c_ss_nnlo);
1291 *d2rc_dr2 = 1./r*(*drc_dr) + r*divrc*((3.*aK2+c_ss_nlo)*u4 + 2.*c_ss_nnlo*u5);
1292
1293 }
1294
1295}
1296
1297/* Non-spinning case -- rc = r */
1299 REAL8 UNUSED nu,
1300 REAL8 UNUSED at1,
1301 REAL8 UNUSED at2,
1302 REAL8 UNUSED aK2,
1303 REAL8 UNUSED C_Q1,
1304 REAL8 UNUSED C_Q2,
1305 REAL8 UNUSED C_Oct1,
1306 REAL8 UNUSED C_Oct2,
1307 REAL8 UNUSED C_Hex1,
1308 REAL8 UNUSED C_Hex2,
1309 int UNUSED usetidal,
1310 REAL8 UNUSED *rc,
1311 REAL8 UNUSED *drc_dr,
1312 REAL8 UNUSED *d2rc_dr2)
1313{
1314 *rc = r;
1315 *drc_dr = 1;
1316 *d2rc_dr2 = 0;
1317}
1318
1319/* LO case with C_Q1 = 0 for tidal part*/
1321 REAL8 nu,
1322 REAL8 at1,
1323 REAL8 at2,
1324 REAL8 aK2,
1325 REAL8 UNUSED C_Q1,
1326 REAL8 UNUSED C_Q2,
1327 REAL8 UNUSED C_Oct1,
1328 REAL8 UNUSED C_Oct2,
1329 REAL8 UNUSED C_Hex1,
1330 REAL8 UNUSED C_Hex2,
1331 int usetidal,
1332 REAL8 *rc,
1333 REAL8 *drc_dr,
1334 REAL8 *d2rc_dr2)
1335{
1336
1337 REAL8 u = 1./r;
1338 REAL8 u2 = u*u;
1339 REAL8 u3 = u*u2;
1340 REAL8 r2 = r*r;
1341
1342 if (usetidal) {
1343 /* We set C_Q1=C_Q2=0, but keep centrifugal radius */
1344
1345 REAL8 a02 = 2.*at1*at2;
1346 REAL8 rc2 = r2 + a02*(1.+2.*u);
1347 *rc = sqrt(rc2);
1348 *drc_dr = r/(*rc)*(1.-a02*u3);
1349 *d2rc_dr2 = 1./(*rc)*(1.-(*drc_dr)*r/(*rc)*(1.-a02*u3)+2.*a02*u3);
1350
1351 } else {
1352
1353 REAL8 X12 = sqrt(1.-4.*nu);
1354 REAL8 c_ss_nlo = (- at2*at2*(1.25 + 1.25*X12 + 0.5*nu) - at1*at1*(1.25 - 1.25*X12 + 0.5*nu) + at1*at2*(-2.+nu));
1355 REAL8 rc2 = r2 + aK2*(1. + 2.*u) + u*c_ss_nlo;
1356 *rc = sqrt(rc2);
1357 REAL8 divrc = 1.0/(*rc);
1358 *drc_dr = r*divrc*(1-(aK2 + 0.5*c_ss_nlo)*u3);
1359 *d2rc_dr2 = divrc*(1.-(*drc_dr)*r*divrc*(1.-(aK2+0.5*c_ss_nlo)*u3)+ (2.*aK2 + c_ss_nlo)*u3);
1360 }
1361
1362}
1363
1364
1365/* EOB Metric A function 5PN log
1366 This function computes the Pade' (1,5) resummed A function (with its
1367 derivatives) starting from the 5PN-expanded version of the A function
1368 including 4PN and 5PN log terms.
1369 This represents the current, stable, most accurate implementation of
1370 the EOB effective potential
1371
1372 Coefficients a5 and a6 are the nonlog contributions to the 4PN and 5PN terms.
1373 In practice, a5 is fixed to its GSF value computed in Akcay et al,
1374
1375 \f$a5 \equiv a5_GSF = +23.50190(5) \approx +23.5\f$
1376
1377 and \f$a6 \equiv a6(nu) = (-110.5 + 129*(1-4*nu)).*(1-1.5e-5/((0.26-nu)^2)\f$
1378 as obtained from comparison with the Caltech-Cornell-CITA numerical data.
1379 These values are used as default. */
1381{
1382
1383 /* shortcuts */
1384 REAL8 nu2 = nu*nu;
1385 REAL8 pi2 = SQ(LAL_PI);
1386 REAL8 pi4 = pi2*pi2;
1387 REAL8 u = 1./r;
1388 REAL8 u2 = u*u;
1389 REAL8 u3 = u*u2;
1390 REAL8 u4 = u2*u2;
1391 REAL8 u5 = u4*u;
1392 REAL8 u6 = u5*u;
1393 REAL8 UNUSED u7 = u6*u;
1394 REAL8 UNUSED u10 = u5*u5;
1395 REAL8 u8 = u5*u3;
1396 REAL8 UNUSED u9 = u8*u;
1397 REAL8 logu = log(u);
1398
1399 REAL8 a5c0 = -4237./60. + 2275./512.*pi2 + 256./5.*Log2 + 128./5.*LAL_GAMMA;
1400 REAL8 a5c1 = -221./6. + 41./32.*pi2;
1401 REAL8 a5 = a5c0 + nu*a5c1;
1402 REAL8 a6 = 3097.3*nu2 - 1330.6*nu + 81.38;
1403
1404 /* 4PN and 5PN coefficients including all known log terms */
1405 REAL8 a5tot = a5 + 64./5.*logu;
1406 REAL8 a6tot = a6 + (-7004./105. - 144./5.*nu)*logu;
1407 REAL8 a5tot2 = a5tot*a5tot;
1408
1409 /* Coefficients of the Padeed function */
1410 REAL8 N1 = (-3*(-512 - 32*nu2 + nu*(3520 + 32*a5tot + 8*a6tot - 123*pi2)))/(-768 + nu*(3584 + 24*a5tot - 123*pi2));
1411 REAL8 D1 = (nu*(-3392 - 48*a5tot - 24*a6tot + 96*nu + 123*pi2))/(-768 + nu*(3584 + 24*a5tot - 123*pi2));
1412 REAL8 D2 = (2*nu*(-3392 - 48*a5tot - 24*a6tot + 96*nu + 123*pi2))/(-768 + nu*(3584 + 24*a5tot - 123*pi2));
1413 REAL8 D3 = (-2*nu*(6016 + 48*a6tot + 3392*nu + 24*a5tot*(4 + nu) - 246*pi2 - 123*nu*pi2))/(-768 + nu*(3584 + 24*a5tot - 123*pi2));
1414 REAL8 D4 = -(nu*(-4608*a6tot*(-4 + nu) + a5tot*(36864 + nu*(72192 - 2952*pi2)) + nu*(2048*(5582 + 9*nu) - 834432*pi2 + 15129*pi4)))/(96.*(-768 + nu*(3584 + 24*a5tot - 123*pi2)));
1415 REAL8 D5 = (nu*(-24*a6tot*(1536 + nu*(-3776 + 123*pi2)) + nu*(-2304*a5tot2 + 96*a5tot*(-3392 + 123*pi2) - (-3776 + 123*pi2)*(-3008 - 96*nu + 123*pi2))))/(96.*(-768 + nu*(3584 + 24*a5tot - 123*pi2)));
1416
1417 /* First derivatives */
1418 REAL8 dN1 = (160*nu*(-828672 - 32256*nu2 + 756*nu*(-768 + nu*(3584 + 24*a5 - 123*pi2)) + nu*(5006848 + 42024*a5 + 8064*a6 - 174045*pi2)))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),2)*u);
1419 REAL8 dD1 = (160*nu*(-828672 - 32256*nu2 + 756*nu*(-768 + nu*(3584 + 24*a5 - 123*pi2)) + nu*(5006848 + 42024*a5 + 8064*a6 - 174045*pi2)))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),2)*u);
1420 REAL8 dD2 = (320*nu*(-828672 - 32256*nu2 + 756*nu*(-768 + nu*(3584 + 24*a5 - 123*pi2)) + nu*(5006848 + 42024*a5 + 8064*a6 - 174045*pi2)))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),2)*u);
1421 REAL8 dD3 = (640*nu*(-828672 - 32256*nu2 + 756*nu*(-768 + nu*(3584 + 24*a5 - 123*pi2)) + nu*(5006848 + 42024*a5 + 8064*a6 - 174045*pi2)))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),2)*u);
1422 REAL8 dD4 = (-320*(-4 + nu)*nu*(-828672 - 32256*nu2 + 756*nu*(-768 + nu*(3584 + 24*a5 - 123*pi2)) + nu*(5006848 + 42024*a5 + 8064*a6 - 174045*pi2)))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),2)*u);
1423 REAL8 dD5 = (nu*(-8400*nu*(-24*(a6 - (4*logu*(1751 + 756*nu))/105.)*(1536 + nu*(-3776 + 123*pi2)) + nu*(-2304*gsl_pow_int(a5 + (64*logu)/5.,2) + 96*(a5 + (64*logu)/5.)*(-3392 + 123*pi2) - (-3776 + 123*pi2)*(-32*(94 + 3*nu) + 123*pi2))) - (1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)))*(4128768*logu*nu + 5*(-2689536 + nu*(11170624 + 64512*a5 - 380685*pi2) - 756*nu*(1536 + nu*(-3776 + 123*pi2))))))/(2625.*gsl_pow_int(-768 + nu*(3584 + 24*(a5 + (64*logu)/5.) - 123*pi2),2)*u);
1424
1425 /* Numerator and denominator of the Pade */
1426 REAL8 Num = 1 + N1*u;
1427 REAL8 Den = 1 + D1*u + D2*u2 + D3*u3 + D4*u4 + D5*u5;
1428 *A = Num/Den;
1429
1430 /* First derivative */
1431 REAL8 dNum = dN1*u + N1;
1432 REAL8 dDen = D1 + u*(dD1 + 2*D2) + u2*(dD2 + 3*D3) + u3*(dD3 + 4*D4) + u4*(dD4 + 5*D5) + dD5*u5;
1433
1434 /* Derivative of A function with respect to u */
1435 REAL8 prefactor = (*A)/(Num*Den);
1436 REAL8 dA_u = prefactor*(dNum*Den - dDen*Num);
1437
1438 /* Derivative of A with respect to r */
1439 /* *dA = -u2*dA_u; */
1440
1441 *dA = dA_u;
1442
1443 if (d2A != NULL) {
1444
1445 /* Second derivatives of Pade coefficients */
1446 REAL8 d2N1 = (160*nu*(-3840 + 1536*logu*nu + nu*(20992 + 120*a5 - 615*pi2))*(828672 + nu*(-42024*a5 - 8064*a6 + 3584*(-1397 + 9*nu) + 174045*pi2) + 756*nu*(768 + nu*(-3584 - 24*a5 + 123*pi2))))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),3)*u2);
1447 REAL8 d2D1 = (160*nu*(-3840 + 1536*logu*nu + nu*(20992 + 120*a5 - 615*pi2))*(828672 + nu*(-42024*a5 - 8064*a6 + 3584*(-1397 + 9*nu) + 174045*pi2) + 756*nu*(768 + nu*(-3584 - 24*a5 + 123*pi2))))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),3)*u2);
1448 REAL8 d2D2 = (320*nu*(-3840 + 1536*logu*nu + nu*(20992 + 120*a5 - 615*pi2))*(828672 + nu*(-42024*a5 - 8064*a6 + 3584*(-1397 + 9*nu) + 174045*pi2) + 756*nu*(768 + nu*(-3584 - 24*a5 + 123*pi2))))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),3)*u2);
1449 REAL8 d2D3 = (640*nu*(-3840 + 1536*logu*nu + nu*(20992 + 120*a5 - 615*pi2))*(828672 + nu*(-42024*a5 - 8064*a6 + 3584*(-1397 + 9*nu) + 174045*pi2) + 756*nu*(768 + nu*(-3584 - 24*a5 + 123*pi2))))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),3)*u2);
1450 REAL8 d2D4 = (320*(-4 + nu)*nu*(-828672 + 756*nu*(-768 + nu*(3584 + 24*a5 - 123*pi2)) + nu*(5006848 + 42024*a5 + 8064*a6 - 32256*nu - 174045*pi2))*(-3840 + 1536*logu*nu + nu*(20992 + 120*a5 - 615*pi2)))/(7.*gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),3)*u2);
1451 REAL8 d2D5 = (nu*(gsl_pow_int(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)),2)*(4128768*logu*nu - 7680*(1751 + 756*nu) + nu*(64*(808193 + 5040*a5 + 223020*nu) - 615*(3095 + 756*nu)*pi2)) + 3072*nu*(1536*logu*nu + 5*(-768 + nu*(3584 + 24*a5 - 123*pi2)))*(4128768*logu*nu - 7680*(1751 + 756*nu) + 5*nu*(64*(174541 + 1008*a5 + 44604*nu) - 123*(3095 + 756*nu)*pi2)) + 25804800*nu2*(-24*(a6 - (4*logu*(1751 + 756*nu))/105.)*(1536 + nu*(-3776 + 123*pi2)) + nu*(-2304*gsl_pow_int(a5 + (64*logu)/5.,2) + 96*(a5 + (64*logu)/5.)*(-3392 + 123*pi2) - (-3776 + 123*pi2)*(-32*(94 + 3*nu) + 123*pi2))) + 42000*nu*(-768 + nu*(3584 + 24*(a5 + (64*logu)/5.) - 123*pi2))*(-24*(a6 - (4*logu*(1751 + 756*nu))/105.)*(1536 + nu*(-3776 + 123*pi2)) + nu*(-2304*gsl_pow_int(a5 + (64*logu)/5.,2) + 96*(a5 + (64*logu)/5.)*(-3392 + 123*pi2) - (-3776 + 123*pi2)*(-32*(94 + 3*nu) + 123*pi2)))))/(13125.*gsl_pow_int(-768 + nu*(3584 + 24*(a5 + (64*logu)/5.) - 123*pi2),3)*u2);
1452
1453 /* Second derivative of numerator and denominator */
1454 REAL8 d2Num = 2.*dN1 + d2N1*u;
1455 REAL8 d2Den = 2.*(D2 + dD1) + u*(6.*D3 + 4.*dD2 + d2D1) + u2*(12.*D4 + 6.*dD3 + d2D2) + u3*(20.*D5 + 8.*dD4 + d2D3) + u4*(10.*dD5 + d2D4) + u5*d2D5;
1456
1457 /* Second derivative with respect of u */
1458 REAL8 d2A_u = prefactor*(2.*dDen*dDen*(*A) - 2.*dNum*dDen + Den*d2Num - d2Den*Num);
1459
1460 *d2A = d2A_u;
1461
1462 /* Second derivative with respect of r */
1463 /* *d2A = u4*d2A_u + 2.*u3*dA_u; */
1464
1465 }
1466}
1467
1468/* Tidal potential, two version implemented:
1469 1. TEOB NNLO, Bernuzzi+ 1205.3403
1470 2. TEOBResum, Bini&Damour, 1409.6933, Bernuzzi+ 1412.4553 */
1473 REAL8 *AT,
1474 REAL8 *dAT,
1475 REAL8 *d2AT)
1476{
1477
1478 REAL8 A, dA_u, d2A_u, UNUSED dA, UNUSED d2A;
1479 A = dA_u = d2A_u = 0.;
1480
1481 const REAL8 elsix = 1.833333333333333333333; // 11/6
1482 const REAL8 eightthird = 2.6666666666666666667; // 8/3
1483 const REAL8 nu = dyn->nu;
1484 const REAL8 rLR = dyn->rLR_tidal;
1485 const REAL8 XA = dyn->X1;
1486 const REAL8 XB = dyn->X2;
1487 const REAL8 kapA2 = dyn->kapA2;
1488 const REAL8 kapB2 = dyn->kapB2;
1489 const REAL8 kapA3 = dyn->kapA3;
1490 const REAL8 kapB3 = dyn->kapB3;
1491 const REAL8 kapT2 = dyn->kapT2;
1492 const REAL8 kapT3 = dyn->kapT3;
1493 const REAL8 kapT4 = dyn->kapT4;
1494 const REAL8 kapA2j = dyn->kapA2j;
1495 const REAL8 kapB2j = dyn->kapB2j;
1496 const REAL8 kapT2j = dyn->kapT2j;
1497
1498 /* Definition of the conservative tidal coefficients \f$\bar{\alpha}_n^{(\ell)}\f$,
1499 Eq.(37) of Damour&Nagar, PRD 81, 084016 (2010) */
1500 const REAL8 bar_alph2_1 = dyn->bar_alph2_1;
1501 const REAL8 bar_alph2_2 = dyn->bar_alph2_2;
1502 const REAL8 bar_alph3_1 = dyn->bar_alph3_1;
1503 const REAL8 bar_alph3_2 = dyn->bar_alph3_2;
1504 const REAL8 bar_alph2j_1 = dyn->bar_alph2j_1;
1505
1506
1507 const REAL8 p = dyn->pGSF_tidal;
1508
1509 /* shortcuts */
1510 REAL8 UNUSED nu2 = nu*nu;
1511 REAL8 pi2 = LAL_PI*LAL_PI;
1512 REAL8 UNUSED pi4 = pi2*pi2;
1513 REAL8 u = 1./r;
1514 REAL8 u2 = u*u;
1515 REAL8 u3 = u*u2;
1516 REAL8 u4 = u2*u2;
1517 REAL8 u5 = u4*u;
1518 REAL8 u6 = u5*u;
1519 REAL8 u7 = u6*u;
1520 REAL8 u10 = u5*u5;
1521 REAL8 u8 = u5*u3;
1522 REAL8 u9 = u8*u;
1523 REAL8 UNUSED logu = log(u);
1524 REAL8 oom3u = 1./(1.-rLR*u);
1525
1526
1528
1529 A = -(kapT4*u10) - kapT2*u6*(1. + bar_alph2_1*u + bar_alph2_2*u2) - kapT3*u8*(1. + bar_alph3_1*u + bar_alph3_2*u2);
1530 dA_u = -10.*kapT4*u9 - kapT2*u6*(bar_alph2_1 + 2.*bar_alph2_2*u) - kapT3*u8*(bar_alph3_1 + 2.*bar_alph3_2*u)
1531 - 6.*kapT2*u5*(1. + bar_alph2_1*u + bar_alph2_2*u2) - 8.*kapT3*u7*(1. + bar_alph3_1*u + bar_alph3_2*u2);
1532
1533 if (d2AT != NULL) {
1534 d2A_u = -90.*kapT4*u8
1535 - kapT2*(2*bar_alph2_2*u6 + 12.*u5*(bar_alph2_1 + 2*bar_alph2_2*u)
1536 + 30.*u4*(1 + bar_alph2_1*u + bar_alph2_2*u2))
1537 - kapT3*(2.*bar_alph3_2*u8 + 16.*u7*(bar_alph3_1 + 2*bar_alph3_2*u) + 56.*u6*(1 + bar_alph3_1*u + bar_alph3_2*u2));
1538 }
1539
1541
1542 const REAL8 c1 = 8.533515908; // OLD value 8.53353;
1543 const REAL8 c2 = 3.043093411; // OLD value 3.04309;
1544 const REAL8 n1 = 0.8400636422; // OLD value 0.840058;
1545 const REAL8 d2 = 17.7324036; // OLD value 17.73239
1546
1547 REAL8 Acub = 5./2.* u * (1. - (c1+c2)*u + c1*c2*u2);
1548 REAL8 dAcub = 5./2.* (1. -2*(c1+c2)*u + 3*c1*c2*u2);
1549 REAL8 d2Acub = 5 * ( - (c1+c2) + 3*c1*c2*u);
1550 REAL8 Den = 1./(1. + d2*u2);
1551 REAL8 f23 = (1. + n1*u)*Den;
1552 REAL8 df23 = (n1 - 2*d2*u - n1*d2*u2)*(Den*Den);
1553 REAL8 A1SF = Acub*f23;
1554 REAL8 dA1SF = dAcub*f23 + Acub*df23;
1555 REAL8 A2SF = 337./28.*u2;
1556 REAL8 dA2SF = 674./28.*u;
1557
1558 REAL8 f0 = 1 + 3*u2*oom3u;
1559 REAL8 f1 = A1SF *pow(oom3u,7./2.);
1560 REAL8 f2 = A2SF *pow(oom3u,p);
1561
1562 REAL8 df0 = 3*u*(2.-rLR*u)*(oom3u*oom3u);
1563 REAL8 df1 = 0.5*(7*rLR*A1SF + 2*(1.-rLR*u)*dA1SF)*pow(oom3u,9./2.);
1564 REAL8 df2 = (rLR*p*A2SF + (1.-rLR*u)*dA2SF)*pow(oom3u,p+1);
1565
1566 /* Gravito-electric tides for el = 2, 3, 4 */
1567 REAL8 AT2 = - kapA2*u6*( f0 + XA*f1 + XA*XA*f2 ) - kapB2*u6*( f0 + XB*f1 + XB*XB*f2 );
1568 REAL8 AT3 = - kapT3*u8*(1. + bar_alph3_1*u + bar_alph3_2*u2);
1569 REAL8 AT4 = - kapT4*u10;
1570
1571 REAL8 dAT2 = - kapA2*6.*u5*( f0 + XA*f1 + XA*XA*f2 ) - kapB2*6.*u5*( f0 + XB*f1 + XB*XB*f2 ) - kapA2*u6*( df0 + XA*df1 + XA*XA*df2 ) - kapB2*u6*( df0 + XB*df1 + XB*XB*df2 );
1572 REAL8 dAT3 = - kapT3*(8.*u7 + 9*bar_alph3_1*u8 + 10*bar_alph3_2*u9);
1573 REAL8 dAT4 = - kapT4*10.*u9;
1574
1575 A = AT2 + AT3 + AT4;
1576 dA_u = dAT2 + dAT3 + dAT4;
1577
1578 if (d2AT != NULL) {
1579 REAL8 d2f23 = 2*d2*(-1 + 3*d2*u2 + n1*u*(-3+d2*u2))*(Den*Den*Den);
1580 REAL8 d2A1SF = d2Acub*f23 + 2*dAcub*df23 + Acub*d2f23;
1581 REAL8 d2A2SF = 674./28.;
1582 REAL8 d2f0 = 6*(oom3u*oom3u*oom3u);
1583 REAL8 d2f1 = 0.25*(63*(rLR*rLR)*A1SF + 4*(-1+rLR*u)*(-7*rLR*dA1SF + (-1+rLR*u)*d2A1SF))*pow(oom3u,11./2.);
1584 REAL8 d2f2 = ( rLR*p*(1+p)*rLR*A2SF +(-1+rLR*u)*( -2.*p*rLR*dA2SF +(-1.+rLR*u)*d2A2SF ) )*pow(oom3u,p+2);
1585
1586 REAL8 d2AT2 = - kapA2*30*u4*( f0 + XA*f1 + XA*XA*f2 ) - kapB2*30*u4*( f0 + XB*f1 + XB*XB*f2 ) - 2*kapA2*6*u5*( df0 + XA*df1 + XA*XA*df2 ) - 2*kapB2*6*u5*( df0 + XB*df1 + XB*XB*df2 ) - kapA2*u6*( d2f0 + XA*d2f1 + XA*XA*d2f2 ) - kapB2*u6*( d2f0 + XB*d2f1 + XB*XB*d2f2 );
1587 REAL8 d2AT3 = - kapT3*(56*u6 + 72*bar_alph3_1*u7 + 90*bar_alph3_2*u8);
1588 REAL8 d2AT4 = - kapT4*90*u8;
1589
1590 d2A_u = d2AT2 + d2AT3 + d2AT4;
1591
1592 }
1594
1595 const REAL8 c1 = 8.533515908;
1596 const REAL8 c2 = 3.043093411;
1597 const REAL8 n1 = 0.8400636422;
1598 const REAL8 d2 = 17.7324036;
1599
1600 REAL8 Acub = 5./2.* u * (1. - (c1+c2)*u + c1*c2*u2);
1601 REAL8 dAcub = 5./2.* (1. -2*(c1+c2)*u + 3*c1*c2*u2);
1602 REAL8 d2Acub = 5 * ( - (c1+c2) + 3*c1*c2*u);
1603 REAL8 Den = 1./(1. + d2*u2);
1604 REAL8 f23 = (1. + n1*u)*Den;
1605 REAL8 df23 = (n1 - 2*d2*u - n1*d2*u2)*(Den*Den);
1606 REAL8 A1SF = Acub*f23;
1607 REAL8 dA1SF = dAcub*f23 + Acub*df23;
1608 REAL8 A2SF = 337./28.*u2;
1609 REAL8 dA2SF = 674./28.*u;
1610
1611 REAL8 f0 = 1 + 3*u2*oom3u;
1612 REAL8 f1 = A1SF *pow(oom3u,7./2.);
1613 REAL8 f2 = A2SF *pow(oom3u,p);
1614
1615 REAL8 df0 = 3*u*(2.-rLR*u)*(oom3u*oom3u);
1616 REAL8 df1 = 0.5*(7*rLR*A1SF + 2*(1.-rLR*u)*dA1SF)*pow(oom3u,9./2.);
1617 REAL8 df2 = (rLR*p*A2SF + (1.-rLR*u)*dA2SF)*pow(oom3u,p+1);
1618
1619 /* Gravito-electric tides for el = 2, 4; el = 3 added below as a GSF series */
1620 REAL8 AT2 = - kapA2*u6*( f0 + XA*f1 + XA*XA*f2 ) - kapB2*u6*( f0 + XB*f1 + XB*XB*f2 );
1621 REAL8 AT4 = - kapT4*u10;
1622
1623 REAL8 dAT2 = - kapA2*6.*u5*( f0 + XA*f1 + XA*XA*f2 ) - kapB2*6.*u5*( f0 + XB*f1 + XB*XB*f2 ) - kapA2*u6*( df0 + XA*df1 + XA*XA*df2 ) - kapB2*u6*( df0 + XB*df1 + XB*XB*df2 );
1624 REAL8 dAT4 = - kapT4*10.*u9;
1625
1626 /* el = 3+, i.e., even parity tidal potential **/
1627
1628 /* 1GSF fitting parameters */
1629 const REAL8 C1 = -3.6820949997216643;
1630 const REAL8 C2 = 5.171003322924513;
1631 const REAL8 C3 = -7.639164165720986;
1632 const REAL8 C4 = -8.63278143009751;
1633 const REAL8 C5 = 12.319646912775516;
1634 const REAL8 C6 = 16.36009385150114;
1635
1636 /* 0SF -- el = 3+, i.e., even parity terms */
1637 REAL8 A3hat_Sch = (1.0 - 2.0*u)*( 1.0 + eightthird*u2*oom3u );
1638 REAL8 dA3hat_Sch = (1.0 - 2.0*u)*( eightthird*rLR*u2*oom3u*oom3u + 2.0*eightthird*u*oom3u ) - 2.0*( 1.0 + eightthird*u2*oom3u );
1639 REAL8 d2A3hat_Sch = (1.0 - 2.0*u)*( 2.0*eightthird*rLR*rLR*u2*oom3u*oom3u*oom3u + 4.0*eightthird*rLR*u*oom3u*oom3u + 2.0*eightthird*oom3u ) - 4.0*( eightthird*rLR*u2*oom3u*oom3u + 2.0*eightthird*u*oom3u );
1640
1641 /* 1SF -- el = 3+, i.e., even parity terms */
1642 REAL8 Denom3 = 1./(1. + C5*u2);
1643 REAL8 A3tilde = 7.5*u*( 1 + C1*u + C2*u2 + C3*u3 )*( 1 + C4*u + C6*u2 )*Denom3;
1644 REAL8 dA3tilde = 7.5*( 1 + 3*C2*u2 + 3*C6*u2 + 4*C3*u3 + 5*C2*C6*u4 + 6*C3*C6*u5 + C1*u*(2 + 3*C4*u + 4*C6*u2) + C4*u*(2 + 4*C2*u2 + 5*C3*u3) )*Denom3 + ( -15.*C5*u2*(1. + C4*u + C6*u2)*(1. + C1*u + C2*u2 + C3*u3) )*Denom3*Denom3;
1645 REAL8 d2A3tilde = 15.*( C1*(1 + 3*C4*u - 3*C5*pow(u,2) + 6*C6*pow(u,2) - C4*C5*pow(u,3) + 3*C5*C6*pow(u,4) + pow(C5,2)*C6*pow(u,6)) + C4*(1 - 3*C5*pow(u,2) + 10*C3*pow(u,3) + 9*C3*C5*pow(u,5) + 3*C3*pow(C5,2)*pow(u,7) + C2*pow(u,2)*(6 + 3*C5*pow(u,2) + pow(C5,2)*pow(u,4))) + u*(3*(C6 + 2*C3*u + 5*C3*C6*pow(u,3)) + C5*(-3 - C6*pow(u,2) + 3*C3*pow(u,3) +17*C3*C6*pow(u,5)) + pow(C5,2)*(pow(u,2) + C3*pow(u,5) + 6*C3*C6*pow(u,7)) + C2*(3 + 10*C6*pow(u,2) + 3*pow(C5,2)*C6*pow(u,6) + C5*pow(u,2)*(-1 + 9*C6*pow(u,2)))) )*Denom3*Denom3*Denom3;
1646 REAL8 A3hat1GSFfit = A3tilde*pow(oom3u, 3.5);
1647 REAL8 dA3hat1GSFfit = 3.5*rLR*A3tilde*pow(oom3u, 4.5) + dA3tilde*pow(oom3u, 3.5);
1648 REAL8 d2A3hat1GSFfit = 15.75*rLR*rLR*A3tilde*pow(oom3u, 5.5) + 7.0*rLR*dA3tilde*pow(oom3u, 4.5) + d2A3tilde*pow(oom3u, 3.5);
1649
1650 /* 2SF -- el = 3+, i.e., even parity terms */
1651 REAL8 A3hat2GSF = 36.666666666666666667*u2*pow(oom3u,p);
1652 REAL8 dA3hat2GSF = 36.666666666666666667*u*( 2. + (p - 2.)*rLR*u ) * pow(oom3u, p+1);
1653 REAL8 d2A3hat2GSF = 36.666666666666666667*( 2. + 4.*(p - 1.)*rLR*u + (2. - 3.*p + 1.*p*p)*rLR*rLR*u2 ) * pow(oom3u, p+2);
1654
1655 /* Hatted el = 3+ potential as a GSF series */
1656 REAL8 A3hatA = A3hat_Sch + XA*A3hat1GSFfit + XA*XA*A3hat2GSF;
1657 REAL8 dA3hatA = dA3hat_Sch + XA*dA3hat1GSFfit + XA*XA*dA3hat2GSF;
1658 REAL8 A3hatB = A3hat_Sch + XB*A3hat1GSFfit + XB*XB*A3hat2GSF;
1659 REAL8 dA3hatB = dA3hat_Sch + XB*dA3hat1GSFfit + XB*XB*dA3hat2GSF;
1660
1661 /* Total el = 3+ tidal potential */
1662 REAL8 AT3 = -1.*kapA3*u8*( A3hatA ) - 1.*kapB3*u8*( A3hatB );
1663 REAL8 dAT3 = -1.*kapA3*u7*( 8.*A3hatA + 1.*u*dA3hatA ) - 1.*kapB3*u7*( 8.*A3hatB + 1.*u*dA3hatB );
1664
1665 A = AT2 + AT3 + AT4;
1666 dA_u = dAT2 + dAT3 + dAT4;
1667
1668 if (d2AT != NULL) {
1669 REAL8 d2f23 = 2*d2*(-1 + 3*d2*u2 + n1*u*(-3+d2*u2))*(Den*Den*Den);
1670 REAL8 d2A1SF = d2Acub*f23 + 2*dAcub*df23 + Acub*d2f23;
1671 REAL8 d2A2SF = 674./28.;
1672 REAL8 d2f0 = 6*(oom3u*oom3u*oom3u);
1673 REAL8 d2f1 = 0.25*(63*(rLR*rLR)*A1SF + 4*(-1+rLR*u)*(-7*rLR*dA1SF + (-1+rLR*u)*d2A1SF))*pow(oom3u,11./2.);
1674 REAL8 d2f2 = ( rLR*p*(1+p)*rLR*A2SF +(-1+rLR*u)*( -2.*p*rLR*dA2SF +(-1.+rLR*u)*d2A2SF ) )*pow(oom3u,p+2);
1675
1676 REAL8 d2AT2 = - kapA2*30*u4*( f0 + XA*f1 + XA*XA*f2 ) - kapB2*30*u4*( f0 + XB*f1 + XB*XB*f2 ) - 2*kapA2*6*u5*( df0 + XA*df1 + XA*XA*df2 ) - 2*kapB2*6*u5*( df0 + XB*df1 + XB*XB*df2 ) - kapA2*u6*( d2f0 + XA*d2f1 + XA*XA*d2f2 ) - kapB2*u6*( d2f0 + XB*d2f1 + XB*XB*d2f2 );
1677 REAL8 d2AT4 = - kapT4*90*u8;
1678
1679 REAL8 d2A3hatA = d2A3hat_Sch + XA*d2A3hat1GSFfit + XA*XA*d2A3hat2GSF;
1680 REAL8 d2A3hatB = d2A3hat_Sch + XB*d2A3hat1GSFfit + XB*XB*d2A3hat2GSF;
1681 REAL8 d2AT3 = -1.*kapA3 * ( 56.*u6*A3hatA + 16.*u7*dA3hatA + 1.*u8*d2A3hatA ) - 1.*kapB3 * ( 56.*u6*A3hatB + 16.*u7*dA3hatB + 1.*u8*d2A3hatB );
1682
1683 d2A_u += d2AT2 + d2AT3 + d2AT4;
1684 }
1685 }
1686
1687
1689
1690 /* PN series for the (2-) tidal potential */
1691 A +=-kapT2j*u7*(1. + bar_alph2j_1*u);
1692 dA_u += -kapT2j*u7*bar_alph2j_1 - 7.*kapT2j*u6*(1. + bar_alph2j_1*u);
1693
1694 if (d2AT != NULL) {
1695 d2A_u += - 14.*kapT2j*u5*(3. + 4.*bar_alph2j_1*u);
1696 }
1697
1699
1700 /* GSF series for the (2-) tidal potential */
1701 const REAL8 a1j = 0.728591192;
1702 const REAL8 a2j = 3.100367557;
1703 const REAL8 n1j = -15.04421708;
1704 const REAL8 d2j = 12.55229698;
1705 // Schwarzschild gravito-magnetic term
1706 REAL8 Ahat_Schj = (1.-2.*u)*oom3u;
1707 REAL8 dAhat_Schj = (rLR-2.)*oom3u*oom3u;
1708 REAL8 d2Ahat_Schj = 2.*rLR*(rLR-2.)*pow(oom3u, 3.);
1709
1710 /* 1SF -- el = 2 gravitomagnetic terms */
1711 REAL8 Denomj = 1./(1. + d2j*u2);
1712 REAL8 Ahat1GSFfitj = elsix*u*(1. - a1j*u)*(1. - a2j*u)*(1. + n1j*u)*Denomj*pow(oom3u, 3.5);
1713 REAL8 dAhat1GSFfitj = 0.5*elsix * Denomj * Denomj * (2 + 4*n1j*u + 5*rLR*u - 2*d2j*pow(u,2) + 3*n1j*rLR*pow(u,2) + 9*d2j*rLR*pow(u,3) + 7*d2j*n1j*rLR*pow(u,4) - a2j*u*(4 + rLR*u*(3 + 7*d2j*pow(u,2)) + n1j*u*(6 + 2*d2j*pow(u,2) + rLR*(u + 5*d2j*pow(u,3)))) + a1j*u*(-4 - 3*rLR*u - 7*d2j*rLR*pow(u,3) - n1j*u*(6 + rLR*u + 2*d2j*pow(u,2) + 5*d2j*rLR*pow(u,3)) + a2j*u*(6 + rLR*u + 2*d2j*pow(u,2) + 5*d2j*rLR*pow(u,3) + n1j*u*(8 - rLR*u + 4*d2j*pow(u,2) + 3*d2j*rLR*pow(u,3)))) ) * pow(oom3u, 4.5);
1714 REAL8 d2Ahat1GSFfitj = 0.25*elsix * Denomj * Denomj * Denomj * ( 8*(1 + n1j*u)*pow(-1 + rLR*u,2)*pow(1 + d2j*pow(u,2),2)*(-a2j + a1j*(-1 + 3*a2j*u)) + 4*(1 - rLR*u)*(1 + d2j*pow(u,2))*(1 - 2*a2j*u + a1j*u*(-2 + 3*a2j*u))*(-4*d2j*u + rLR*(7 + 11*d2j*pow(u,2)) + n1j*(2 - 2*d2j*pow(u,2) + rLR*u*(5 + 9*d2j*pow(u,2)))) + u*(-1 + a1j*u)*(-1 + a2j*u)*(7*rLR*(9*rLR + n1j*(4 + 5*rLR*u)) + 2*d2j*(-4 - 20*rLR*u + 87*pow(rLR,2)*pow(u,2) +3*n1j*u*(-4 + 8*rLR*u + 17*pow(rLR,2)*pow(u,2))) + pow(d2j,2)*pow(u,2)*(24 - 104*rLR*u + 143*pow(rLR,2)*pow(u,2) + n1j*u*(8 - 44*rLR*u + 99*pow(rLR,2)*pow(u,2)))) ) * pow(oom3u, 5.5);
1715
1716 /* 2SF -- el = 2 gravitomagnetic terms */
1717 REAL8 Ahat2GSFj = u*pow(oom3u,p);
1718 REAL8 dAhat2GSFj = ( 1.+ (p-1.)*rLR*u ) * pow(oom3u, p+1);
1719 REAL8 d2Ahat2GSFj = p*rLR * ( 2.+ (p-1.)*rLR*u ) * pow(oom3u, p+2);
1720
1721 /* Total el = 2 gravitomagnetic potential as a GSF series */
1722 REAL8 AhatjA = Ahat_Schj + XA*Ahat1GSFfitj + XA*XA*Ahat2GSFj;
1723 REAL8 dAhatjA = dAhat_Schj + XA*dAhat1GSFfitj + XA*XA*dAhat2GSFj;
1724 REAL8 AhatjB = Ahat_Schj + XB*Ahat1GSFfitj + XB*XB*Ahat2GSFj;
1725 REAL8 dAhatjB = dAhat_Schj + XB*dAhat1GSFfitj + XB*XB*dAhat2GSFj;
1726
1727 /* el = 2 gravitomagnetic total contribution */
1728 REAL8 ATj_2 = -1.*kapA2j*u7*( AhatjA ) - 1.*kapB2j*u7*( AhatjB );
1729 REAL8 dATj_2 = -1.*kapA2j * ( 7.*u6*AhatjA + u7*dAhatjA ) - 1.*kapB2j * ( 7.*u6*AhatjB + u7*dAhatjB );
1730
1731 A += ATj_2;
1732 dA_u += dATj_2;
1733
1734 if (d2AT != NULL) {
1735 REAL8 d2AhatjA = d2Ahat_Schj + XA*d2Ahat1GSFfitj + XA*XA*d2Ahat2GSFj;
1736 REAL8 d2AhatjB = d2Ahat_Schj + XB*d2Ahat1GSFfitj + XB*XB*d2Ahat2GSFj;
1737 REAL8 d2ATj_2 = -1.*kapA2j * ( 42.*u5*AhatjA + 14.*u6*dAhatjA + u7*d2AhatjA ) - 1.*kapB2j * ( 42.*u5*AhatjB + 14.*u6*dAhatjB + u7*d2AhatjB );
1738
1739 d2A_u += d2ATj_2;
1740 }
1741
1742 }
1743
1744 *AT = A;
1745 *dAT = dA_u;
1746 if (d2AT != NULL) *d2AT = d2A_u;
1747
1748 return;
1749}
1750
1751/* EOB Metric potentials A(r), B(r), and their derivatives, no spin version */
1754 REAL8 *A,
1755 REAL8 *B,
1756 REAL8 *dA,
1757 REAL8 *d2A,
1758 REAL8 *dB)
1759{
1760 const REAL8 nu = dyn->nu;
1761 const REAL8 u = 1./r;
1762 const REAL8 u2 = u*u;
1763 const REAL8 u3 = u2*u;
1764 const REAL8 u4 = u2*u2;
1765 const REAL8 UNUSED u6 = u2*u4;
1766
1767 REAL8 Atmp=0., dAtmp_u=0., d2Atmp_u=0.;
1768 REAL8 Btmp=0., dBtmp_r=0.;
1769
1770 /* A potential and derivative with respect to u */
1771 eob_metric_A5PNlog(r, nu, &Atmp, &dAtmp_u, &d2Atmp_u);
1772
1773 /* Add here tides if needed */
1774 if (dyn->use_tidal) {
1775 REAL8 AT, dAT_u, d2AT_u;
1776 REAL8 UNUSED BT, UNUSED dBT;
1777 eob_metric_Atidal(r, dyn, &AT, &dAT_u, &d2AT_u);
1778 Atmp += AT;
1779 dAtmp_u += dAT_u;
1780 d2Atmp_u += d2AT_u;
1781#if (USEBTIDALPOTENTIAL)
1782 /* Vines, Flanagan 1PN term in B */
1783 REAL8 kT2 = dyn->kapT2;
1784 BT = kT2*(8. - 15.*nu)*u6;
1785 dBT = -kT2*6.*(8. - 15.*nu)*u4*u3;
1786 Btmp += BT;
1787 dBtmp_r += dBT;
1788#endif
1789 }
1790
1791 /* A potential and derivative with respect to r */
1792 *A = Atmp;
1793 *dA = -dAtmp_u*u2;
1794 *d2A = 2.*dAtmp_u*u3 + d2Atmp_u*u4;
1795
1796 /* D potential and derivative with respect to r */
1797 const REAL8 Dp = 1.0 + 6.*nu*u2 - 2.*(3.0*nu-26.0)*nu*u3; // Pade' resummation of D
1798 const REAL8 D = 1./Dp;
1799 const REAL8 dD = 6.*u2*(2.*nu*u-(3.*nu-26.)*nu*u2)*D*D;
1800
1801 /* B potential and derivative with respect to r */
1802 Btmp += D/(Atmp);
1803 dBtmp_r += (dD*(Atmp) - D*(*dA))/((Atmp)*(Atmp));
1804
1805 *B = Btmp;
1806 *dB = dBtmp_r;
1807
1808}
1809
1810/* EOB Metric potentials A(r), B(r), and their derivatives, spin version */
1812{
1813
1814 const REAL8 nu = dyn->nu;
1815 const REAL8 a1 = dyn->a1;
1816 const REAL8 a2 = dyn->a2;
1817 const REAL8 aK2 = dyn->aK2;
1818 const REAL8 C_Q1 = dyn->C_Q1;
1819 const REAL8 C_Q2 = dyn->C_Q2;
1820 const REAL8 C_Oct1 = dyn->C_Oct1;
1821 const REAL8 C_Oct2 = dyn->C_Oct2;
1822 const REAL8 C_Hex1 = dyn->C_Hex1;
1823 const REAL8 C_Hex2 = dyn->C_Hex2;
1824 const int usetidal = dyn->use_tidal;
1825
1826 const REAL8 u = 1./r;
1827 const REAL8 u2 = u*u;
1828 const REAL8 u3 = u2*u;
1829 const REAL8 u4 = u2*u2;
1830
1831 REAL8 rc, drc, d2rc;
1832 dyn->eob_dyn_s_get_rc(r, nu, a1, a2, aK2, C_Q1, C_Q2, C_Oct1, C_Oct2, C_Hex1, C_Hex2, usetidal, &rc, &drc, &d2rc);
1833
1834 /* A potential and derivative with respect to u */
1835 REAL8 Aorb, dAorb_u, d2Aorb_u;
1836 eob_metric_A5PNlog(rc, nu, &Aorb, &dAorb_u, &d2Aorb_u);
1837
1838 /* Add here tides if needed */
1839 if (usetidal) {
1840 REAL8 AT, dAT_u, d2AT_u;
1841 eob_metric_Atidal(rc, dyn, &AT, &dAT_u, &d2AT_u);
1842 Aorb += AT;
1843 dAorb_u += dAT_u;
1844 d2Aorb_u += d2AT_u;
1845 }
1846
1847 /* A potential and derivative with respect to r */
1848 REAL8 uc = 1./rc;
1849 REAL8 uc2 = uc*uc;
1850 REAL8 uc3 = uc2*uc;
1851 REAL8 uc4 = uc2*uc2;
1852
1853 REAL8 dAorb = -dAorb_u*uc2;
1854 REAL8 d2Aorb = 2.*dAorb_u*uc3 + d2Aorb_u*uc4;
1855
1856 /* Correct A for spin */
1857 REAL8 AKerr_Multipole = (1.+2.*uc)/(1.+2.*u);
1858 REAL8 fss = 1.;
1859
1860 *A = Aorb*AKerr_Multipole*fss;
1861 *dA = dAorb*drc*(1.+2.*uc)/(1.+2.*u) - 2.*Aorb*drc*uc2/(1.+2.*u) + 2.*Aorb*(1.+2.*uc)*u2/((1.+2.*u)*(1.+2.*u));
1862 *d2A = d2Aorb*(1.+2.*uc)/(1.+2.*u) + 4.*dAorb*( u2*(1.+2.*uc)/((1.+2.*u)*(1.+2.*u)) - uc2/(1.+2.*u)*drc) + Aorb*(-4.*u3*(1.+2.*uc)/((1.+2.*u)*(1.+2.*u)) + 8.*u4*(1.+2.*uc)/((1.+2.*u)*(1.+2.*u)*(1.+2.*u))+4.*uc3*(1.+2.*u)*drc*drc - 2.*uc2/(1.+2.*u)*d2rc);
1863
1864 /* D potential and derivative with respect to r */
1865 REAL8 Dp = 1.0 + 6.*nu*uc2 - 2.*(3.0*nu-26.0)*nu*uc3; // Pade' resummation of D
1866 REAL8 D = 1./Dp;
1867 REAL8 dD = 6.*uc2*(2.*nu*uc-(3.*nu-26.)*nu*uc2)*D*D;
1868
1869 /* B potential and derivative with respect to r */
1870 *B = r*r*uc2*D/(*A);
1871 *dB = (dD*(*A) - D*(*dA))/((*A)*(*A));
1872
1873 /* Add here tides if needed */
1874
1875}
1876
1877/* Newtonian partial fluxes */
1879{
1880
1881 /* Shorthands*/
1882 const REAL8 nu2 = nu*nu;
1883 const REAL8 nu3 = nu2*nu;
1884 const REAL8 x5 = x*x*x*x*x;
1885 const REAL8 x6 = x*x5;
1886 const REAL8 x7 = x*x6;
1887 const REAL8 x8 = x*x7;
1888 const REAL8 x9 = x*x8;
1889 const REAL8 x10 = x*x9;
1890 const REAL8 x11 = x*x10;
1891 const REAL8 x12 = x*x11;
1892
1893 const REAL8 sp2 = 1.-4.*nu;
1894 const REAL8 sp4 = (1-4*nu)*SQ((1-2*nu));
1895 const REAL8 sp3 = (1.-3.*nu)*(1.-3.*nu);
1896 const REAL8 sp5 = (1.-5.*nu+5.*nu2)*(1.-5.*nu+5.*nu2);
1897 const REAL8 sp6 = (1-4*nu)*(3*nu2-4*nu +1)*(3*nu2-4*nu +1);
1898 const REAL8 sp7 = (1 - 7*nu + 14*nu2 - 7*nu3)*(1 - 7*nu + 14*nu2 - 7*nu3);
1899 const REAL8 sp8 = (1 - 4*nu)*(1 - 6*nu + 10*nu2 - 4*nu3)*(1 - 6*nu + 10*nu2 - 4*nu3);
1900
1901 REAL8 spx[] = {
1902 sp2 * x6, x5,
1903 sp2 * x6, sp3 * x7, sp2 * x6,
1904 sp4 * x8, sp3 * x7, sp4 * x8, sp3 * x7,
1905 sp4 * x8, sp5 * x9, sp4 * x8, sp5 * x9, sp4 * x8,
1906 sp6 * x10, sp5 * x9, sp6 * x10, sp5 * x9, sp6 * x10, sp5 * x9,
1907 sp6 * x10, sp7 * x11, sp6 * x10, sp7 * x11, sp6 * x10, sp7 * x11, sp6 * x10,
1908 sp8 * x12, sp7 * x11, sp8 * x12, sp7 * x11, sp8 * x12, sp7 * x11, sp8 * x12, (7*nu3-14*nu2+7*nu-1)*(7*nu3-14*nu2+7*nu-1) * x11
1909 };
1910
1911 /* Newtonian partial fluxes*/
1912 for (int k = 0; k < KMAX; k++) {
1913 Nlm[k] = CNlm[k] * spx[k];
1914 }
1915
1916 return;
1917}
1918
1919/* Factorials evaluated for the tail term */
1920static const REAL8 f14[] =
1921{1., 1., 2.,
1922 6., 24., 120.,
1923 720., 5040., 40320.,
1924 362880., 3628800., 39916800.,
1925 479001600., 6227020800., 87178291200.};
1926
1927
1928/* Tail term (modulus) */
1929void eob_flx_Tlm(const REAL8 w, REAL8 *MTlm)
1930{
1931 REAL8 hhatk, x2, y, prod;
1932 INT4 k, j;
1933 for (k = 0; k < KMAX; k++ ) {
1934 hhatk = TEOB_MINDEX[k] * w;
1935 x2 = 4.*hhatk*hhatk;
1936 prod = 1.;
1937 for (j=1; j <= TEOB_LINDEX[k]; j++ ) {
1938 prod *= ( j*j + x2 );
1939 }
1940 y = 4.*LAL_PI*hhatk;
1941 y /= ( 1. - exp(-y) );
1942 MTlm[k] = sqrt( 1./(f14[TEOB_LINDEX[k]]*f14[TEOB_LINDEX[k]]) * y * prod );
1943 }
1944 return;
1945}
1946
1947
1948/* Compute horizon-absorbed fluxes. no spin case.
1949 * Nagar & Akcay, PRD 85, 044025 (2012)
1950 * Bernuzzi, Nagar & Zenginoglu, PRD 86, 104038 (2012)
1951 */
1953{
1954 REAL8 rhoHlm[2]; /* only 21,22 multipoles -> k=0,1 */
1955 REAL8 FlmHLO[2];
1956 REAL8 FlmH[2];
1957
1958 /* Shorthands */
1959 REAL8 nu2 = nu*nu;
1960 REAL8 nu3 = nu*nu2;
1961 REAL8 x2 = x*x;
1962 REAL8 x3 = x*x2;
1963 REAL8 x4 = x*x3;
1964 REAL8 x5 = x*x4;
1965 REAL8 x9 = x4*x5;
1966 REAL8 x10 = x*x9;
1967
1968 /* The Newtonian asymptotic contribution */
1969 const REAL8 FNewt22 = 32./5.*x5;
1970
1971 /* Compute leading-order part (nu-dependent) */
1972 FlmHLO[1] = 32./5.*(1-4*nu+2*nu2)*x9;
1973 FlmHLO[0] = 32./5.*(1-4*nu+2*nu2)*x10;
1974
1975 /* Compute rho_lm */
1976 REAL8 c1[2];
1977 REAL8 c2[2];
1978 REAL8 c3[2];
1979 REAL8 c4[2];
1980
1981 c1[0] = 0.58121;
1982 c2[0] = 1.01059;
1983 c3[0] = 7.955729;
1984 c4[0] = 1.650228;
1985
1986 c1[1] = (4.-21.*nu + 27.*nu2 - 8.*nu3)/(4.*(1.-4.*nu+2.*nu2));
1987 c2[1] = 4.78752;
1988 c3[1] = 26.760136;
1989 c4[1] = 43.861478;
1990
1991 rhoHlm[1] = 1. + c1[1]*x + c2[1]*x2 + c3[1]*x3 + c4[1]*x4;
1992 rhoHlm[0] = 1. + c1[0]*x + c2[0]*x2 + c3[0]*x3 + c4[0]*x4;
1993
1994 /* Compute horizon multipolar flux (only l=2) */
1995 const REAL8 Heff2 = Heff*Heff;
1996 const REAL8 jhat2 = jhat*jhat;
1997
1998 FlmH[1] = FlmHLO[1] * Heff2 * gsl_pow_int(rhoHlm[1],4);
1999 FlmH[0] = FlmHLO[0] * jhat2 * gsl_pow_int(rhoHlm[0],4);
2000
2001 /* Sum over multipoles and normalize to the 22 Newtonian multipole */
2002 REAL8 hatFH = (FlmH[0]+FlmH[1])/FNewt22;
2003
2004 return hatFH;
2005}
2006
2007
2008/* Compute horizon-absorbed fluxes. spin case. */
2010 REAL8 UNUSED Heff,
2011 REAL8 UNUSED jhat,
2012 REAL8 UNUSED nu,
2013 REAL8 X1,
2014 REAL8 X2,
2015 REAL8 chi1,
2016 REAL8 chi2)
2017{
2018
2019 REAL8 x2 = x*x;
2020 REAL8 x3 = x2*x;
2021 REAL8 x4 = x3*x;
2022 REAL8 x5 = x4*x;
2023 REAL8 v5 = sqrt(x5);
2024
2025 REAL8 cv5[2];
2026 REAL8 cv8[2];
2027
2028 /* Coefficients of the v^5 term (Alvi leading order) */
2029 cv5[0] = -1./4.*chi1*(1.+3.*chi1*chi1)*X1*X1*X1;
2030 cv5[1] = -1./4.*chi2*(1.+3.*chi2*chi2)*X2*X2*X2;
2031
2032 /* Coefficients of the v^8=x^4 term */
2033 cv8[0] = 0.5*(1.+sqrt(1.-chi1*chi1))*(1.+3.*chi1*chi1)*X1*X1*X1*X1;
2034 cv8[1] = 0.5*(1.+sqrt(1.-chi2*chi2))*(1.+3.*chi2*chi2)*X2*X2*X2*X2;
2035
2036 REAL8 FH22_S = (cv5[0]+cv5[1])*v5;
2037 REAL8 FH22 = (cv8[0]+cv8[1])*x4;
2038 REAL8 FH21 = 0.0;
2039
2040 /* Newton-normalized horizon flux: use only l=2 fluxes */
2041 REAL8 hatFH = FH22_S + FH22 + FH21;
2042
2043 return hatFH;
2044}
2045
2046
2047/* Flux calculation for spinning systems */
2048// TODO: NQC are not applied in spin case!
2050 REAL8 Omega,
2051 REAL8 r_omega,
2052 REAL8 E,
2053 REAL8 Heff,
2054 REAL8 jhat,
2055 REAL8 r,
2056 REAL8 pr_star,
2057 REAL8 ddotr,
2059{
2060 const REAL8 nu = dyn->nu;
2061 const REAL8 chi1 = dyn->chi1;
2062 const REAL8 chi2 = dyn->chi2;
2063 const REAL8 X1 = dyn->X1;
2064 const REAL8 X2 = dyn->X2;
2065 const REAL8 a1 = dyn->a1;
2066 const REAL8 a2 = dyn->a2;
2067 const REAL8 C_Q1 = dyn->C_Q1;
2068 const REAL8 C_Q2 = dyn->C_Q2;
2069 const REAL8 X12 = X1-X2; /* sqrt(1-4nu) */
2070 const REAL8 UNUSED X12sq = SQ(X12); /* (1-4nu) */
2071
2072 const INT4 usetidal = dyn->use_tidal;
2073 const INT4 usespins = dyn->use_spins;
2074
2075 REAL8 prefact[] = {
2076 jhat, Heff,
2077 Heff, jhat, Heff,
2078 jhat, Heff, jhat, Heff,
2079 Heff, jhat, Heff, jhat, Heff,
2080 jhat, Heff, jhat, Heff, jhat, Heff,
2081 Heff, jhat, Heff, jhat, Heff, jhat, Heff,
2082 jhat, Heff, jhat, Heff, jhat, Heff, jhat, Heff};
2083
2084 REAL8 FNewt22, sum_k=0.;
2085 REAL8 rholm[KMAX], flm[KMAX], FNewtlm[KMAX], MTlm[KMAX], hlmTidal[KMAX], hlmNQC[KMAX];
2086 REAL8 Modhhatlm[KMAX];
2087
2088 /* Newtonian flux */
2089 eob_flx_FlmNewt(x, nu, FNewtlm);
2090
2091 /* Correct amplitudes for specific multipoles and cases */
2092 if (usespins) {
2093 /* Correct (2,1), (3,1) and (3,3) ( sp2 = 1 ) */
2094 REAL8 x6 = gsl_pow_int(x, 6);
2095 FNewtlm[0] = CNlm[0] * x6; /* (2,1) */
2096 FNewtlm[2] = CNlm[2] * x6; /* (3,1) */
2097 FNewtlm[4] = CNlm[4] * x6; /* (3,3) */
2098 /* Correct (4,1), (4,3) ( sp4 = (1-2nu)^2 ) */
2099 REAL8 sp4x8 = SQ((1-2*nu)) * gsl_pow_int(x, 8);
2100 FNewtlm[5] = CNlm[5] * sp4x8; /* (4,1) */
2101 FNewtlm[7] = CNlm[7] * sp4x8; /* (4,3) */
2102 } else {
2103 if (usetidal) {
2104 /* Correct (2,1), (3,1) and (3,3) ( sp2 = 1 ) */
2105 REAL8 x6 = gsl_pow_int(x, 6);
2106 FNewtlm[0] = CNlm[0] * x6; /* (2,1) */
2107 FNewtlm[2] = CNlm[2] * x6; /* (3,1) */
2108 FNewtlm[4] = CNlm[4] * x6; /* (3,3) */
2109 }
2110 }
2111
2112 /* Tail term */
2113 eob_flx_Tlm(E*Omega, MTlm);
2114
2115 /* Amplitudes */
2116 if (usespins) {
2117 //dyn->eob_wav_flm_s_old(x,nu, X1,X2,chi1,chi2,a1,a2,C_Q1,C_Q2, usetidal, rholm, flm);
2118 dyn->eob_wav_flm_s(x, nu, X1, X2, chi1, chi2, a1, a2, C_Q1, C_Q2, dyn->clm, usetidal, rholm, flm);
2119 } else {
2120 //eob_wav_flm_old(x,nu, rholm, flm);
2121 eob_wav_flm(x, nu, dyn->clm, rholm, flm);
2122 }
2123
2124 FNewt22 = FNewtlm[1];
2125
2126 /* NQC correction to the modulus of the (l,m) waveform */
2127 for (int k = 0; k < KMAX; k++) hlmNQC[k] = 1.; /* no NQC */
2128
2129 if (dyn->nqc_coeffs_flx != NQC_OFF)
2130 {
2132 /* eob_wav_hlmNQC_nospin201602(nu,r,pr_star,Omega,ddotr, &hNQC); */
2133 eob_wav_hlmNQC(nu, r, pr_star, Omega, ddotr, dyn->NQC->flx, &hNQC);
2134 /*
2135 const INT4 UNUSED maxk = MIN(KMAX, NQC->hlm->maxk+1);
2136 for (int k = 0; k < maxk; k++) {
2137 if (NQC->hlm->activemode[k]) {
2138 hlmNQC[k] = hNQC.ampli[k];
2139 }
2140 }
2141 */
2142 /* Use only the 22: */
2143 hlmNQC[1] = hNQC.ampli[1];
2144 }
2145
2146 /* Compute modulus of hhat_lm (with NQC) */
2147 for (int k = 0; k < KMAX; k++) {
2148 Modhhatlm[k] = prefact[k] * MTlm[k] * flm[k] * hlmNQC[k];
2149 }
2150
2151 if (usetidal) {
2152 /* Tidal amplitudes */
2153 eob_wav_hlmTidal(x, dyn, hlmTidal);
2154 if (!(usespins)) {
2155 /* Correct normalization of (2,1) (3,1), (3,3) point-mass amplitudes */
2156 Modhhatlm[0] *= X12;
2157 Modhhatlm[2] *= X12;
2158 Modhhatlm[4] *= X12;
2159 }
2160 /* Add tidal amplitudes */
2161 for (int k = 0; k < KMAX; k++) {
2162 Modhhatlm[k] += MTlm[k] * hlmTidal[k];
2163 }
2164 }
2165
2166 /* Total multipolar flux */
2167 for (int k = KMAX; k--;) sum_k += SQ(Modhhatlm[k]) * FNewtlm[k];
2168
2169 /* Normalize to the 22 Newtonian multipole */
2170 REAL8 hatf = sum_k/(FNewt22);
2171
2172 /* Horizon flux */
2173 if (!(usetidal)) {
2174 REAL8 hatFH;
2175 if (usespins) {
2176 hatFH = eob_flx_HorizonFlux_s(x, Heff, jhat, nu, X1, X2, chi1, chi2);
2177 } else {
2178 hatFH = eob_flx_HorizonFlux(x,Heff,jhat,nu);
2179 }
2180 hatf += hatFH;
2181 }
2182
2183 /* return Fphi */
2184 return (-32./5. * nu * gsl_pow_int(r_omega,4) * gsl_pow_int(Omega,5) * hatf);
2185}
2186
2187
2188/* Flux calculation for Newton-Normalized energy flux
2189 Use the DIN resummation procedure.
2190 Add non-QC and non-K corrections to (2,2) partial flux. */
2192 REAL8 Omega,
2193 REAL8 r_omega,
2194 REAL8 E,
2195 REAL8 Heff,
2196 REAL8 jhat,
2197 REAL8 r,
2198 REAL8 pr_star,
2199 REAL8 ddotr,
2201{
2202 return eob_flx_Flux_s(x, Omega, r_omega, E, Heff, jhat, r, pr_star, ddotr,dyn);
2203}
2204
2205
2206/* Alternative implementation of the phase of the tail factor */
2208{
2209 REAL8 x;
2210 REAL8 x2;
2211 REAL8 x3;
2212 REAL8 x4;
2213 REAL8 x5;
2214 REAL8 tlm_ang;
2215 REAL8 num_ang;
2216
2217 /* Fit coefficients*/
2218 const REAL8 b1[] = {
2219 0.1113090643348557, 0.1112593821157397, 0.0424759238428813, 0.0424489015884926, 0.0424717446800903, 0.0215953972500844, 0.0215873812155663, 0.0215776183122621, 0.0216017621863542, 0.0128123696874894, 0.0128097056242375, 0.0128038943888768, 0.0128025242617949, 0.0128202485907368, 0.0083762045692408, 0.0083751913886140, 0.0083724067460769, 0.0083694435961860, 0.0083710364141552, 0.0083834483913443, 0.0058540393221396, 0.0058536069384738, 0.0058522594457692, 0.0058502436535615, 0.0058491157293566, 0.0058514875071582, 0.0058602498033381, 0.0042956812356573, 0.0042954784390887, 0.0042947951664056, 0.0042935886137697, 0.0042923691461384, 0.0042922256848799, 0.0042945927126022, 0.0043009106861259};
2220
2221 const REAL8 b2[] = {
2222 0.0004643273300862, 0.0009375605440004, 0.0000597134489198, 0.0002551406918111, 0.0001741036904709, 0.0000124649041611, 0.0000685496215625, 0.0001131160409390, 0.0000419907542591, 0.0000035218982282, 0.0000219211271097, 0.0000473186962874, 0.0000524142634057, 0.0000106823372552, 0.0000012237574387, 0.0000081742188269, 0.0000201940563214, 0.0000295722761753, 0.0000260539631956, 0.0000018994753518, 0.0000004932942990, 0.0000034477210351, 0.0000092294406360, 0.0000155143073237, 0.0000183386499818, 0.0000137922469695, -0.0000007075155453, 0.0000002223410995, 0.0000016045317657, 0.0000045260028113, 0.0000082655700107, 0.0000112393599417, 0.0000115758243113, 0.0000076838709956, -0.0000014020591745};
2223
2224 const REAL8 b3[] = {
2225 -0.0221835462237291, -0.0235386333304348, -0.0042911639711832, -0.0047431560217121, -0.0046577314472149, -0.0013089557502947, -0.0014343968205390, -0.0014978542575474, -0.0014329302934532, -0.0005167994164556, -0.0005573939123058, -0.0005921030407223, -0.0005978284714483, -0.0005673965369076, -0.0002409269302708, -0.0002561516055118, -0.0002723768586352, -0.0002815958312453, -0.0002792078156272, -0.0002646630240693, -0.0001261183503407, -0.0001325622938779, -0.0001403198638518, -0.0001464084186977, -0.0001485971591029, -0.0001459023931717, -0.0001384829633836, -0.0000719062974278, -0.0000749128468013, -0.0000788187384314, -0.0000824202283094, -0.0000846673495936, -0.0000849054394951, -0.0000829269749240, -0.0000788883333858};
2226
2227 const REAL8 b4[] = {
2228 0.0058366730167965, 0.0070452306758401, 0.0006914295465364, 0.0010322294603561, 0.0010057563135650, 0.0001394203795507, 0.0002309706405978, 0.0002596611624417, 0.0002409588083156, 0.0000386949167221, 0.0000679154947896, 0.0000830199015202, 0.0000850120755064, 0.0000780125513602, 0.0000133034384660, 0.0000241813441339, 0.0000311573885555, 0.0000340233089866, 0.0000335167900637, 0.0000307571022927, 0.0000053305073331, 0.0000099143129290, 0.0000132296989826, 0.0000150959309402, 0.0000156304390748, 0.0000151274875147, 0.0000139320508803, 0.0000023959090314, 0.0000045285807761, 0.0000061918979830, 0.0000072894226381, 0.0000078251853305, 0.0000078772667984, 0.0000075606242809, 0.0000069956215270
2229 };
2230
2231 REAL8 Tlm_real[KMAX];
2232 eob_flx_Tlm(Omega*Hreal, Tlm_real);
2233
2234 /* Pre-computed psi */
2235 const REAL8 psi[] = {0.9227843350984671394, 0.9227843350984671394,
2236 1.256117668431800473, 1.256117668431800473, 1.256117668431800473,
2237 1.506117668431800473, 1.506117668431800473, 1.506117668431800473, 1.506117668431800473,
2238 1.706117668431800473, 1.706117668431800473, 1.706117668431800473, 1.706117668431800473, 1.706117668431800473,
2239 1.872784335098467139, 1.872784335098467139, 1.872784335098467139, 1.872784335098467139, 1.872784335098467139, 1.872784335098467139,
2240 2.015641477955609997, 2.015641477955609997, 2.015641477955609997, 2.015641477955609997, 2.015641477955609997, 2.015641477955609997, 2.015641477955609997,
2241 2.140641477955609997, 2.140641477955609997, 2.140641477955609997, 2.140641477955609997, 2.140641477955609997, 2.140641477955609997, 2.140641477955609997, 2.140641477955609997};
2242
2243 REAL8 k;
2244 int i;
2245 // TODO: [optimization] vectorize?
2246 for (i=0; i<KMAX; i++) {
2247 k = TEOB_MINDEX[i] * Omega;
2248 x = k * Hreal; /* hathatk */
2249 x2 = x * x;
2250 x3 = x2 * x;
2251 x4 = x3 * x;
2252 x5 = x4 * x;
2253 num_ang = 1. + b1[i]*x2 + b2[i]*x3 + b3[i]*x4 + b4[i]*x5;
2254 tlm_ang = (- 2. * psi[i] * x * num_ang) + 2.*x* log(2. * k * bphys);
2255 tlm->ampli[i] = Tlm_real[i];
2256 tlm->phase[i] = tlm_ang;
2257 }
2258
2259}
2260
2261/* Tail contribution to the resummed wave.
2262 Ref. Damour, Iyer & Nagar, PRD 79, 064004 (2009) */
2264{
2265 REAL8 k;
2266 REAL8 hhatk;
2267
2268 gsl_sf_result num_rad;
2269 gsl_sf_result num_phase;
2270 gsl_sf_result denom_rad;
2271 gsl_sf_result denom_phase;
2272
2273 REAL8 ratio_rad;
2274 REAL8 ratio_ang;
2275 REAL8 tlm_rad;
2276 REAL8 tlm_phase;
2277
2278 int i;
2279 for (i = 0; i < KMAX; i++) {
2280 k = TEOB_MINDEX[i] * Omega;
2281 hhatk = k * Hreal;
2282
2283 gsl_sf_lngamma_complex_e((double) TEOB_LINDEX[i] + 1., (double) (-2.*hhatk), &num_rad, &num_phase);
2284 gsl_sf_lngamma_complex_e((double) TEOB_LINDEX[i] + 1., 0., &denom_rad, &denom_phase);
2285
2286 ratio_rad = (REAL8) (num_rad.val - denom_rad.val);
2287 ratio_ang = (REAL8) num_phase.val - 0.;
2288
2289 tlm_rad = ratio_rad + LAL_PI * hhatk;
2290 tlm_phase = ratio_ang + 2.*hhatk*log(2.*k*bphys);
2291
2292 tlm->ampli[i] = exp(tlm_rad);
2293 tlm->phase[i] = tlm_phase;
2294 }
2295
2296}
2297
2298
2299/* Resummed amplitudes for the spin case.
2300 This function computes the residual amplitude corrections flm's as
2301 introduced in Damour, Iyer & Nagar, PRD 79, 064004 (2008).
2302 The orbital part is taken at the usual 3^{+2} PN order, i.e. 3PN terms
2303 are integrated by the 4PN and 5PN test-particle terms, with the higher
2304 modes obtained by Fujita & Iyer.
2305 It only includes spin-spin interaction at LO for the (2,2) mode.
2306 Note that the variables called here (a1,a2)
2307 are what we usually cal \f$tilde{a}_1\f$ and \f$tilde{a}_2\f$ and are defined as
2308 a1 = X1*chi1, a2=X2*chi2 and are passed here as parameters. Special
2309 combinations of these quantities are used here to write the spin-dependent
2310 part of the waveform in particularly compact form, so that the (spinning)
2311 test-particle limit is recovered just by visual inspection of the equations */
2313 REAL8 nu,
2314 REAL8 X1,
2315 REAL8 X2,
2316 REAL8 UNUSED chi1,
2317 REAL8 UNUSED chi2,
2318 REAL8 a1,
2319 REAL8 a2,
2320 REAL8 C_Q1,
2321 REAL8 C_Q2,
2322 REAL8 clm[KMAX][6],
2323 int usetidal,
2324 REAL8 *rholm,
2325 REAL8 *flm)
2326{
2327
2328 /* Orbital part */
2329 eob_wav_flm(x, nu, clm, rholm, flm);
2330
2331 /* Spin corrections */
2332 REAL8 rho22S;
2333 REAL8 rho32S;
2334 REAL8 rho44S;
2335 REAL8 rho42S;
2336 REAL8 f21S;
2337 REAL8 f33S;
2338 REAL8 f31S;
2339 REAL8 f43S;
2340 REAL8 f41S;
2341
2342 const REAL8 a0 = a1+a2;
2343 const REAL8 a12 = a1-a2;
2344 const REAL8 X12 = X1-X2;
2345 const REAL8 a0X12 = a0*X12;
2346 const REAL8 a12X12 = a12*X12;
2347
2348 const REAL8 v = sqrt(x);
2349 const REAL8 v2 = x;
2350 const REAL8 v3 = v*v2;
2351 const REAL8 v4 = v3*v;
2352 const REAL8 v5 = v4*v;
2353
2354 /* l=m=2 multipole */
2355 /* spin-orbit */
2356 const REAL8 cSO_lo = (-0.5*a0 - a12X12/6.);
2357 const REAL8 cSO_nlo = (-52./63.-19./504.*nu)*a0 - (50./63.+209./504.*nu)*a12X12;
2358
2359 /* SPIN-SPIN contribution */
2360 REAL8 cSS_lo;
2361 if (usetidal) {
2362#if (RC_EXCLUDESPINSPINTIDES)
2363 /* Switch off spin-spin-tidal couplings */
2364 /* See also: eob_dyn_s_get_rc() */
2365 cSS_lo = 0.;
2366 /* Above code switch off everything,
2367 Alt. one can set C_Q1=C_Q2=0, but keep the term: */
2368 /*
2369 cSS_lo = a1*a2;
2370 */
2371#else
2372 cSS_lo = 0.5*(C_Q1*a1*a1 + 2.*a1*a2 + C_Q2*a2*a2);
2373#endif
2374 } else {
2375 cSS_lo = 0.5*a0*a0;
2376 }
2377
2378 /* rho_22^S: Eq. (80) of Damour & Nagar, PRD 90, 044018 (2014) */
2379 rho22S = cSO_lo*v3 + cSS_lo*v4 + cSO_nlo*v5 ;
2380
2381 /* l>=3, m=even: multipoles rewritten in compact and self-explanatory form */
2382 rho32S = (a0-a12X12)/(3.*(1.-3.*nu))*v;
2383 rho44S = (-19./30.*a0 - (1.-21.*nu)/(30.-90.*nu)*a12X12)*v3;
2384 rho42S = ( -1./30.*a0 - (19.-39.*nu)/(30.-90.*nu)*a12X12)*v3;
2385
2386 /* l>=2, m=odd: multipoles rewritten in compact and self-explanatory form */
2387 f21S = -1.5*a12*v + ((110./21. + 79./84.*nu)*a12 - 13./84.*a0X12)*v3;
2388 f33S = ((-0.25 + 2.5*nu)*a12 - 1.75*a0X12)*v3;
2389 f31S = ((-2.25 + 6.5*nu)*a12 + 0.25*a0X12)*v3;
2390 f43S = (( 5. -10.*nu)*a12 - 5.*a0X12)/(-4.+8.*nu)*v;
2391 f41S = f43S;
2392
2393 /* Amplitudes (correct with spin terms) */
2394 flm[0] = SQ(rholm[0]);
2395 flm[0] = (X12*flm[0] + f21S);
2396
2397 flm[1] = SQ(rholm[1]+ rho22S);
2398
2399 flm[2] = gsl_pow_int(rholm[2], 3);
2400 flm[2] = (X12*flm[2] + f31S);
2401
2402 flm[3] = gsl_pow_int(rholm[3]+ rho32S, 3);
2403
2404 flm[4] = gsl_pow_int(rholm[4], 3);
2405 flm[4] = (X12*flm[4] + f33S);
2406
2407 flm[5] = gsl_pow_int(rholm[5], 4);
2408 flm[5] = (X12*flm[5] + f41S);
2409
2410 flm[6] = gsl_pow_int(rholm[6] + rho42S, 4);
2411
2412 flm[7] = gsl_pow_int(rholm[7], 4);
2413 flm[7] = (X12*flm[7] + f43S);
2414
2415 flm[8] = gsl_pow_int(rholm[8] + rho44S, 4);
2416
2417}
2418
2419/*
2420 Resummed amplitudes for the spin case.
2421 This function computes the residual amplitude corrections flm's as
2422 introduced in Damour, Iyer & Nagar, PRD 79, 064004 (2008).
2423 The orbital part is taken at the usual 3^{+2} PN order, i.e. 3PN terms
2424 are integrated by the 4PN and 5PN test-particle terms, with the higher
2425 modes obtained by Fujita & Iyer.
2426 The function includes spin-spin interaction at NLO for the (2,2) mode
2427 and at LO for the (2,1),(3,1) and (3,3) modes.
2428 Note that the variables called here (a1,a2)
2429 are what we usually cal \f$tilde{a}_1\f$ and \f$tilde{a}_2\f$ and are defined as
2430 a1 = X1*chi1, a2=X2*chi2 and are passed here as parameters. */
2432 REAL8 nu,
2433 REAL8 X1,
2434 REAL8 X2,
2435 REAL8 UNUSED chi1,
2436 REAL8 UNUSED chi2,
2437 REAL8 a1,
2438 REAL8 a2,
2439 REAL8 C_Q1,
2440 REAL8 C_Q2,
2441 REAL8 clm[KMAX][6],
2442 int usetidal,
2443 REAL8 *rholm,
2444 REAL8 *flm)
2445{
2446
2447 /* Orbital part */
2448 eob_wav_flm(x, nu, clm, rholm, flm);
2449
2450 /* Spin corrections */
2451 REAL8 rho22S;
2452 REAL8 rho32S;
2453 REAL8 rho44S;
2454 REAL8 rho42S;
2455 REAL8 f21S;
2456 REAL8 f33S;
2457 REAL8 f31S;
2458 REAL8 f43S;
2459 REAL8 f41S;
2460
2461 const REAL8 a0 = a1+a2;
2462 const REAL8 a12 = a1-a2;
2463 const REAL8 X12 = X1-X2;
2464 const REAL8 a0X12 = a0*X12;
2465 const REAL8 a12X12 = a12*X12;
2466
2467 const REAL8 v = sqrt(x);
2468 const REAL8 v2 = x;
2469 const REAL8 v3 = v2*v;
2470 const REAL8 v4 = v3*v;
2471 const REAL8 v5 = v4*v;
2472 const REAL8 v6 = v5*v;
2473 const REAL8 UNUSED v7 = v6*v;
2474
2475 /* l=m=2 multipole */
2476 /* spin-orbit */
2477 const REAL8 cSO_lo = (-0.5*a0 - a12X12/6.);
2478 const REAL8 cSO_nlo = (-52./63.-19./504.*nu)*a0 - (50./63.+209./504.*nu)*a12X12;
2479 const REAL8 UNUSED cSO_nnlo = (32873./21168 + 477563./42336.*nu + 147421./84672.*nu*nu)*a0 - (23687./63504 - 171791./127008.*nu + 50803./254016.*nu*nu)*a12X12;
2480
2481 /* SPIN-SPIN contribution */
2482 REAL8 cSS_lo = 0.;
2483 REAL8 cSS_nlo = 0.;
2484 if (usetidal) {
2485#if (RC_EXCLUDESPINSPINTIDES)
2486 /* Switch off spin-spin-tidal couplings */
2487 /* See also: eob_dyn_s_get_rc() */
2488 cSS_lo = 0.;
2489 cSS_nlo = 0.;
2490 /* Above code switch off everything,
2491 Alt. one can set C_Q1=C_Q2=0, but keep the term: */
2492 /*
2493 cSS_lo = a1*a2;
2494 */
2495#else
2496 cSS_lo = 0.5*(C_Q1*a1*a1 + 2.*a1*a2 + C_Q2*a2*a2);
2497 cSS_nlo = (-85./63. + 383./252.*nu)*a1*a2 + (-2./3. - 5./18.*nu)*(a1*a1 + a2*a2) + (1./7. + 27./56.*nu)*(C_Q1*a1*a1 + C_Q2*a2*a2) + 2./9.*X12*(a1*a1 - a2*a2) + 55./84.*X12*(C_Q1*a1*a1 - C_Q2*a2*a2);
2498#endif
2499 } else {
2500 cSS_lo = 0.5*a0*a0;
2501 cSS_nlo = 1./504.*(2.*(19. - 70.*nu)*a12*a12 + (-302. + 243.*nu)*a0*a0 + 442.*X12*a0*a12);
2502 }
2503
2504 /* rho_22^S: Eq. (80) of Damour & Nagar, PRD 90, 044018 (2014) */
2505 rho22S = cSO_lo*v3 + cSS_lo*v4 + cSO_nlo*v5;
2506
2507 // Adding NLO SS term w.r.t. eob_wav_flm_s_SSLO
2508 rho22S += cSS_nlo*v6;
2509
2510 /* l>=3, m=even: multipoles rewritten in compact and self-explanatory form */
2511 rho32S = (a0-a12X12)/(3.*(1.-3.*nu))*v;
2512 rho44S = (-19./30.*a0 - (1.-21.*nu)/(30.-90.*nu)*a12X12)*v3;
2513 rho42S = ( -1./30.*a0 - (19.-39.*nu)/(30.-90.*nu)*a12X12)*v3;
2514
2515 /* l>=2, m=odd*/
2516 /* spin-orbit */
2517 f21S = -1.5*a12*v + ((110./21. + 79./84.*nu)*a12 - 13./84.*a0X12)*v3;
2518 f33S = ((-0.25 + 2.5*nu)*a12 - 1.75*a0X12)*v3;
2519 f31S = ((-2.25 + 6.5*nu)*a12 + 0.25*a0X12)*v3;
2520 f43S = (( 5. -10.*nu)*a12 - 5.*a0X12)/(-4.+8.*nu)*v;
2521 f41S = f43S;
2522
2523 /* SPIN-SPIN contribution */
2524 REAL8 c21SS_lo;
2525 REAL8 c33SS_lo;
2526 REAL8 c31SS_lo;
2527 if (usetidal) {
2528#if (RC_EXCLUDESPINSPINTIDES)
2529 /* Switch off spin-spin-tidal couplings */
2530 /* See also: eob_dyn_s_get_rc() */
2531 c21SS_lo = 0.;
2532 c33SS_lo = 0.;
2533 c31SS_lo = 0.;
2534 /* Above code switch off everything,
2535 Alt. one can set C_Q1=C_Q2=0, but keep the term: */
2536#else
2537 c21SS_lo = -19./8.*(a1*a1 - a2*a2) - (C_Q1*a1*a1 - C_Q2*a2*a2) + 1./8.*(-9.*a1*a1 + 10*a1*a2 -9.*a2*a2 + 12.*(C_Q1*a1*a1 + C_Q2*a2*a2))*X12;
2538 c33SS_lo = 3.*(a1*a2 + 0.5*(C_Q1*a1*a1 + C_Q2*a2*a2))*X12;
2539 c31SS_lo = -4.*(C_Q1*a1*a1 - C_Q2*a2*a2) + 3.*(a1*a2 + 0.5*(C_Q1*a1*a1 + C_Q2*a2*a2))*X12;
2540#endif
2541 } else {
2542 c21SS_lo = 1./8.*(-27.*(a1*a1 - a2*a2) + (3.*a1*a1 + 10.*a1*a2 + 3.*a2*a2)*X12);
2543 c33SS_lo = 3./2.*a0*a0*X12;
2544 c31SS_lo = -4.*(a1*a1 - a2*a2) + 3./2.*a0*a0*X12;
2545 }
2546
2547 /* Adding LO SS term w.r.t. eob_wav_flm_s_SSLO */
2548 f21S += c21SS_lo*v4;
2549 f33S += c33SS_lo*v4;
2550 f31S += c31SS_lo*v4;
2551
2552 /* Amplitudes (correct with spin terms) */
2553 flm[0] = SQ(rholm[0]);
2554 flm[0] = (X12*flm[0] + f21S);
2555
2556 flm[1] = SQ(rholm[1]+ rho22S);
2557
2558 flm[2] = gsl_pow_int(rholm[2], 3);
2559 flm[2] = (X12*flm[2] + f31S);
2560
2561 flm[3] = gsl_pow_int(rholm[3]+ rho32S, 3);
2562
2563 flm[4] = gsl_pow_int(rholm[4], 3);
2564 flm[4] = (X12*flm[4] + f33S);
2565
2566 flm[5] = gsl_pow_int(rholm[5], 4);
2567 flm[5] = (X12*flm[5] + f41S);
2568
2569 flm[6] = gsl_pow_int(rholm[6] + rho42S, 4);
2570
2571 flm[7] = gsl_pow_int(rholm[7], 4);
2572 flm[7] = (X12*flm[7] + f43S);
2573
2574 flm[8] = gsl_pow_int(rholm[8] + rho44S, 4);
2575
2576}
2577
2578/* Pre-calculate coefficients for resummed amplitudes.
2579 * Refs:
2580 * . Damour, Iyer & Nagar, PRD 79, 064004 (2009) [theory]
2581 * . Fujita & Iyer, PRD 82, 044051 (2010) [test-mass 5.5PN]
2582 * . Damour, Nagar & Bernuzzi, PRD 87, 084035 (2013) [complete information]
2583 */
2585{
2586
2587 const REAL8 nu2 = nu*nu;
2588 const REAL8 nu3 = nu*nu2;
2589 const REAL8 nu4 = nu*nu3;
2590
2591 for (int k=0; k<KMAX; k++) clm[k][0] = 1.;
2592 for (int k=0; k<KMAX; k++) for (int n=1; n<6; n++) clm[k][n] = 0.;
2593
2594 /* (2,1) */
2595 clm[0][1] = (-1.0535714285714286 + 0.27380952380952384 *nu);
2596 clm[0][2] = (-0.8327841553287982 - 0.7789824263038548 *nu + 0.13116496598639457*nu2);
2597 /* clm[0][3] = (2.9192806270460925 - 1.019047619047619 *el1); */
2598 /* clm[0][4] = (-1.28235780892213 + 1.073639455782313 *el1); */
2599 /* clm[0][5] = (-3.8466571723355227 + 0.8486467106683944 *el1)*PMTERMS_eps; */
2600
2601 /* (2,2) */
2602 clm[1][1] = (-1.0238095238095237 + 0.6547619047619048*nu);
2603 clm[1][2] = (-1.94208238851096 - 1.5601379440665155*nu + 0.4625614134542706*nu2);
2604 /* clm[1][3] = (12.736034731834051 - 2.902228713904598 *nu - 1.9301558466099282*nu2 + 0.2715020968103451*nu3 - 4.076190476190476*el2); */
2605 /* clm[1][4] = (-2.4172313935587004 + 4.173242630385488 *el2); */
2606 /* clm[1][5] = (-30.14143102836864 + 7.916297736025627 *el2); */
2607
2608 /* (3,1) */
2609 clm[2][1] = (-0.7222222222222222 - 0.2222222222222222*nu);
2610 clm[2][2] = (0.014169472502805836 - 0.9455667789001122*nu - 0.46520763187429853*nu2);
2611 /* clm[2][3] = (1.9098284139598072 - 0.4126984126984127*el1); */
2612 /* clm[2][4] = (0.5368150316615179 + 0.2980599647266314*el1); */
2613 /* clm[2][5] = (1.4497991763035063 - 0.0058477188106817735*el1)*PMTERMS_eps; */
2614
2615 /* (3,2) */
2616 clm[3][1] = (0.003703703703703704*(328. - 1115.*nu + 320.*nu2))/(-1. + 3.*nu);
2617 clm[3][2] = (6.235191420376606e-7*(-1.444528e6 + 8.050045e6*nu - 4.725605e6*nu2 - 2.033896e7*nu3 + 3.08564e6*nu4))/((-1. + 3.*nu)*(-1. + 3.*nu));
2618 /* clm[3][3] = (6.220997955214429 - 1.6507936507936507*el2); */
2619 /* clm[3][4] = (-3.4527288879001268 + 2.005408583186361*el2)*PMTERMS_eps; */
2620
2621 /* (3,3) */
2622 clm[4][1] = (-1.1666666666666667 + 0.6666666666666666*nu);
2623 clm[4][2] = (-1.6967171717171716 - 1.8797979797979798*nu + 0.45151515151515154*nu2);
2624 /* clm[4][3] = (14.10891386831863 - 3.7142857142857144*el3); */
2625 /* clm[4][4] = (-6.723375314944128 + 4.333333333333333*el3); */
2626 /* clm[4][5] = (-29.568699895427518 + 6.302092352092352*el3)*PMTERMS_eps; */
2627
2628 /* (4,1) */
2629 clm[5][1] = (0.001893939393939394*(602. - 1385.*nu + 288.*nu2))/(-1. + 2.*nu);
2630 clm[5][2] = (- 0.36778992787515513);
2631 /* clm[5][3] = (0.6981550175535535 - 0.2266955266955267*el1); */
2632 /* clm[5][4] = (-0.7931524512893319 + 0.2584672482399755*el1)*PMTERMS_eps; */
2633
2634 /* (4,2) */
2635 clm[6][1] = (0.0007575757575757576*(1146. - 3530.*nu + 285.*nu2))/(-1. + 3.*nu);
2636 clm[6][2] = - (3.1534122443213353e-9*(1.14859044e8 - 2.95834536e8*nu - 1.204388696e9*nu2 + 3.04798116e9*nu3 + 3.79526805e8*nu4))/((-1. + 3.*nu)*(-1. + 3.*nu));
2637 /* clm[6][3] = 4.550378418934105e-12*(8.48238724511e11 - 1.9927619712e11*el2); */
2638 /* clm[6][4] = (-0.6621921297263365 + 0.787251738160829*el2)*PMTERMS_eps; */
2639
2640 /* (4,3) */
2641 clm[7][1] = (0.005681818181818182*(222. - 547.*nu + 160.*nu2))/(-1. + 2.*nu);
2642 clm[7][2] = (- 0.9783218202252293);
2643 /* clm[7][3] = (8.519456157072423 - 2.0402597402597404*el3)*PMTERMS_eps; */
2644 /* clm[7][4] = (-5.353216984886716 + 2.5735094451003544*el3)*PMTERMS_eps; */
2645
2646 /* (4,4) */
2647 clm[8][1] = (0.0007575757575757576*(1614. - 5870.*nu + 2625.*nu2))/(-1. + 3.*nu);
2648 clm[8][2] = (3.1534122443213353e-9*(-5.11573572e8 + 2.338945704e9*nu - 3.13857376e8*nu2 - 6.733146e9*nu3 + 1.252563795e9*nu4))/((-1. + 3.*nu)*(-1. + 3.*nu));
2649 /* clm[8][3] = (15.108111214795123 - 3.627128427128427*el4); */
2650 /* clm[8][4] = (-8.857121657199649 + 4.434988849534304*el4)*PMTERMS_eps; */
2651
2652 /* (5,1) */
2653 clm[9][1] = (0.002564102564102564*(319. - 626.*nu + 8.*nu2))/(-1. + 2.*nu);
2654 clm[9][2] = (- 0.1047896120973044);
2655 /* clm[9][3] = (0.642701885362399 - 0.14414918414918415*el1)*PMTERMS_eps; */
2656 /* clm[9][4] = (-0.07651588046467575 + 0.11790664036817883*el1)*PMTERMS_eps; */
2657
2658 /* (5,2) */
2659 clm[10][1] = (0.00007326007326007326*(-15828. + 84679.*nu - 104930.*nu2 + 21980.*nu3))/(1. - 5.*nu + 5.*nu2);
2660 clm[10][2] = (- 0.4629337197600934)*PMTERMS_eps;
2661 /* clm[10][3] = (2.354458371550237 - 0.5765967365967366*el2)*PMTERMS_eps; */
2662
2663 /* (5,3) */
2664 clm[11][1] = (0.002564102564102564*(375. - 850.*nu + 176.*nu2))/(-1. + 2.*nu);
2665 clm[11][2] = (- 0.5788010707241477);
2666 /* clm[11][3] = (5.733973288504755 - 1.2973426573426574*el3)*PMTERMS_eps; */
2667 /* clm[11][4] = (-1.9573287625526001 + 1.2474448628294783*el3)*PMTERMS_eps; */
2668
2669 /* (5,4) */
2670 clm[12][1] = (0.00007326007326007326*(-17448. + 96019.*nu - 127610.*nu2 + 33320.*nu3))/(1. - 5.*nu + 5.*nu2);
2671 clm[12][2] = (- 1.0442142414362194)*PMTERMS_eps;
2672 /* clm[12][3] = (10.252052781721588 - 2.3063869463869464*el4)*PMTERMS_eps; */
2673
2674 /* (5,5) */
2675 clm[13][1] = (0.002564102564102564*(487. - 1298.*nu + 512.*nu2))/(-1. + 2.*nu);
2676 clm[13][2] = (- 1.5749727622804546);
2677 /* clm[13][3] = (15.939827047208668 - 3.6037296037296036*el5)*PMTERMS_eps; */
2678 /* clm[13][4] = (-10.272578060123237 + 4.500041838503377*el5)*PMTERMS_eps; */
2679
2680 /* (6,1) */
2681 clm[14][1] = (0.006944444444444444*(-161. + 694.*nu - 670.*nu2 + 124.*nu3))/(1. - 4.*nu + 3.*nu2);
2682 clm[14][2] = (- 0.29175486850885135)*PMTERMS_eps;
2683 /* clm[14][3] = (0.21653486654395454 - 0.10001110001110002*el1)*PMTERMS_eps; */
2684
2685 /* (6,2) */
2686 clm[15][1] = (0.011904761904761904*(-74. + 378.*nu - 413.*nu2 + 49.*nu3))/(1. - 5.*nu + 5.*nu2);
2687 clm[15][2] = ( - 0.24797525070634313)*PMTERMS_eps;
2688 /* clm[15][3] = (1.7942694138754138 - 0.40004440004440006*el2)*PMTERMS_eps; */
2689
2690 /* (6,3) */
2691 clm[16][1] = (0.006944444444444444*(-169. + 742.*nu - 750.*nu2 + 156.*nu3))/(1. - 4.*nu + 3.*nu2);
2692 clm[16][2] = (- 0.5605554442947213)*PMTERMS_eps;
2693 /* clm[16][3] = (4.002558222882566 - 0.9000999000999002*el3)*PMTERMS_eps; */
2694
2695 /* (6,4) */
2696 clm[17][1] = (0.011904761904761904*(-86. + 462.*nu - 581.*nu2 + 133.*nu3))/(1. - 5.*nu + 5.*nu2);
2697 clm[17][2] = (- 0.7228451986855349)*PMTERMS_eps;
2698 /* clm[17][3] = (7.359388663371044 - 1.6001776001776002*el4)*PMTERMS_eps; */
2699
2700 /* (6,5) */
2701 clm[18][1] = (0.006944444444444444*(-185. + 838.*nu - 910.*nu2 + 220.*nu3))/(1. - 4.*nu + 3.*nu2);
2702 clm[18][2] = (- 1.0973940686333457)*PMTERMS_eps;
2703 /* clm[18][3] = (11.623366217471297 - 2.5002775002775004*el5)*PMTERMS_eps; */
2704
2705 /* (6,6) */
2706 clm[19][1] = (0.011904761904761904*(-106. + 602.*nu - 861.*nu2 + 273.*nu3))/(1. - 5.*nu + 5.*nu2);
2707 clm[19][2] = (- 1.5543111183867486)*PMTERMS_eps;
2708 /* clm[19][3] = (16.645950799433503 - 3.6003996003996006*el6)*PMTERMS_eps; */
2709
2710 /* (7,1) */
2711 clm[20][1] = (0.0014005602240896359*(-618. + 2518.*nu - 2083.*nu2 + 228.*nu3))/(1. - 4.*nu + 3.*nu2);
2712 clm[20][2] = ( - 0.1508235111143767)*PMTERMS_eps;
2713 /* clm[20][3] = (0.2581280702019663 - 0.07355557607658449*el1)*PMTERMS_eps; */
2714
2715 /* (7,2) */
2716 clm[21][1] = (0.00006669334400426837*(16832. - 123489.*nu + 273924.*nu2 - 190239.*nu3 + 32760.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2717 clm[21][2] = (- 0.351319484450667)*PMTERMS_eps;
2718
2719 /* (7,3) */
2720 clm[22][1] = (0.0014005602240896359*(-666. + 2806.*nu - 2563.*nu2 + 420.*nu3))/(1. - 4.*nu + 3.*nu2);
2721 clm[22][2] = (- 0.37187416047628863)*PMTERMS_eps;
2722 /* clm[22][3] = (3.0835293524055283 - 0.6620001846892604*el3)*PMTERMS_eps; */
2723
2724 /* (7,4) */
2725 clm[23][1] = (0.00006669334400426837*(17756. - 131805.*nu + 298872.*nu2 - 217959.*nu3 + 41076.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2726 clm[23][2] = (- 0.6473746896670599)*PMTERMS_eps;
2727
2728 /* (7,5) */
2729 clm[24][1] = (0.0014005602240896359*(-762. + 3382.*nu - 3523.*nu2 + 804.*nu3))/(1. - 4.*nu + 3.*nu2);
2730 clm[24][2] = (- 0.8269193364414116)*PMTERMS_eps;
2731 /* clm[24][3] = (8.750589067052443 - 1.838889401914612*el5)*PMTERMS_eps; */
2732
2733 /* (7,6) */
2734 clm[25][1] = (0.0006002400960384153*(2144. - 16185.*nu + 37828.*nu2 - 29351.*nu3 + 6104.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2735 clm[25][2] = (- 1.1403265020692532)*PMTERMS_eps;
2736
2737 /* (7,7) */
2738 clm[26][1] = (0.0014005602240896359*(-906. + 4246.*nu - 4963.*nu2 + 1380.*nu3))/(1. - 4.*nu + 3.*nu2);
2739 clm[26][2] = (- 1.5418467934923434)*PMTERMS_eps;
2740 /* clm[26][3] = (17.255875091408523 - 3.6042232277526396*el7)*PMTERMS_eps; */
2741
2742 /* (8,1) */
2743 clm[27][1] = (0.00005482456140350877*(20022. - 126451.*nu + 236922.*nu2 - 138430.*nu3 + 21640.*nu4))/(-1. + 6.*nu - 10.*nu2 + 4.*nu3);
2744 clm[27][2] = (- 0.26842133517043704)*PMTERMS_eps;
2745
2746 /* (8,2) */
2747 clm[28][1] = (0.0003654970760233918*(2462. - 17598.*nu + 37119.*nu2 - 22845.*nu3 + 3063.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2748 clm[28][2] = (- 0.2261796441029474)*PMTERMS_eps;
2749
2750 /* (8,3) */
2751 clm[29][1] = (0.00005482456140350877*(20598. - 131059.*nu + 249018.*nu2 - 149950.*nu3 + 24520.*nu4))/(-1. + 6.*nu - 10.*nu2 + 4.*nu3);
2752 clm[29][2] = (- 0.4196774909106648)*PMTERMS_eps;
2753
2754 /* (8,4) */
2755 clm[30][1] = (0.0003654970760233918*(2666. - 19434.*nu + 42627.*nu2 - 28965.*nu3 + 4899.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2756 clm[30][2] = (- 0.47652059150068155)*PMTERMS_eps;
2757
2758 /* (8,5) */
2759 clm[31][1] = (0.00027412280701754384*(4350. - 28055.*nu + 54642.*nu2 - 34598.*nu3 + 6056.*nu4))/(-1. + 6.*nu - 10.*nu2 + 4.*nu3);
2760 clm[31][2] = (- 0.7220789990670207)*PMTERMS_eps;
2761
2762 /* (8,6) */
2763 clm[32][1] = (0.0010964912280701754*(1002. - 7498.*nu + 17269.*nu2 - 13055.*nu3 + 2653.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2764 clm[32][2] = (- 0.9061610303170207)*PMTERMS_eps;
2765
2766 /* (8,7) */
2767 clm[33][1] = (0.00005482456140350877*(23478. - 154099.*nu + 309498.*nu2 - 207550.*nu3 + 38920.*nu4))/(-1. + 6.*nu - 10.*nu2 + 4.*nu3);
2768 clm[33][2] = (- 1.175404252991305)*PMTERMS_eps;
2769
2770 /* (8,8) */
2771 clm[34][1] = (0.0003654970760233918*(3482. - 26778.*nu + 64659.*nu2 - 53445.*nu3 + 12243.*nu4))/(-1. + 7.*nu - 14.*nu2 + 7.*nu3);
2772 clm[34][2] = (- 1.5337092502821381)*PMTERMS_eps;
2773
2774 return;
2775}
2776
2777
2778/* Resummed amplitudes in the general nu-dependent case.
2779 * Refs:
2780 * . Damour, Iyer & Nagar, PRD 79, 064004 (2009) [theory]
2781 * . Fujita & Iyer, PRD 82, 044051 (2010) [test-mass 5.5PN]
2782 * . Damour, Nagar & Bernuzzi, PRD 87, 084035 (2013) [complete information]
2783 */
2784void eob_wav_flm(REAL8 x, REAL8 nu, REAL8 clm[KMAX][6], REAL8 *rholm, REAL8 *flm)
2785{
2786
2787 /* Coefficients */
2788 const REAL8 nu2 = nu*nu;
2789 const REAL8 nu3 = nu*nu2;
2790 const REAL8 Pi2 = SQ(LAL_PI);
2791
2792
2793 /* Compute EulerLogs */
2794 const REAL8 el1 = Eulerlog(x,1);
2795 const REAL8 el2 = Eulerlog(x,2);
2796 const REAL8 el3 = Eulerlog(x,3);
2797 const REAL8 el4 = Eulerlog(x,4);
2798 const REAL8 el5 = Eulerlog(x,5);
2799 const REAL8 el6 = Eulerlog(x,6);
2800 const REAL8 el7 = Eulerlog(x,7);
2801
2802 /* Coefs with Eulerlogs */
2803 clm[0][3] = (2.9192806270460925 - 1.019047619047619 *el1);
2804 clm[0][4] = (-1.28235780892213 + 1.073639455782313 *el1);
2805 clm[0][5] = (-3.8466571723355227 + 0.8486467106683944 *el1)*PMTERMS_eps;
2806
2807 clm[1][3] = (12.736034731834051 - 2.902228713904598 *nu - 1.9301558466099282*nu2 + 0.2715020968103451*nu3 - 4.076190476190476*el2);
2808 clm[1][4] = (-2.4172313935587004 + 4.173242630385488 *el2);
2809 clm[1][5] = (-30.14143102836864 + 7.916297736025627 *el2);
2810
2811 clm[2][3] = (1.9098284139598072 - 0.4126984126984127*el1+ (-4.646868015386534 + (0.21354166666666666)*Pi2)*nu + 2.3020866307903347*nu2 - 0.5813492634480288*nu3);
2812 clm[2][4] = (0.5368150316615179 + 0.2980599647266314*el1);
2813 clm[2][5] = (1.4497991763035063 - 0.0058477188106817735*el1)*PMTERMS_eps;
2814
2815 clm[3][3] = (6.220997955214429 - 1.6507936507936507*el2);
2816 clm[3][4] = (-3.4527288879001268 + 2.005408583186361*el2)*PMTERMS_eps;
2817
2818 clm[4][3] = (14.10891386831863 - 3.7142857142857144*el3 + (-5.031429681429682 + (0.21354166666666666)*Pi2)*nu - 1.7781727531727531*nu2 + 0.25923767590434255*nu3);
2819 clm[4][4] = (-6.723375314944128 + 4.333333333333333*el3);
2820 clm[4][5] = (-29.568699895427518 + 6.302092352092352*el3)*PMTERMS_eps;
2821
2822 clm[5][3] = (0.6981550175535535 - 0.2266955266955267*el1);
2823 clm[5][4] = (-0.7931524512893319 + 0.2584672482399755*el1)*PMTERMS_eps;
2824
2825 clm[6][3] = 4.550378418934105e-12*(8.48238724511e11 - 1.9927619712e11*el2);
2826 clm[6][4] = (-0.6621921297263365 + 0.787251738160829*el2)*PMTERMS_eps;
2827
2828 clm[7][3] = (8.519456157072423 - 2.0402597402597404*el3)*PMTERMS_eps;
2829 clm[7][4] = (-5.353216984886716 + 2.5735094451003544*el3)*PMTERMS_eps;
2830
2831 clm[8][3] = (15.108111214795123 - 3.627128427128427*el4);
2832 clm[8][4] = (-8.857121657199649 + 4.434988849534304*el4)*PMTERMS_eps;
2833
2834 clm[9][3] = (0.642701885362399 - 0.14414918414918415*el1)*PMTERMS_eps;
2835 clm[9][4] = (-0.07651588046467575 + 0.11790664036817883*el1)*PMTERMS_eps;
2836
2837 clm[10][3] = (2.354458371550237 - 0.5765967365967366*el2)*PMTERMS_eps;
2838
2839 clm[11][3] = (5.733973288504755 - 1.2973426573426574*el3)*PMTERMS_eps;
2840 clm[11][4] = (-1.9573287625526001 + 1.2474448628294783*el3)*PMTERMS_eps;
2841
2842 clm[12][3] = (10.252052781721588 - 2.3063869463869464*el4)*PMTERMS_eps;
2843
2844 clm[13][3] = (15.939827047208668 - 3.6037296037296036*el5)*PMTERMS_eps;
2845 clm[13][4] = (-10.272578060123237 + 4.500041838503377*el5)*PMTERMS_eps;
2846
2847 clm[14][3] = (0.21653486654395454 - 0.10001110001110002*el1)*PMTERMS_eps;
2848
2849 clm[15][3] = (1.7942694138754138 - 0.40004440004440006*el2)*PMTERMS_eps;
2850
2851 clm[16][3] = (4.002558222882566 - 0.9000999000999002*el3)*PMTERMS_eps;
2852
2853 clm[17][3] = (7.359388663371044 - 1.6001776001776002*el4)*PMTERMS_eps;
2854
2855 clm[18][3] = (11.623366217471297 - 2.5002775002775004*el5)*PMTERMS_eps;
2856
2857 clm[19][3] = (16.645950799433503 - 3.6003996003996006*el6)*PMTERMS_eps;
2858
2859 clm[20][3] = (0.2581280702019663 - 0.07355557607658449*el1)*PMTERMS_eps;
2860
2861 clm[22][3] = (3.0835293524055283 - 0.6620001846892604*el3)*PMTERMS_eps;
2862
2863 clm[24][3] = (8.750589067052443 - 1.838889401914612*el5)*PMTERMS_eps;
2864
2865 clm[26][3] = (17.255875091408523 - 3.6042232277526396*el7)*PMTERMS_eps;
2866
2867 /* rho_lm */
2868 const REAL8 x2 = x*x;
2869 const REAL8 x3 = x*x2;
2870 const REAL8 x4 = x*x3;
2871 const REAL8 x5 = x*x4;
2872 const REAL8 xn[] = {1.,x,x2,x3,x4,x5};
2873
2874 for (int k=0; k<KMAX; k++) {
2875 /* Note: the two sums give different result */
2876#if (1)
2877 rholm[k] = clm[k][0];
2878 for (int n=1; n<6; n++) {
2879 rholm[k] += clm[k][n]*xn[n];
2880 }
2881#else
2882 rholm[k] = x5*clm[k][5];
2883 for (int n=5; n-- >1; ) { // 4,3,2,1 //
2884 rholm[k] += clm[k][n]*xn[n];
2885 }
2886 rholm[k] += clm[k][0];
2887#endif
2888 }
2889
2890//#pragma omp parallel
2891//#pragma omp for
2892 /* Amplitudes */
2893 for (int k = 0; k < KMAX; k++) {
2894 flm[k] = gsl_pow_int(rholm[k], TEOB_LINDEX[k]);
2895 }
2896
2897 return;
2898}
2899
2900
2901/* Residual phase corrections \f$delta_{lm}\f$ up to \f$l=m=5\f$.
2902 Reference(s)
2903 Damour, Iyer & Nagar, PRD 79, 064004 (2008)
2904 Fujita & Iyer, PRD 82 044051 (2010)
2905 Faye et al., Class. Q. Grav. 29 175004 (2012)
2906 Damour, Nagar & Bernuzzi, PRD 87, 084035 (2013) */
2907//TODO: [optimization] this routine can be optimized: precompute coefficients c(nu)
2909{
2910
2911 /* Useful shorthands*/
2912 const REAL8 Pi2 = SQ(LAL_PI);
2913 REAL8 nu2 = SQ(nu);
2914 REAL8 y = cbrt(Hreal*Omega*Hreal*Omega);
2915 REAL8 sqrt_y = sqrt(y);
2916 REAL8 y3 = y*y*y;
2917 REAL8 y32 = Hreal*Omega;
2918
2919 /* Leading order contributions*/
2920 REAL8 delta22LO = 7./3. * y32;
2921 REAL8 delta21LO = 2./3. * y32;
2922 REAL8 delta33LO = 13./10. * y32;
2923 REAL8 delta31LO = 13./30. * y32;
2924
2925 /* Init phase */
2926 for (int k = 0; k < KMAX; k++) {
2927 dlm[k] = 0.;
2928 }
2929
2930 /* Residual phases in Pade-resummed form when possible */
2931 REAL8 num;
2932 REAL8 den;
2933
2934 /* l=2 */
2935 /* Pade(1,2) approximant */
2936 num = 69020.*nu + 5992.*LAL_PI*sqrt_y;
2937 den = 5992.*LAL_PI*sqrt_y + 2456.*nu*(28.+493.*nu* y);
2938 dlm[0] = delta21LO*num/den;
2939 /* Pade(2,2) approximant */
2940 num = (808920.*nu*LAL_PI*sqrt(y) + 137388.*Pi2*y + 35.*nu2*(136080. + (154975. - 1359276.*nu)*y));
2941 den = (808920.*nu*LAL_PI*sqrt(y) + 137388.*Pi2*y + 35.*nu2*(136080. + (154975. + 40404.*nu)*y));
2942 dlm[1] = delta22LO*num/den;
2943
2944 /* l=3 */
2945 /* Pade(1,2) approximant */
2946 num = 4641.*nu + 1690.*LAL_PI*sqrt_y;
2947 den = num + 18207.*nu2*y;
2948 dlm[2] = delta31LO*num/den;
2949 /* Taylor-expanded form */
2950 num = 1. + 94770.*LAL_PI/(566279.*nu)*sqrt_y;
2951 den = num + 80897.* nu/3159.*y;
2952 dlm[3] = (10.+33.*nu)/(15.*(1.-3.*nu)) * y32 + 52./21.*LAL_PI*y3;
2953 /* Pade(1,2) approximant */
2954 dlm[4] = delta33LO*num/den;
2955
2956 /* l=4 */
2957 dlm[5] = (2.+507.*nu)/(10.*(1.-2.*nu))*y32 + 1571./3465.*LAL_PI*y3;
2958 dlm[6] = 7.*(1.+6.*nu)/(15.*(1.-3.*nu))*y32 + 6284./3465.*LAL_PI*y3;
2959 dlm[7] = (486.+4961.*nu)/(810.*(1.-2.*nu))*y32 + 1571./385.*LAL_PI*y3;
2960 dlm[8] = (112.+219.*nu)/(120.*(1.-3.*nu))*y32 + 25136./3465.*LAL_PI*y3;
2961
2962 /* l=5 */
2963 dlm[9] = (96875. + 857528.*nu)/(131250.*(1.-2.*nu))*y32;
2964
2965 return;
2966}
2967
2968
2969/* Leading-order (Newtonian) prefactor of the multipolar resummed waveform.
2970 Reference: Damour, Iyer & Nagar, PRD 79, 064004 (2009) */
2972 REAL8 Omega,
2973 REAL8 phi,
2974 REAL8 nu,
2976{
2977 /* Shorthands */
2978 REAL8 nu2 = nu*nu;
2979 REAL8 nu3 = nu*nu2;
2980
2981 REAL8 vphi = r*Omega;
2982 REAL8 vphi2 = vphi*vphi;
2983 REAL8 vphi3 = vphi*vphi2;
2984 REAL8 vphi4 = vphi*vphi3;
2985 REAL8 vphi5 = vphi*vphi4;
2986 REAL8 vphi6 = vphi*vphi5;
2987 REAL8 vphi7 = vphi*vphi6;
2988 REAL8 vphi8 = vphi*vphi7;
2989 REAL8 vphi9 = vphi*vphi8;
2990
2991 /* Polynomials in nu */
2992 const REAL8 p1 = 1.;
2993 const REAL8 p2 = sqrt(1.-4.*nu);
2994 const REAL8 p3 = (3.*nu-1.);
2995 const REAL8 p4 = (2.*nu-1.)*sqrt(1.-4.*nu);
2996 const REAL8 p5 = 1.-5.*nu+5.*nu2;
2997 const REAL8 p6 = (1.-4.*nu+3.*nu2)*sqrt(1.-4.*nu);
2998 const REAL8 p7 = 7.*nu3 - 14.*nu2 + 7.*nu -1.;
2999 const REAL8 p8 = (4.*nu3 - 10.*nu2 + 6.*nu -1.)*sqrt(1.-4.*nu);
3000
3001 const REAL8 phix2 = 2. * phi;
3002 const REAL8 phix3 = 3. * phi;
3003 const REAL8 phix4 = 4. * phi;
3004 const REAL8 phix5 = 5. * phi;
3005 const REAL8 phix6 = 6. * phi;
3006 const REAL8 phix7 = 7. * phi;
3007
3008 const REAL8 pv23 = p2 * vphi3;
3009 const REAL8 pv34 = p3 * vphi4;
3010 const REAL8 pv45 = p4 * vphi5;
3011 const REAL8 pv56 = p5 * vphi6;
3012 const REAL8 pv67 = p6 * vphi7;
3013 const REAL8 pv78 = p7 * vphi8;
3014 const REAL8 pv89 = p8 * vphi9;
3015
3016 REAL8 phim[KMAX] = {
3017 phi,phix2,
3018 phi,phix2,phix3,
3019 phi,phix2,phix3,phix4,
3020 phi,phix2,phix3,phix4,phix5,
3021 phi,phix2,phix3,phix4,phix5,phix6,
3022 phi,phix2,phix3,phix4,phix5,phix6,phix7,
3023 phi,phix2,phix3,phix4,phix5,phix6,phix7,8.*phi
3024 };
3025
3026 REAL8 Alm[KMAX] = {
3027 pv23, p1 * vphi2,
3028 pv23, pv34, pv23,
3029 pv45, pv34, pv45, pv34,
3030 pv45, pv56, pv45, pv56, pv45,
3031 pv67, pv56, pv67, pv56, pv67, pv56,
3032 pv67, pv78, pv67, pv78, pv67, pv78, pv67,
3033 pv89, pv78, pv89, pv78, pv89, pv78, pv89, pv78
3034 };
3035
3036 /* Compute hlmNewt (without phase factor) in complex Polar coords */
3037 for (int k = 0; k < KMAX; k++) {
3038 hlmNewt->phase[k] = - phim[k] + ChlmNewt_phase[k];
3039 hlmNewt->ampli[k] = ChlmNewt_ampli[k] * Alm[k];
3040 }
3041
3042}
3043
3044
3045/* Calculate tidal correction to multipolar waveform amplitude
3046 Ref. Damour, Nagar & Villain, Phys.Rev. D85 (2012) 123007 */
3048{
3049 const REAL8 nu = dyn->nu;
3050 const REAL8 XA = dyn->X1;
3051 const REAL8 XB = dyn->X2;
3052 const REAL8 khatA_2 = dyn->khatA2;
3053 const REAL8 khatB_2 = dyn->khatB2;
3054 const REAL8 kapA2j = dyn->kapA2j;
3055 const REAL8 kapB2j = dyn->kapB2j;
3056 const REAL8 kapT2j = dyn->kapT2j;
3057
3058 const REAL8 x5 = (REAL8) gsl_pow_int((double) x, 5);
3059 const REAL8 x6 = (REAL8) gsl_pow_int((double) x, 6);
3060
3061 REAL8 hA[KMAX], hB[KMAX], betaA1[KMAX], betaB1[KMAX];
3062
3063 memset(hTidallm, 0., KMAX*sizeof(REAL8));
3064 memset(hA, 0., KMAX*sizeof(REAL8));
3065 memset(hB, 0., KMAX*sizeof(REAL8));
3066 memset(betaA1, 0., KMAX*sizeof(REAL8));
3067 memset(betaB1, 0., KMAX*sizeof(REAL8));
3068
3069 /* l=2 */
3070 hA[1] = 2 * khatA_2 *(XA/XB+3);
3071 hB[1] = 2 * khatB_2 *(XB/XA+3);
3072
3073 betaA1[1] = (-202. + 560*XA - 340*XA*XA + 45*XA*XA*XA)/(42*(3-2*XA));
3074 betaB1[1] = (-202. + 560*XB - 340*XB*XB + 45*XB*XB*XB)/(42*(3-2*XB));
3075
3076 hA[0] = 3 * khatA_2 * (3-4*XA);
3077 hB[0] = 3 * khatB_2 * (3-4*XB);
3078
3079 /* l=3 */
3080 hA[2] = 12 * khatA_2 * XB;
3081 hB[2] = 12 * khatB_2 * XA;
3082
3083 betaA1[2] = (-6. -5.*XA +131.*XA*XA -130.*XA*XA*XA)/(36.*(1.-XA));
3084 betaB1[2] = (-6. -5.*XB +131.*XB*XB -130.*XB*XB*XB)/(36.*(1.-XB));
3085
3086 hA[4] = hA[2];
3087 hB[4] = hB[2];
3088
3089 betaA1[4] = ( (XA-3.)*(10.*XA*XA - 25.*XA+ 14.) )/(12.*(1.-XA));
3090 betaB1[4] = ( (XB-3.)*(10.*XB*XB - 25.*XB+ 14.) )/(12.*(1.-XB));
3091
3092 /* l=2 */
3093 /* (2,1) */
3094 hTidallm[0] = ( -hA[0] + hB[0] )*x5;
3095 /* (2,2) */
3096 hTidallm[1] = ( hA[1]*(1. + betaA1[1]*x) + hB[1]*(1. + betaB1[1]*x) )*x5;
3097
3098 /* l=3 */
3099 /* (3,1) */
3100 hTidallm[2] = ( -hA[2]*(1. + betaA1[2]*x) + hB[2]*(1. + betaB1[2]*x) )*x5;
3101 /* (3,2) */
3102 hTidallm[3] = 8.*( khatA_2*(1. -2.*XB + 3.*XB*XB) +khatB_2*(1. -2.*XA + 3.*XA*XA) )*x5/(1.-3.*nu);
3103 /* (3,3) */
3104 hTidallm[4] = ( -hA[4]*(1. + betaA1[4]*x) + hB[4]*(1. + betaB1[4]*x) )*x5;
3105 // MA: TODO: replace
3106
3107
3109 const double fourtnine= 1.5555555555555555556; // 14/9 = 112/(3*24)
3110 const double fourthird = 1.3333333333333333333; // 32/24 = 4/3
3111 hTidallm[0] += 0.5*( -1.*kapA2j/XB + kapB2j/XA )*x5;
3112 hTidallm[1] += fourtnine*kapT2j*x6;
3113 hTidallm[2] += 0.5*( kapA2j*(4. - 17.*XB) - kapB2j*(4. - 17.*XA) )*x6;
3114 hTidallm[3] += fourthird*kapT2j*x5/(1.-3.*nu);
3115 hTidallm[4] += 0.5*( kapA2j*(4. - 9.*XB) - kapB2j*(4. - 9.*XA) )*x6;
3116 }
3117
3118}
3119
3120/* NQC corrections to the RWZ multipolar waveform
3121 Nagar, Damour, Reisswig, Pollney http://arxiv.org/abs/1506.08457
3122 Nonspinning case, Current fits: 9/02/2016 */
3124 REAL8 r,
3125 REAL8 prstar,
3126 REAL8 Omega,
3127 REAL8 ddotr,
3129{
3130 const REAL8 xnu = 1-4*nu;
3131 const REAL8 xnu2 = SQ(xnu);
3132
3133 REAL8 a1[KMAX], a2[KMAX], a3[KMAX];
3134 REAL8 b1[KMAX], b2[KMAX], b3[KMAX];
3135 REAL8 n[KMAX][6];
3136
3137 const INT4 k21 = 0;
3138 const INT4 k22 = 1;
3139 const INT4 k33 = 4;
3140 int k;
3141
3142 /* NR fits */
3143 for (int ki = 0; ki < KMAX; ki++) {
3144 a1[ki] = 0.;
3145 a2[ki] = 0.;
3146 a3[ki] = 0.;
3147 b1[ki] = 0.;
3148 b2[ki] = 0.;
3149 b3[ki] = 0.;
3150 }
3151
3152 /* (2,1) */
3153 a1[k21] = 0.0162387198*(7.32653082*xnu2 + 1.19616248*xnu + 0.73496656);
3154 a2[k21] = -1.80492460*xnu2 + 1.78172686*xnu + 0.30865284;
3155 a3[k21] = 0.0;
3156
3157 b1[k21] = -0.0647955017*(3.59934444*xnu2 - 4.08628784*xnu + 1.37890907);
3158 b2[k21] = 1.3410693180*(0.38491989*xnu2 + 0.10969453*xnu + 0.97513971);
3159 b3[k21] = 0.0;
3160
3161 /* (2,2) */
3162 a1[k22] = -0.0805236959*( 1 - 2.00332326*xnu2)/( 1 + 3.08595088*xnu2);
3163 a2[k22] = 1.5299534255*( 1 + 1.16438929*xnu2)/( 1 + 1.92033923*xnu2);
3164 a3[k22] = 0.0;
3165
3166 b1[k22] = 0.146768094955*( 0.07417121*xnu + 1.01691256);
3167 b2[k22] = 0.896911234248*(-0.61072011*xnu + 0.94295129);
3168 b3[k22] = 0.0;
3169
3170 /* (3,3) */
3171 a1[k33] = -0.0377680000*(1 - 14.61548907*xnu2)/( 1 + 2.44559263*xnu2);
3172 a2[k33] = 1.9898000000*(1 + 2.09750346 *xnu2)/( 1 + 2.57489466*xnu2);
3173 a3[k33] = 0.0;
3174
3175 b1[k33] = 0.1418400000*(1.07430512 - 1.23906804*xnu + 4.44910652*xnu2);
3176 b2[k33] = 0.6191300000*(0.80672432 + 4.07432829*xnu - 7.47270977*xnu2);
3177 b3[k33] = 0.0;
3178
3179 /* NQC corrections to the modulus and phase */
3180 for (int ki = 0; ki < KMAX; ki++) {
3181 for (int j = 0; j < 6; j++) {
3182 n[ki][j] = 0.;
3183 }
3184 }
3185
3186 k = k21;
3187 n[k][0] = (prstar/(r*Omega))*(prstar/(r*Omega));
3188 n[k][1] = ddotr/(r*Omega*Omega);
3189 n[k][2] = n[k][0]*prstar*prstar;
3190 n[k][3] = prstar/(r*Omega);
3191 n[k][4] = n[k][3]*cbrt(Omega*Omega);
3192 n[k][5] = n[k][4]*prstar*prstar;
3193
3194 k = k22;
3195 n[k][0] = (prstar/(r*Omega))*(prstar/(r*Omega));
3196 n[k][1] = ddotr/(r*Omega*Omega);
3197 n[k][2] = n[k][0]*prstar*prstar;
3198 n[k][3] = prstar/(r*Omega);
3199 /* n[k][4] = n[k][3]*cbrt(Omega*Omega); */
3200 n[k][4] = n[k][3]*(r*Omega)*(r*Omega);
3201 n[k][5] = n[k][4]*prstar*prstar;
3202
3203 k = k33;
3204 n[k][0] = (prstar/(r*Omega))*(prstar/(r*Omega));
3205 n[k][1] = ddotr/(r*Omega*Omega);
3206 n[k][2] = n[k][0]*prstar*prstar;
3207 n[k][3] = prstar/(r*Omega);
3208 n[k][4] = n[k][3]*cbrt(Omega*Omega);
3209 n[k][5] = n[k][4]*prstar*prstar;
3210
3211 /* NQC factor */
3212 for (int ki = 0; ki < KMAX; ki++) {
3213 hlmnqc->ampli[ki] = 1.;
3214 hlmnqc->phase[ki] = 0.;
3215 }
3216
3217 k = k21; /* (2,1) */
3218 hlmnqc->ampli[k] = 1. + a1[k]*n[k][0] + a2[k]*n[k][1] + a3[k]*n[k][2];
3219 hlmnqc->phase[k] = b1[k]*n[k][3] + b2[k]*n[k][4] + b3[k]*n[k][5];
3220
3221 k = k22; /* (2,2) */
3222 hlmnqc->ampli[k] = 1. + a1[k]*n[k][0] + a2[k]*n[k][1] + a3[k]*n[k][2];
3223 hlmnqc->phase[k] = b1[k]*n[k][3] + b2[k]*n[k][4] + b3[k]*n[k][5];
3224
3225 k = k33; /* (3,3) */
3226 hlmnqc->ampli[k] = 1. + a1[k]*n[k][0] + a2[k]*n[k][1] + a3[k]*n[k][2];
3227 hlmnqc->phase[k] = b1[k]*n[k][3] + b2[k]*n[k][4] + b3[k]*n[k][5];
3228
3229 return;
3230}
3231
3232/* Generic routine for NQC */
3233void eob_wav_hlmNQC(REAL8 UNUSED nu, REAL8 r, REAL8 prstar, REAL8 Omega, REAL8 ddotr, NQCcoefs *nqc,
3235{
3236 const INT4 maxk = MIN(KMAX, nqc->maxk+1);
3237
3238 /* Multipoles with special treatment */
3239 const INT4 k22 = 1;
3240
3241 /* Shorthand */
3242 const REAL8 n0 = (prstar/(r*Omega))*(prstar/(r*Omega));
3243 const REAL8 n1 = ddotr/(r*Omega*Omega);
3244 const REAL8 n2 = n0*SQ(prstar);
3245 const REAL8 n3 = prstar/(r*Omega);
3246 const REAL8 n4 = n3*cbrt(Omega*Omega);
3247 const REAL8 n5 = n4*SQ(prstar);
3248
3249 const REAL8 n4_k = n3*SQ((r*Omega));
3250 const REAL8 n5_k = n4*SQ(prstar);
3251
3252 /* n functions */
3253 for (int k = 0; k < maxk; k++) {
3254 if (nqc->activemode[k]) {
3255 nqc->n[k][0] = n0;
3256 nqc->n[k][1] = n1;
3257 nqc->n[k][2] = n2;
3258 nqc->n[k][3] = n3;
3259 nqc->n[k][4] = n4;
3260 nqc->n[k][5] = n5;
3261 }
3262 }
3263
3264 /* Change special multipoles */
3265 INT4 k0 = k22;
3266 nqc->n[k0][4] = n4_k;
3267 nqc->n[k0][5] = n5_k;
3268
3269 /* NQC wave factor */
3270 for (int k = 0; k < KMAX; k++) {
3271 hlmnqc->ampli[k] = 1.;
3272 hlmnqc->phase[k] = 0.;
3273 }
3274
3275 for (int k = 0; k < maxk; k++) {
3276 if (nqc->activemode[k]) {
3277 hlmnqc->ampli[k] += nqc->a1[k]*nqc->n[k][0] + nqc->a2[k]*nqc->n[k][1] + nqc->a3[k]*nqc->n[k][2];
3278 hlmnqc->phase[k] += nqc->b1[k]*nqc->n[k][3] + nqc->b2[k]*nqc->n[k][4] + nqc->b3[k]*nqc->n[k][5];
3279 }
3280 }
3281
3282}
3283
3284/* Computes the factors and the coefficients that build the
3285 NQC corrections to the waveform in the spinning case */
3287{
3288
3289 REAL8 A_tmp, dA_tmp, omg_tmp, domg_tmp;
3290
3291 const REAL8 nu = dyn->nu;
3292 const REAL8 X1 = dyn->X1;
3293 const REAL8 X2 = dyn->X2;
3294 const REAL8 chi1 = dyn->chi1;
3295 const REAL8 chi2 = dyn->chi2;
3296 const REAL8 aK = dyn->a1 + dyn->a2;
3297
3298 const REAL8 nu2 = SQ(nu);
3299 const REAL8 nu3 = nu2*nu;
3300 const REAL8 X12 = X1 - X2;
3301 const REAL8 aK2 = SQ(aK);
3302 const REAL8 aK3 = aK2*aK;
3303 const REAL8 aK4 = aK2*aK2;
3304 const REAL8 a12 = X1*chi1 - X2*chi2;
3305 const REAL8 aeff = aK + 1./3.*a12*X12;
3306 const REAL8 aeff_omg = aK + a12*X12;
3307
3308 REAL8 *t = h->tdata->data;
3309 REAL8 *r = dyn->data[TEOB_RAD];
3310 REAL8 *w = dyn->data[TEOB_MOMG]; /* Omega */
3311 REAL8 UNUSED *pph = dyn->data[TEOB_PPHI];
3312 REAL8 *pr_star = dyn->data[TEOB_PRSTAR];
3313 REAL8 *Omg_orb = dyn->data[TEOB_OMGORB]; /* Omega orbital */
3314 REAL8 *ddotr = dyn->data[TEOB_DDOTR];
3315
3316 REAL8 c_p1, c_p2, c_p3, c_p4;
3317 REAL8 c_pdA1, c_pdA2, c_pdA3, c_pdA4;
3318 REAL8 c_pdomg1, c_pdomg2;
3319 REAL8 n0, d1;
3320 REAL8 a0_omg_tmp, a1_omg_tmp, a2_omg_tmp, b0_omg_tmp, b1_omg_tmp, b2_omg_tmp, a0_domg_tmp, a1_domg_tmp, a2_domg_tmp, b0_domg_tmp, b1_domg_tmp, b2_domg_tmp, a0_A_tmp, a1_A_tmp , a2_A_tmp, b0_A_tmp, b1_A_tmp, b2_A_tmp, a0_dA_tmp, a1_dA_tmp, a2_dA_tmp, b0_dA_tmp, b1_dA_tmp, b2_dA_tmp, omg_tmp_nu, omg_tmp_equal, domg_tmp_nu, domg_tmp_equal, A_tmp_scale_nu, A_tmp_scale_equal, dA_tmp_scale_nu, dA_tmp_scale_equal ;
3321
3322 REAL8 P[2], M[4], p1[2], p2[2], p3[2], p4[2], pA[5], pdA[5];
3323 REAL8 pomg[5], pdomg[5], pn0[2], pd1[2], ppdomg1[2], ppdomg2[2], pdA1[2],pdA2[2],pdA3[2],pdA4[2];
3324 REAL8 max_A[KMAX], max_dA[KMAX], UNUSED d2max[KMAX], UNUSED d3max[KMAX], max_omg[KMAX], max_domg[KMAX], UNUSED maxd2omg[KMAX], UNUSED DeltaT[KMAX];
3325 REAL8 ai[KMAX][2];
3326 REAL8 bi[KMAX][2];
3327
3328 const int size = (int) h->tdata->length;
3329 for (int i = 0; i < size; i++) {
3330 hnqc->tdata->data[i] = t[i];
3331 }
3332
3333 REAL8 *omg[KMAX], *domg[KMAX];
3334 REAL8 *n1,*n2,*n3,*n4,*n5,*n6, *d_n4,*d_n5, *d2_n4,*d2_n5;
3335 REAL8 *m11[KMAX], *m12[KMAX], *m13[KMAX], *m21[KMAX], *m22[KMAX];
3336 REAL8 *p1tmp[KMAX], *p2tmp[KMAX]; /* RWZ amplitude and derivative */
3337
3338 for (int k=0; k<KMAX; k++) {
3339 omg[k] = (REAL8*) calloc (size,sizeof(REAL8));
3340 domg[k] = (REAL8*) calloc (size,sizeof(REAL8));
3341 m11[k] = (REAL8*) calloc (size,sizeof(REAL8));
3342 m12[k] = (REAL8*) calloc (size,sizeof(REAL8));
3343 m13[k] = (REAL8*) calloc (size,sizeof(REAL8));
3344 m21[k] = (REAL8*) calloc (size,sizeof(REAL8));
3345 m22[k] = (REAL8*) calloc (size,sizeof(REAL8));
3346 p1tmp[k] = (REAL8*) calloc (size,sizeof(REAL8));
3347 p2tmp[k] = (REAL8*) calloc (size,sizeof(REAL8));
3348 }
3349
3350 n1 = (REAL8*) calloc (size,sizeof(REAL8));
3351 n2 = (REAL8*) calloc (size,sizeof(REAL8));
3352 n3 = (REAL8*) calloc (size,sizeof(REAL8));
3353 n4 = (REAL8*) calloc (size,sizeof(REAL8));
3354 n5 = (REAL8*) calloc (size,sizeof(REAL8));
3355 n6 = (REAL8*) calloc (size,sizeof(REAL8));
3356 d_n4 = (REAL8*) calloc (size,sizeof(REAL8));
3357 d_n5 = (REAL8*) calloc (size,sizeof(REAL8));
3358 d2_n4 = (REAL8*) calloc (size,sizeof(REAL8));
3359 d2_n5 = (REAL8*) calloc (size,sizeof(REAL8));
3360
3361 /* omega derivatives */
3362 const REAL8 dt = t[1]-t[0];
3364 this = h;
3365 for (int k=0; k<KMAX; k++) {
3366 D0(this->phase->data->data, dt, size, omg[k]);
3367 D0(omg[k], dt, size, domg[k]);
3368 this = this->next;
3369 }
3370
3371 /* NR fits */
3372 if (DEQUAL(nu,0.25,1e-9)) {
3373
3374 pA[0] = 0.00178195;
3375 pA[1] = 0.00435589;
3376 pA[2] = 0.00344489;
3377 pA[3] = -0.00076165;
3378 pA[4] = 0.31973334;
3379 A_tmp = pA[0]*aK4 + pA[1]*aK3 + pA[2]*aK2 + pA[3]*aK + pA[4];
3380
3381 pdA[0] = 0.00000927;
3382 pdA[1] = -0.00024550;
3383 pdA[2] = 0.00012469;
3384 pdA[3] = 0.00123845;
3385 pdA[4] = -0.00195014;
3386 dA_tmp = pdA[0]*aK4 + pdA[1]*aK3 + pdA[2]*aK2 + pdA[3]*aK + pdA[4];
3387
3388 pomg[0] = 0.00603482;
3389 pomg[1] = 0.01604555;
3390 pomg[2] = 0.02290799;
3391 pomg[3] = 0.07084587;
3392 pomg[4] = 0.38321834;
3393 omg_tmp = pomg[0]*aK4 + pomg[1]*aK3 + pomg[2]*aK2 + pomg[3]*aK + pomg[4];
3394
3395 pdomg[0] = 0.00024066;
3396 pdomg[1] = 0.00038123;
3397 pdomg[2] = -0.00049714;
3398 pdomg[3] = 0.00041219;
3399 pdomg[4] = 0.01190548;
3400 domg_tmp = pdomg[0]*aK4 + pdomg[1]*aK3 + pdomg[2]*aK2 + pdomg[3]*aK + pdomg[4];
3401
3402 } else if( nu > 0.16) {
3403
3404 p1[0] = 0.04680896;
3405 p1[1] = -0.00632114;
3406 p2[0] = 0.06586192;
3407 p2[1] = -0.01180039;
3408 p3[0] = -0.11617413;
3409 p3[1] = 0.02704959;
3410 p4[0] = 0.15597465;
3411 p4[1] = 0.28034978;
3412 c_p1 = p1[0]*nu + p1[1];
3413 c_p2 = p2[0]*nu + p2[1];
3414 c_p3 = p3[0]*nu + p3[1];
3415 c_p4 = p4[0]*nu + p4[1];
3416 A_tmp = c_p1*aK3 + c_p2*aK2 + c_p3*aK + c_p4;
3417
3418 pdA1[0] = -0.00130824;
3419 pdA1[1] = 0.00006202;
3420 pdA2[0] = 0.00199855;
3421 pdA2[1] = -0.00027474;
3422 pdA3[0] = 0.00218838;
3423 pdA3[1] = 0.00071540;
3424 pdA4[0] = -0.00362779;
3425 pdA4[1] = -0.00105397;
3426 c_pdA1 = pdA1[0]*nu + pdA1[1];
3427 c_pdA2 = pdA2[0]*nu + pdA2[1];
3428 c_pdA3 = pdA3[0]*nu + pdA3[1];
3429 c_pdA4 = pdA4[0]*nu + pdA4[1];
3430 dA_tmp = c_pdA1*aK3 + c_pdA2*aK2 + c_pdA3*aK+ c_pdA4;
3431
3432 pn0[0] = 0.46908067;
3433 pn0[1] = 0.27022141;
3434 pd1[0] = 0.64131115;
3435 pd1[1] = -0.37878384;
3436 n0 = pn0[0]*nu + pn0[1];
3437 d1 = pd1[0]*nu + pd1[1];
3438 omg_tmp = n0/(1 + d1*aK);
3439
3440 ppdomg1[0] = 0.00061175;
3441 ppdomg1[1] = 0.00074001;
3442 ppdomg2[0] = 0.02504442;
3443 ppdomg2[1] = 0.00548217;
3444 c_pdomg1 = ppdomg1[0]*nu + ppdomg1[1];
3445 c_pdomg2 = ppdomg2[0]*nu + ppdomg2[1];
3446 domg_tmp = c_pdomg1*aK + c_pdomg2;
3447
3448 } else {
3449
3450 /* Fit by G.Riemanschneider incorporating the test-particle NQC point
3451 obtained from the most-recent Teukolsky waveforms done by
3452 M. Colleoni using the 6PN-accurare iResum-radiation reaction.
3453 These points assure a smooth connection between merger and
3454 ringdown also outside the "calibration" domain, notably for
3455 large-mass ratios (though q<=20) and large (negative) spins
3456 Updated, 28/09/2017 */
3457
3458 a0_omg_tmp = -0.1460961247;
3459 a1_omg_tmp = 0.0998056;
3460 a2_omg_tmp = -0.118098;
3461 b0_omg_tmp = -0.3430184009;
3462 b1_omg_tmp = 0.0921551;
3463 b2_omg_tmp = -0.0740285;
3464 omg_tmp_nu = +0.5427169903*nu2 +0.2512395608*nu +0.2863992248;
3465 omg_tmp_equal =((a2_omg_tmp*X12*X12 + a1_omg_tmp*X12 + a0_omg_tmp)*aeff_omg+1)/((b2_omg_tmp*X12*X12 +b1_omg_tmp*X12 + b0_omg_tmp)*aeff_omg+1);
3466 omg_tmp = omg_tmp_nu*omg_tmp_equal;
3467
3468 a0_domg_tmp = +0.0604556289;
3469 b0_domg_tmp = -0.0299583285;
3470 a1_domg_tmp = 0.0711715;
3471 a2_domg_tmp = -0.0500886;
3472 b1_domg_tmp = 0.0461239;
3473 b2_domg_tmp = -0.0153068;
3474
3475 domg_tmp_nu = ( +0.0045213831*nu +0.0064934920)/( -1.4466409969*nu+1);
3476 domg_tmp_equal = (a2_domg_tmp*X12*X12 +a1_domg_tmp*X12 +b0_domg_tmp)*aeff_omg*aeff_omg +(b2_domg_tmp*X12*X12 +b1_domg_tmp*X12+a0_domg_tmp)*aeff_omg+1;
3477 domg_tmp = domg_tmp_nu*domg_tmp_equal;
3478
3479 a0_A_tmp = -0.2750516062;
3480 b0_A_tmp = -0.4693776065;
3481 a1_A_tmp = 0.143066;
3482 a2_A_tmp = -0.0425947;
3483 b1_A_tmp = 0.176955;
3484 b2_A_tmp = -0.111902;
3485
3486 A_tmp_scale_nu = -0.9862040409*nu3 +0.8167558040*nu2 -0.0427442282*nu+0.2948879452;
3487 A_tmp_scale_equal = ((a2_A_tmp*X12*X12 + a1_A_tmp*X12 +a0_A_tmp)*aeff+1)/((b2_A_tmp*X12*X12 + b1_A_tmp*X12 +b0_A_tmp)*aeff+1);
3488 A_tmp = A_tmp_scale_nu*A_tmp_scale_equal*(1-0.5*omg_tmp*aeff);
3489
3490 a0_dA_tmp = +0.0037461628;
3491 b0_dA_tmp = +0.0636082543;
3492 a1_dA_tmp = 0.00129393;
3493 a2_dA_tmp = -0.00239069;
3494 b1_dA_tmp = -0.0534209;
3495 b2_dA_tmp = -0.186101;
3496
3497 dA_tmp_scale_nu = ( -0.0847947167*nu -0.0042142765)/( +16.1559461812*nu+1);
3498 dA_tmp_scale_equal = ((a2_dA_tmp*X12*X12 + a1_dA_tmp*X12+ a0_dA_tmp)*aeff)/((b2_dA_tmp*X12*X12 + b1_dA_tmp*X12 + b0_dA_tmp)*aeff+1);
3499 dA_tmp = (dA_tmp_scale_nu +dA_tmp_scale_equal)*omg_tmp;
3500
3501 }
3502
3503 /* Switch on the 22 values (only) */
3504 for (int k=0; k<KMAX; k++) {
3505 max_A[k] = 0.;
3506 max_dA[k] = 0.;
3507 max_omg[k] = 0.;
3508 max_domg[k] = 0.;
3509 }
3510 max_A[1] = A_tmp;
3511 max_dA[1] = dA_tmp;
3512 max_omg[1] = omg_tmp;
3513 max_domg[1] = domg_tmp;
3514
3515 // if (TEOB_VERBOSE) {
3516 // printf("NR values for NQC determination:\n");
3517 // PRFORMd("A22_mrg",max_A[1]);
3518 // PRFORMd("dA22_mrg",max_dA[1]);
3519 // PRFORMd("omg22_mrg",max_omg[1]);
3520 // PRFORMd("domg22_mrg",max_domg[1]);
3521 // }
3522
3523 /* NQC corrections to AMPLITUDE (n1,n2,n3) and PHASE (n4,n5,n6)
3524 * NQC basis for (2,2) waveform : AMPLITUDE
3525 * note: n3 and n6 are not used
3526 */
3527 REAL8 pr_star2, r2, w2;
3528 for (int j=0; j<size; j++) {
3529 pr_star2 = SQ(pr_star[j]);
3530 r2 = SQ(r[j]);
3531 w2 = SQ(w[j]); //CHECKME: Omg or Omg_orbital ?
3532 n1[j] = pr_star2/(r2*w2); /* [pr*\/(r Omg)]^2 */
3533 n2[j] = ddotr[j]/(r[j]*w2); /* [ddot{r}/(r Omg^2)] */
3534 n4[j] = pr_star[j]/(r[j]*w[j]); /* pr*\/(r Omg) */
3535 n5[j] = n4[j]*r2*w2; /* (pr*)*(r Omg) */
3536 }
3537
3538 //#if (TEOB_DEBUG)
3539 // FILE* fp = fopen("nqc_nfunc.txt", "w");
3540 // for (int j=0; j<size; j++) {
3541 // fprintf(fp, "%20.12f\t%.16e\t%.16e\t%.16e\t%.16e\n", t[j], n1[j], n2[j], n4[j], n5[j]);
3542 // }
3543 // fclose(fp);
3544 //#endif
3545
3546 /* Derivatives for the phase */
3547 D0(n4,dt,size, d_n4);
3548 D0(n5,dt,size, d_n5);
3549 D0(d_n4,dt,size, d2_n4);
3550 D0(d_n5,dt,size, d2_n5);
3551
3552 //#if (TEOB_DEBUG)
3553 // fp = fopen("nqc_dfunc.txt", "w");
3554 // for (int j=0; j<size; j++) {
3555 // fprintf(fp, "%f\t%.16e\t%.16e\t%.16e\t%.16e\n", t[j], d_n4[j], d_n5[j], d2_n4[j], d2_n5[j]);
3556 // }
3557 // fclose(fp);
3558 //#endif
3559
3560 /* Find max Omg */
3561 //TODO: search backwards!
3562 int Omgmax_index = 0;
3563 REAL8 Omg_max = Omg_orb[0];
3564 for (int j=0; j<size; j++) {
3565 if (Omg_orb[j] > Omg_max) {
3566 Omg_max = Omg_orb[j];
3567 Omgmax_index = j;
3568 }
3569 }
3570
3571 /* Time */
3572 REAL8 tOmgOrb_pk = t[Omgmax_index];
3573 REAL8 DeltaT_nqc = eob_nqc_timeshift(nu, chi1);
3574 REAL8 tNQC = tOmgOrb_pk - DeltaT_nqc;
3575
3576 // if (TEOB_VERBOSE) {
3577 // printf("NQC info:\n");
3578 // PRFORMd("DeltaT_tNQC",DeltaT_nqc);
3579 // PRFORMd("tNQC[bare]",tNQC);
3580 // }
3581
3582 /* Find jmax: t[jmax] <= tNQC */
3583 int jmax = 0;
3584 for (int j=0; j<size; j++) {
3585 if(t[j] > tNQC) {
3586 jmax = j-2;
3587 break;
3588 }
3589 }
3590
3591 /* Solve the linear systems */
3592
3593 /* Regge-Wheeler-Zerilli normalized amplitude.
3594 The ringdown coefficient refer to this normalization.
3595 Nagar & Rezzolla, CQG 22 (2005) R167 */
3596 this = h;
3597 for (int k=0; k<KMAX; k++) {
3598 REAL8 nlm = 1./(sqrt( (this->l+2)*(this->l+1)*this->l*(this->l-1) ) );
3599 for (int j=0; j<size; j++) {
3600 p1tmp[k][j] = this->ampl->data->data[j] * nlm;
3601 }
3602 this = this->next;
3603 }
3604
3605 /* Matrix elements: waveform amplitude at all points */
3606 for (int k=0; k<KMAX; k++) {
3607 for (int j=0; j<size; j++) {
3608 m11[k][j] = n1[j] * p1tmp[k][j];
3609 m12[k][j] = n2[j] * p1tmp[k][j];
3610 }
3611 }
3612
3613 /* Take FD derivatives */
3614 for (int k=0; k<KMAX; k++) {
3615 D0(m11[k],dt,size, m21[k]);
3616 D0(m12[k],dt,size, m22[k]);
3617 D0(p1tmp[k],dt,size, p2tmp[k]);
3618 }
3619
3620 //#if (TEOB_DEBUG)
3621 // fp = fopen("nqc_amp_func.txt", "w");
3622 // for (int j=0; j<size; j++) {
3623 // fprintf(fp, "%e\t%e\t%e\n", t[j], p1tmp[1][j], p2tmp[1][j]);
3624 // }
3625 // fclose(fp);
3626 //#endif
3627
3628 // REAL8 detM = 1.;
3629 REAL8 oodetM = 1.;
3630 for (int k=0; k<KMAX; k++) {
3631
3632 ai[k][0] = ai[k][1] = 0.;
3633 bi[k][0] = bi[k][1] = 0.;
3634
3635 /* Computation of ai coefficients at Omega peak */
3636 P[0] = max_A[k] - p1tmp[k][jmax];
3637 P[1] = max_dA[k] - p2tmp[k][jmax];
3638
3639 M[0] = m11[k][jmax];
3640 M[1] = m12[k][jmax];
3641 M[2] = m21[k][jmax];
3642 M[3] = m22[k][jmax];
3643
3644 /* detM = M[0]*M[3]-M[1]*M[2];
3645 ai[k][0] = (M[3]*P[0] - M[1]*P[1])/detM;
3646 ai[k][1] = (M[0]*P[1] - M[2]*P[0])/detM; */
3647 /* safe version (amplitude can be zero) */
3648 oodetM = 1.0/(M[0]*M[3]-M[1]*M[2]);
3649 if (isfinite((double) oodetM)) {
3650 ai[k][0] = (M[3]*P[0] - M[1]*P[1])*oodetM;
3651 ai[k][1] = (M[0]*P[1] - M[2]*P[0])*oodetM;
3652 }
3653
3654 /* Computation of bi coefficients at Omega peak */
3655 P[0] = omg[k][jmax] - max_omg[k];
3656 P[1] = domg[k][jmax] - max_domg[k];
3657
3658 M[0] = d_n4[jmax];
3659 M[1] = d_n5[jmax];
3660 M[2] = d2_n4[jmax];
3661 M[3] = d2_n5[jmax];
3662
3663 /* detM = M[0]*M[3] - M[1]*M[2];
3664 bi[k][0] = (M[3]*P[0] - M[1]*P[1])/detM;
3665 bi[k][1] = (M[0]*P[1] - M[2]*P[0])/detM; */
3666 /* safe version (phase can be zero) */
3667 oodetM = 1.0/(M[0]*M[3]-M[1]*M[2]);
3668 if (isfinite((double) oodetM)) {
3669 bi[k][0] = (M[3]*P[0] - M[1]*P[1])*oodetM;
3670 bi[k][1] = (M[0]*P[1] - M[2]*P[0])*oodetM;
3671 }
3672
3673 }
3674
3675 // if (TEOB_VERBOSE){
3676 // printf("NQC coefficients for 22 mode:\n");
3677 // PRFORMd("a1",ai[1][0]);
3678 // PRFORMd("a2",ai[1][1]);
3679 // PRFORMd("b1",bi[1][0]);
3680 // PRFORMd("b2",bi[1][1]);
3681 // }
3682
3683 /* Set amplitude and phase */
3684 // TODO: [optimization] vectorize!
3685 this = hnqc;
3686 for (int k=0; k<KMAX; k++) {
3687 for (int j=0; j<size; j++) {
3688 this->ampl->data->data[j] = 1. + ai[k][0]*n1[j] + ai[k][1]*n2[j];
3689 this->phase->data->data[j] = bi[k][0]*n4[j] + bi[k][1]*n5[j];
3690 }
3691 this = this->next;
3692 }
3693
3694 this = h;
3695 SphHarmPolarTimeSeries *that = hnqc;
3696 /* Multiply waveform to NQC */
3697 // TODO: [optimization] vectorize!
3698 while (this && that) {
3699 for (int j=0; j<size; j++) {
3700 this->ampl->data->data[j] *= that->ampl->data->data[j];
3701 this->phase->data->data[j] -= that->phase->data->data[j];
3702 }
3703 this = this->next;
3704 that = that->next;
3705 }
3706
3707 /* Free mem */
3708 for (int k=0; k<KMAX; k++) {
3709 XLALFree(omg[k]);
3710 XLALFree(domg[k]);
3711 XLALFree(m11[k]);
3712 XLALFree(m12[k]);
3713 XLALFree(m13[k]);
3714 XLALFree(m21[k]);
3715 XLALFree(m22[k]);
3716 XLALFree(p1tmp[k]);
3717 XLALFree(p2tmp[k]);
3718 }
3719 XLALFree(n1);
3720 XLALFree(n2);
3721 XLALFree(n3);
3722 XLALFree(n4);
3723 XLALFree(n5);
3724 XLALFree(n6);
3725 XLALFree(d_n4);
3726 XLALFree(d_n5);
3727 XLALFree(d2_n4);
3728 XLALFree(d2_n5);
3729
3730}
3731
3732/* Computes the factors and the coefficients that build the
3733 NQC corrections to the waveform in the spinning case.
3734 This routine works around merger with dyn and h and
3735 then add everything also to hlm */
3737{
3738
3739 REAL8 A_tmp, dA_tmp, omg_tmp, domg_tmp;
3740
3741 const REAL8 nu = dyn->nu;
3742 const REAL8 X1 = dyn->X1;
3743 const REAL8 X2 = dyn->X2;
3744 const REAL8 chi1 = dyn->chi1;
3745 const REAL8 chi2 = dyn->chi2;
3746 const REAL8 aK = dyn->a1 + dyn->a2;
3747
3748 const REAL8 nu2 = SQ(nu);
3749 const REAL8 nu3 = nu2*nu;
3750 const REAL8 X12 = X1 - X2;
3751 const REAL8 aK2 = SQ(aK);
3752 const REAL8 aK3 = aK2*aK;
3753 const REAL8 aK4 = aK2*aK2;
3754 const REAL8 a12 = X1*chi1 - X2*chi2;
3755 const REAL8 aeff = aK + 1./3.*a12*X12;
3756 const REAL8 aeff_omg = aK + a12*X12;
3757
3758 REAL8 *t = hlm_mrg->tdata->data;
3759 REAL8 *r = dyn_mrg->data[TEOB_RAD];
3760 REAL8 *w = dyn_mrg->data[TEOB_MOMG]; /* Omega */
3761 REAL8 UNUSED *pph = dyn_mrg->data[TEOB_PPHI];
3762 REAL8 *pr_star = dyn_mrg->data[TEOB_PRSTAR];
3763 REAL8 *Omg_orb = dyn_mrg->data[TEOB_OMGORB]; /* Omega orbital */
3764 REAL8 *ddotr = dyn_mrg->data[TEOB_DDOTR];
3765
3766 REAL8 c_p1, c_p2, c_p3, c_p4;
3767 REAL8 c_pdA1, c_pdA2, c_pdA3, c_pdA4;
3768 REAL8 c_pdomg1, c_pdomg2;
3769 REAL8 n0, d1;
3770 REAL8 a0_omg_tmp, a1_omg_tmp, a2_omg_tmp, b0_omg_tmp, b1_omg_tmp, b2_omg_tmp, a0_domg_tmp, a1_domg_tmp, a2_domg_tmp, b0_domg_tmp, b1_domg_tmp, b2_domg_tmp, a0_A_tmp, a1_A_tmp , a2_A_tmp, b0_A_tmp, b1_A_tmp, b2_A_tmp, a0_dA_tmp, a1_dA_tmp, a2_dA_tmp, b0_dA_tmp, b1_dA_tmp, b2_dA_tmp, omg_tmp_nu, omg_tmp_equal, domg_tmp_nu, domg_tmp_equal, A_tmp_scale_nu, A_tmp_scale_equal, dA_tmp_scale_nu, dA_tmp_scale_equal ;
3771
3772 REAL8 P[2], M[4], p1[2], p2[2], p3[2], p4[2], pA[5], pdA[5];
3773 REAL8 pomg[5], pdomg[5], pn0[2], pd1[2], ppdomg1[2], ppdomg2[2], pdA1[2],pdA2[2],pdA3[2],pdA4[2];
3774 REAL8 max_A[KMAX], max_dA[KMAX], UNUSED d2max[KMAX], UNUSED d3max[KMAX], max_omg[KMAX], max_domg[KMAX], UNUSED maxd2omg[KMAX], UNUSED DeltaT[KMAX];
3775 REAL8 ai[KMAX][2];
3776 REAL8 bi[KMAX][2];
3777
3778 /* SphHarmSetTData has already taken care of pointing to time sequence */
3779 const int size = (int) hlm_mrg->tdata->length;
3780
3781 REAL8 *omg[KMAX], *domg[KMAX];
3782 REAL8 *n1,*n2,*n3,*n4,*n5,*n6, *d_n4,*d_n5, *d2_n4,*d2_n5;
3783 REAL8 *m11[KMAX], *m12[KMAX], *m13[KMAX], *m21[KMAX], *m22[KMAX];
3784 REAL8 *p1tmp[KMAX], *p2tmp[KMAX]; /* RWZ amplitude and derivative */
3785
3786 for (int k=0; k<KMAX; k++)
3787 {
3788 omg[k] = (REAL8*) calloc (size,sizeof(REAL8));
3789 domg[k] = (REAL8*) calloc (size,sizeof(REAL8));
3790 m11[k] = (REAL8*) calloc (size,sizeof(REAL8));
3791 m12[k] = (REAL8*) calloc (size,sizeof(REAL8));
3792 m13[k] = (REAL8*) calloc (size,sizeof(REAL8));
3793 m21[k] = (REAL8*) calloc (size,sizeof(REAL8));
3794 m22[k] = (REAL8*) calloc (size,sizeof(REAL8));
3795 p1tmp[k] = (REAL8*) calloc (size,sizeof(REAL8));
3796 p2tmp[k] = (REAL8*) calloc (size,sizeof(REAL8));
3797 }
3798
3799 n1 = (REAL8*) calloc (size,sizeof(REAL8));
3800 n2 = (REAL8*) calloc (size,sizeof(REAL8));
3801 n3 = (REAL8*) calloc (size,sizeof(REAL8));
3802 n4 = (REAL8*) calloc (size,sizeof(REAL8));
3803 n5 = (REAL8*) calloc (size,sizeof(REAL8));
3804 n6 = (REAL8*) calloc (size,sizeof(REAL8));
3805 d_n4 = (REAL8*) calloc (size,sizeof(REAL8));
3806 d_n5 = (REAL8*) calloc (size,sizeof(REAL8));
3807 d2_n4 = (REAL8*) calloc (size,sizeof(REAL8));
3808 d2_n5 = (REAL8*) calloc (size,sizeof(REAL8));
3809
3810 /* omega derivatives */
3811 const REAL8 dt = t[1]-t[0];
3813 this = hlm_mrg;
3814 for (int k=0; k<KMAX; k++)
3815 {
3816 D0(this->phase->data->data, dt, size, omg[k]);
3817 D0(omg[k], dt, size, domg[k]);
3818 this = this->next;
3819 }
3820
3821 /* NR fits */
3822 if (DEQUAL(nu,0.25,1e-9))
3823 {
3824
3825 pA[0] = 0.00178195;
3826 pA[1] = 0.00435589;
3827 pA[2] = 0.00344489;
3828 pA[3] = -0.00076165;
3829 pA[4] = 0.31973334;
3830 A_tmp = pA[0]*aK4 + pA[1]*aK3 + pA[2]*aK2 + pA[3]*aK + pA[4];
3831
3832 pdA[0] = 0.00000927;
3833 pdA[1] = -0.00024550;
3834 pdA[2] = 0.00012469;
3835 pdA[3] = 0.00123845;
3836 pdA[4] = -0.00195014;
3837 dA_tmp = pdA[0]*aK4 + pdA[1]*aK3 + pdA[2]*aK2 + pdA[3]*aK + pdA[4];
3838
3839 pomg[0] = 0.00603482;
3840 pomg[1] = 0.01604555;
3841 pomg[2] = 0.02290799;
3842 pomg[3] = 0.07084587;
3843 pomg[4] = 0.38321834;
3844 omg_tmp = pomg[0]*aK4 + pomg[1]*aK3 + pomg[2]*aK2 + pomg[3]*aK + pomg[4];
3845
3846 pdomg[0] = 0.00024066;
3847 pdomg[1] = 0.00038123;
3848 pdomg[2] = -0.00049714;
3849 pdomg[3] = 0.00041219;
3850 pdomg[4] = 0.01190548;
3851 domg_tmp = pdomg[0]*aK4 + pdomg[1]*aK3 + pdomg[2]*aK2 + pdomg[3]*aK + pdomg[4];
3852
3853 } else if( nu > 0.16) {
3854
3855 p1[0] = 0.04680896;
3856 p1[1] = -0.00632114;
3857 p2[0] = 0.06586192;
3858 p2[1] = -0.01180039;
3859 p3[0] = -0.11617413;
3860 p3[1] = 0.02704959;
3861 p4[0] = 0.15597465;
3862 p4[1] = 0.28034978;
3863 c_p1 = p1[0]*nu + p1[1];
3864 c_p2 = p2[0]*nu + p2[1];
3865 c_p3 = p3[0]*nu + p3[1];
3866 c_p4 = p4[0]*nu + p4[1];
3867 A_tmp = c_p1*aK3 + c_p2*aK2 + c_p3*aK + c_p4;
3868
3869 pdA1[0] = -0.00130824;
3870 pdA1[1] = 0.00006202;
3871 pdA2[0] = 0.00199855;
3872 pdA2[1] = -0.00027474;
3873 pdA3[0] = 0.00218838;
3874 pdA3[1] = 0.00071540;
3875 pdA4[0] = -0.00362779;
3876 pdA4[1] = -0.00105397;
3877 c_pdA1 = pdA1[0]*nu + pdA1[1];
3878 c_pdA2 = pdA2[0]*nu + pdA2[1];
3879 c_pdA3 = pdA3[0]*nu + pdA3[1];
3880 c_pdA4 = pdA4[0]*nu + pdA4[1];
3881 dA_tmp = c_pdA1*aK3 + c_pdA2*aK2 + c_pdA3*aK+ c_pdA4;
3882
3883 pn0[0] = 0.46908067;
3884 pn0[1] = 0.27022141;
3885 pd1[0] = 0.64131115;
3886 pd1[1] = -0.37878384;
3887 n0 = pn0[0]*nu + pn0[1];
3888 d1 = pd1[0]*nu + pd1[1];
3889 omg_tmp = n0/(1 + d1*aK);
3890
3891 ppdomg1[0] = 0.00061175;
3892 ppdomg1[1] = 0.00074001;
3893 ppdomg2[0] = 0.02504442;
3894 ppdomg2[1] = 0.00548217;
3895 c_pdomg1 = ppdomg1[0]*nu + ppdomg1[1];
3896 c_pdomg2 = ppdomg2[0]*nu + ppdomg2[1];
3897 domg_tmp = c_pdomg1*aK + c_pdomg2;
3898
3899 } else {
3900
3901 /* Fit by G.Riemanschneider incorporating the test-particle NQC point
3902 obtained from the most-recent Teukolsky waveforms done by
3903 M. Colleoni using the 6PN-accurare iResum-radiation reaction.
3904 These points assure a smooth connection between merger and
3905 ringdown also outside the "calibration" domain, notably for
3906 large-mass ratios (though q<=20) and large (negative) spins
3907 Updated, 28/09/2017 */
3908
3909 a0_omg_tmp = -0.1460961247;
3910 a1_omg_tmp = 0.0998056;
3911 a2_omg_tmp = -0.118098;
3912 b0_omg_tmp = -0.3430184009;
3913 b1_omg_tmp = 0.0921551;
3914 b2_omg_tmp = -0.0740285;
3915 omg_tmp_nu = +0.5427169903*nu2 +0.2512395608*nu +0.2863992248;
3916 omg_tmp_equal =((a2_omg_tmp*X12*X12 + a1_omg_tmp*X12 + a0_omg_tmp)*aeff_omg+1)/((b2_omg_tmp*X12*X12 +b1_omg_tmp*X12 + b0_omg_tmp)*aeff_omg+1);
3917 omg_tmp = omg_tmp_nu*omg_tmp_equal;
3918
3919 a0_domg_tmp = +0.0604556289;
3920 b0_domg_tmp = -0.0299583285;
3921 a1_domg_tmp = 0.0711715;
3922 a2_domg_tmp = -0.0500886;
3923 b1_domg_tmp = 0.0461239;
3924 b2_domg_tmp = -0.0153068;
3925
3926 domg_tmp_nu = ( +0.0045213831*nu +0.0064934920)/( -1.4466409969*nu+1);
3927 domg_tmp_equal = (a2_domg_tmp*X12*X12 +a1_domg_tmp*X12 +b0_domg_tmp)*aeff_omg*aeff_omg +(b2_domg_tmp*X12*X12 +b1_domg_tmp*X12+a0_domg_tmp)*aeff_omg+1;
3928 domg_tmp = domg_tmp_nu*domg_tmp_equal;
3929
3930 a0_A_tmp = -0.2750516062;
3931 b0_A_tmp = -0.4693776065;
3932 a1_A_tmp = 0.143066;
3933 a2_A_tmp = -0.0425947;
3934 b1_A_tmp = 0.176955;
3935 b2_A_tmp = -0.111902;
3936
3937 A_tmp_scale_nu = -0.9862040409*nu3 +0.8167558040*nu2 -0.0427442282*nu+0.2948879452;
3938 A_tmp_scale_equal = ((a2_A_tmp*X12*X12 + a1_A_tmp*X12 +a0_A_tmp)*aeff+1)/((b2_A_tmp*X12*X12 + b1_A_tmp*X12 +b0_A_tmp)*aeff+1);
3939 A_tmp = A_tmp_scale_nu*A_tmp_scale_equal*(1-0.5*omg_tmp*aeff);
3940
3941 a0_dA_tmp = +0.0037461628;
3942 b0_dA_tmp = +0.0636082543;
3943 a1_dA_tmp = 0.00129393;
3944 a2_dA_tmp = -0.00239069;
3945 b1_dA_tmp = -0.0534209;
3946 b2_dA_tmp = -0.186101;
3947
3948 dA_tmp_scale_nu = ( -0.0847947167*nu -0.0042142765)/( +16.1559461812*nu+1);
3949 dA_tmp_scale_equal = ((a2_dA_tmp*X12*X12 + a1_dA_tmp*X12+ a0_dA_tmp)*aeff)/((b2_dA_tmp*X12*X12 + b1_dA_tmp*X12 + b0_dA_tmp)*aeff+1);
3950 dA_tmp = (dA_tmp_scale_nu +dA_tmp_scale_equal)*omg_tmp;
3951
3952 }
3953
3954 /* Switch on the 22 values (only) */
3955 for (int k=0; k<KMAX; k++) {
3956 max_A[k] = 0.;
3957 max_dA[k] = 0.;
3958 max_omg[k] = 0.;
3959 max_domg[k] = 0.;
3960 }
3961 max_A[1] = A_tmp;
3962 max_dA[1] = dA_tmp;
3963 max_omg[1] = omg_tmp;
3964 max_domg[1] = domg_tmp;
3965
3966 // if (TEOB_VERBOSE) {
3967 // printf("NR values for NQC determination:\n");
3968 // PRFORMd("A22_mrg",max_A[1]);
3969 // PRFORMd("dA22_mrg",max_dA[1]);
3970 // PRFORMd("omg22_mrg",max_omg[1]);
3971 // PRFORMd("domg22_mrg",max_domg[1]);
3972 // }
3973
3974 /* NQC corrections to AMPLITUDE (n1,n2,n3) and PHASE (n4,n5,n6)
3975 * NQC basis for (2,2) waveform : AMPLITUDE
3976 * note: n3 and n6 are not used
3977 */
3978 REAL8 pr_star2, r2, w2;
3979 for (int j=0; j<size; j++)
3980 {
3981 pr_star2 = SQ(pr_star[j]);
3982 r2 = SQ(r[j]);
3983 w2 = SQ(w[j]); // FIXME: Omg or Omg_orbital ?
3984 n1[j] = pr_star2/(r2*w2); /* [pr*\/(r Omg)]^2 */
3985 n2[j] = ddotr[j]/(r[j]*w2); /* [ddot{r}/(r Omg^2)] */
3986 n4[j] = pr_star[j]/(r[j]*w[j]); /* pr*\/(r Omg) */
3987 n5[j] = n4[j]*r2*w2; /* (pr*)*(r Omg) */
3988 }
3989
3990//#if (TEOB_DEBUG)
3991// fp = fopen("nqc_nfunc.txt", "w");
3992// for (int j=0; j<size; j++) {
3993// fprintf(fp, "%20.12f\t%.16e\t%.16e\t%.16e\t%.16e\n", t[j], n1[j], n2[j], n4[j], n5[j]);
3994// }
3995// fclose(fp);
3996//#endif
3997
3998 /* Derivatives for the phase */
3999 D0(n4,dt,size, d_n4);
4000 D0(n5,dt,size, d_n5);
4001 D0(d_n4,dt,size, d2_n4);
4002 D0(d_n5,dt,size, d2_n5);
4003
4004//#if (TEOB_DEBUG)
4005// fp = fopen("nqc_dfunc.txt", "w");
4006// for (int j=0; j<size; j++) {
4007// fprintf(fp, "%f\t%.16e\t%.16e\t%.16e\t%.16e\n", t[j], d_n4[j], d_n5[j], d2_n4[j], d2_n5[j]);
4008// }
4009// fclose(fp);
4010//#endif
4011
4012 /* Find max Omg */
4013 INT4 Omgmax_index = 0;
4014 REAL8 Omg_max = Omg_orb[0];
4015 for (int j=0; j<size; j++)
4016 {
4017 if (Omg_orb[j] > Omg_max)
4018 {
4019 Omg_max = Omg_orb[j];
4020 Omgmax_index = j;
4021 }
4022 }
4023 //TODO:
4024 //Test the search backwards
4025 /*
4026 int Omgmax_index = size-1;
4027 REAL8 Omg_max = Omg_orb[Omgmax_index];
4028 for (int j=(size-2); j--; ) {
4029 if (Omg_orb[j] < Omg_max)
4030 break;
4031 Omg_max = Omg_orb[j];
4032 Omgmax_index = j;
4033 }
4034 */
4035
4036 /* Time */
4037 REAL8 tOmgOrb_pk = t[Omgmax_index];
4038 REAL8 DeltaT_nqc = eob_nqc_timeshift(nu, chi1);
4039 REAL8 tNQC = tOmgOrb_pk - DeltaT_nqc;
4040
4041// if (TEOB_VERBOSE) {
4042// printf("NQC info:\n");
4043// PRFORMd("DeltaT_tNQC",DeltaT_nqc);
4044// PRFORMd("tNQC[bare]",tNQC);
4045// }
4046
4047 /* Find jmax: t[jmax] <= tNQC */
4048 INT4 jmax = 0;
4049 for (INT4 j=0; j<size; j++)
4050 {
4051 if(t[j] > tNQC)
4052 {
4053 jmax = j-2;
4054 break;
4055 }
4056 }
4057
4058 /* Solve the linear systems */
4059
4060 /* Regge-Wheeler-Zerilli normalized amplitude.
4061 The ringdown coefficient refer to this normalization.
4062 Nagar & Rezzolla, CQG 22 (2005) R167 */
4063 this = hlm_mrg;
4064 for (int k=0; k<KMAX; k++)
4065 {
4066 REAL8 nlm = 1./(sqrt( (this->l+2)*(this->l+1)*this->l*(this->l-1) ) );
4067 for (int j=0; j<size; j++)
4068 {
4069 p1tmp[k][j] = this->ampl->data->data[j] * nlm;
4070 }
4071 this = this->next;
4072 }
4073
4074 /* Matrix elements: waveform amplitude at all points */
4075 for (int k=0; k<KMAX; k++)
4076 {
4077 for (int j=0; j<size; j++)
4078 {
4079 m11[k][j] = n1[j] * p1tmp[k][j];
4080 m12[k][j] = n2[j] * p1tmp[k][j];
4081 }
4082 }
4083
4084 /* Take FD derivatives */
4085 for (int k=0; k<KMAX; k++)
4086 {
4087 D0(m11[k],dt,size, m21[k]);
4088 D0(m12[k],dt,size, m22[k]);
4089 D0(p1tmp[k],dt,size, p2tmp[k]);
4090 }
4091
4092//#if (TEOB_DEBUG)
4093// fp = fopen("nqc_amp_func.txt", "w");
4094// for (int j=0; j<size; j++) {
4095// fprintf(fp, "%e\t%e\t%e\n", t[j], p1tmp[1][j], p2tmp[1][j]);
4096// }
4097// fclose(fp);
4098//#endif
4099
4100// REAL8 detM = 1.;
4101 REAL8 oodetM = 1.;
4102 for (int k=0; k<KMAX; k++) {
4103
4104 ai[k][0] = ai[k][1] = 0.;
4105 bi[k][0] = bi[k][1] = 0.;
4106
4107 /* Computation of ai coefficients at Omega peak */
4108 P[0] = max_A[k] - p1tmp[k][jmax];
4109 P[1] = max_dA[k] - p2tmp[k][jmax];
4110
4111 M[0] = m11[k][jmax];
4112 M[1] = m12[k][jmax];
4113 M[2] = m21[k][jmax];
4114 M[3] = m22[k][jmax];
4115
4116 /* detM = M[0]*M[3]-M[1]*M[2];
4117 ai[k][0] = (M[3]*P[0] - M[1]*P[1])/detM;
4118 ai[k][1] = (M[0]*P[1] - M[2]*P[0])/detM; */
4119 /* safe version (amplitude can be zero) */
4120 oodetM = 1.0/(M[0]*M[3]-M[1]*M[2]);
4121 if (isfinite(oodetM)) {
4122 ai[k][0] = (M[3]*P[0] - M[1]*P[1])*oodetM;
4123 ai[k][1] = (M[0]*P[1] - M[2]*P[0])*oodetM;
4124 }
4125
4126 /* Computation of bi coefficients at Omega peak */
4127 P[0] = omg[k][jmax] - max_omg[k];
4128 P[1] = domg[k][jmax] - max_domg[k];
4129
4130 M[0] = d_n4[jmax];
4131 M[1] = d_n5[jmax];
4132 M[2] = d2_n4[jmax];
4133 M[3] = d2_n5[jmax];
4134
4135 /* detM = M[0]*M[3] - M[1]*M[2];
4136 bi[k][0] = (M[3]*P[0] - M[1]*P[1])/detM;
4137 bi[k][1] = (M[0]*P[1] - M[2]*P[0])/detM; */
4138 /* safe version (phase can be zero) */
4139 oodetM = 1.0/(M[0]*M[3]-M[1]*M[2]);
4140 if (isfinite(oodetM)) {
4141 bi[k][0] = (M[3]*P[0] - M[1]*P[1])*oodetM;
4142 bi[k][1] = (M[0]*P[1] - M[2]*P[0])*oodetM;
4143 }
4144
4145 }
4146
4147// if (TEOB_VERBOSE){
4148// printf("NQC coefficients for 22 mode:\n");
4149// PRFORMd("a1",ai[1][0]);
4150// PRFORMd("a2",ai[1][1]);
4151// PRFORMd("b1",bi[1][0]);
4152// PRFORMd("b2",bi[1][1]);
4153// }
4154
4155 /* Set amplitude and phase */
4156 this = hnqc;
4157 for (int k=0; k<KMAX; k++) {
4158 for (int j=0; j<size; j++) {
4159 this->ampl->data->data[j] = 1. + ai[k][0]*n1[j] + ai[k][1]*n2[j];
4160 this->phase->data->data[j] = bi[k][0]*n4[j] + bi[k][1]*n5[j];
4161 }
4162 this = this->next;
4163 }
4164
4165 /* Multiply merger waveform to NQC */
4166 this = hlm_mrg;
4167 SphHarmPolarTimeSeries *that = hnqc;
4168 while (this && that) {
4169 for (int j=0; j<size; j++) {
4170 this->ampl->data->data[j] *= that->ampl->data->data[j];
4171 this->phase->data->data[j] -= that->phase->data->data[j];
4172 if (DEBUG)
4173 XLAL_CHECK_VOID((this->l == that->l) && (this->m == that->m), XLAL_EFAULT, "Spherical harmonic mode numbers do not agree.");
4174 }
4175 this = this->next;
4176 that = that->next;
4177 }
4178 if (DEBUG)
4179 XLAL_CHECK_VOID(!this && !that, XLAL_EFAULT, "Spherical harmonics link lists do not have the same length.");
4180
4181 /* Multiply full waveform to NQC */
4182
4183 r = dyn->data[TEOB_RAD];
4184 w = dyn->data[TEOB_MOMG]; /* Omega */
4185 pph = dyn->data[TEOB_PPHI];
4186 pr_star = dyn->data[TEOB_PRSTAR];
4187 Omg_orb = dyn->data[TEOB_OMGORB]; /* Omega orbital */
4188 ddotr = dyn->data[TEOB_DDOTR];
4189
4190 free(n1);
4191 free(n2);
4192 free(n4);
4193 free(n5);
4194
4195 const INT4 fullsize = hlm->tdata->length;
4196
4197 n1 = (REAL8*) calloc (fullsize,sizeof(REAL8));
4198 n2 = (REAL8*) calloc (fullsize,sizeof(REAL8));
4199 n4 = (REAL8*) calloc (fullsize,sizeof(REAL8));
4200 n5 = (REAL8*) calloc (fullsize,sizeof(REAL8));
4201
4202 for (int j=0; j<fullsize; j++) {
4203 pr_star2 = SQ(pr_star[j]);
4204 r2 = SQ(r[j]);
4205 w2 = SQ(w[j]); //CHECKME: Omg or Omg_orbital ?
4206 n1[j] = pr_star2/(r2*w2); /* [pr*\/(r Omg)]^2 */
4207 n2[j] = ddotr[j]/(r[j]*w2); /* [ddot{r}/(r Omg^2)] */
4208 n4[j] = pr_star[j]/(r[j]*w[j]); /* pr*\/(r Omg) */
4209 n5[j] = n4[j]*r2*w2; /* (pr*)*(r Omg) */
4210 }
4211
4212 this = hlm;
4213 for (int k=0; k<KMAX; k++) {
4214 for (int j=0; j<fullsize; j++) {
4215 this->ampl->data->data[j] *= (1. + ai[k][0]*n1[j] + ai[k][1]*n2[j]);
4216 this->phase->data->data[j] -= (bi[k][0]*n4[j] + bi[k][1]*n5[j]);
4217 }
4218 this = this->next;
4219 }
4220
4221 /* Free mem */
4222 for (int k=0; k<KMAX; k++)
4223 {
4224 free(omg[k]);
4225 free(domg[k]);
4226 free(m11[k]);
4227 free(m12[k]);
4228 free(m13[k]);
4229 free(m21[k]);
4230 free(m22[k]);
4231 free(p1tmp[k]);
4232 free(p2tmp[k]);
4233 }
4234 free(n1);
4235 free(n2);
4236 free(n3);
4237 free(n4);
4238 free(n5);
4239 free(n6);
4240 free(d_n4);
4241 free(d_n5);
4242 free(d2_n4);
4243 free(d2_n5);
4244}
4245
4246
4247/* Main routine for factorized EOB waveform */
4249{
4250
4251 const REAL8 nu = dyn->nu;
4252 const REAL8 chi1 = dyn->chi1;
4253 const REAL8 chi2 = dyn->chi2;
4254 const REAL8 a1 = dyn->a1;
4255 const REAL8 a2 = dyn->a2;
4256 const REAL8 X1 = dyn->X1;
4257 const REAL8 X2 = dyn->X2;
4258 const REAL8 C_Q1 = dyn->C_Q1;
4259 const REAL8 C_Q2 = dyn->C_Q2;
4260 const int usetidal = dyn->use_tidal;
4261 const int usespins = dyn->use_spins;
4262 const int usespeedytail = 1;
4263 const REAL8 X12 = X1-X2; /* sqrt(1-4nu) */
4264
4265 const REAL8 t = dyn->t;
4266 const REAL8 phi = dyn->phi;
4267 const REAL8 r = dyn->r;
4268 const REAL8 UNUSED pph = dyn->pphi;
4269 const REAL8 prstar = dyn->prstar;
4270 const REAL8 Omega = dyn->Omg;
4271 const REAL8 ddotr = dyn->ddotr;
4272 const REAL8 H = dyn->H;
4273 const REAL8 Heff = dyn->Heff;
4274 const REAL8 jhat = dyn->jhat;
4275 const REAL8 rw = dyn->r_omega;
4276
4277 hlm->time = t;
4278
4279 /* Source term */
4280 REAL8 source[] = {
4281 jhat,Heff,
4282 Heff,jhat,Heff,
4283 jhat,Heff,jhat,Heff,
4284 Heff,jhat,Heff,jhat,Heff,
4285 jhat,Heff,jhat,Heff,jhat,Heff,
4286 Heff,jhat,Heff,jhat,Heff,jhat,Heff,
4287 jhat,Heff,jhat,Heff,jhat,Heff,jhat,Heff
4288 };
4289
4290 /* Newtonian waveform */
4292 eob_wav_hlmNewt(rw,Omega,phi,nu, &hNewt);
4293
4294 if (usetidal) {
4295 /* Need to correct some of the m=odd modes.
4296 The Newtonian factor has a different normalization when entering the point-mass
4297 and the tidal term. The factor X12 = sqrt*1-4nu) is re-introduced in the point-mass term
4298 in eob_wav_hlm() */
4299 REAL8 vphi3 = gsl_pow_int(rw*Omega,3);
4300 hNewt.ampli[0] = ChlmNewt_ampli[0] * vphi3;
4301 hNewt.ampli[2] = ChlmNewt_ampli[2] * vphi3;
4302 hNewt.ampli[4] = ChlmNewt_ampli[4] * vphi3;
4303 REAL8 p4_vphi5 = (2.*nu-1) * gsl_pow_int(rw*Omega,5);
4304 hNewt.ampli[5] = ChlmNewt_ampli[5] * p4_vphi5;
4305 hNewt.ampli[7] = ChlmNewt_ampli[7] * p4_vphi5;
4306 hNewt.ampli[9] = ChlmNewt_ampli[9] * p4_vphi5;
4307 hNewt.ampli[11] = ChlmNewt_ampli[11] * p4_vphi5;
4308 hNewt.ampli[13] = ChlmNewt_ampli[13] * p4_vphi5;
4309 }
4310
4311 if (usespins) {
4312 /* Special treatment when spin is on because of the singularity in the sqrt(1-4*nu)
4313 for m=odd mode and nu=1/4. See discussion in
4314 Damour & Nagar, PRD 90, 044018, Sec. 4, Eq.(89).
4315 This is not done for multipoles l>4 because no spinning information is included there */
4316
4317 REAL8 vphi3 = gsl_pow_int(rw*Omega,3);
4318 hNewt.ampli[0] = ChlmNewt_ampli[0] * vphi3; /* (2,1) */
4319 hNewt.ampli[2] = ChlmNewt_ampli[2] * vphi3; /* (3,1) */
4320 hNewt.ampli[4] = ChlmNewt_ampli[4] * vphi3; /* (3,3) */
4321
4322 REAL8 p4_vphi5 = (2.*nu-1) * gsl_pow_int(rw*Omega,5);
4323 hNewt.ampli[5] = ChlmNewt_ampli[5] * p4_vphi5; /* (4,1) */
4324 hNewt.ampli[7] = ChlmNewt_ampli[7] * p4_vphi5; /* (4,3) */
4325 hNewt.ampli[9] = ChlmNewt_ampli[9] * p4_vphi5 * X12; /* (5,1) */
4326 hNewt.ampli[11] = ChlmNewt_ampli[11] * p4_vphi5 * X12; /* (5,3) */
4327 hNewt.ampli[13] = ChlmNewt_ampli[13] * p4_vphi5 * X12; /* (5,5) */
4328 }
4329
4330 /* Compute corrections */
4331 REAL8 rholm[KMAX], flm[KMAX];
4332 REAL8 x = SQ(rw*Omega);
4333 if (usespins){
4334 /* eob_wav_flm_s_old(x, nu, X1,X2,chi1,chi2,a1,a2,C_Q1,C_Q2,usetidal,rholm,flm); */
4335 dyn->eob_wav_flm_s(x, nu, X1, X2, chi1, chi2, a1, a2, C_Q1, C_Q2, dyn->clm, usetidal, rholm, flm);
4336 } else {
4337 /* eob_wav_flm_old(x, nu, rholm,flm); */
4338 eob_wav_flm(x, nu, dyn->clm, rholm, flm);
4339 }
4340
4341 /* Computing the tail */
4342#define RTAIL (1.213061319425267e+00)
4343 const REAL8 Hreal = H * nu;
4345 if (usespeedytail) {
4346 eob_wav_speedyTail(Omega, Hreal, RTAIL, &tlm);
4347 } else {
4348 eob_wav_hhatlmTail(Omega, Hreal, RTAIL, &tlm);
4349 }
4350
4351 /* Residual phase corrections delta_{lm} */
4352 REAL8 dlm[KMAX];
4353 eob_wav_deltalm(Hreal, Omega, nu, dlm);
4354
4355 /* Point-mass h_lm */
4356 for (int k = 0; k < KMAX; k++) {
4357 hlm->ampli[k] = hNewt.ampli[k] * flm[k] * source[k] * tlm.ampli[k];
4358 hlm->phase[k] = -( hNewt.phase[k] + tlm.phase[k] + dlm[k]); /* Minus sign by convention */
4359 }
4360
4361 /* NQC */
4362 if (!(dyn->nqc_coeffs_hlm == NQC_OFF) &&
4364 {
4366 /* eob_wav_hlmNQC_nospin2016(nu,r,prstar,Omega,ddotr, &hNQC); */
4367 eob_wav_hlmNQC(nu, r, prstar, Omega, ddotr, dyn->NQC->hlm, &hNQC);
4368
4369 const INT4 maxk = MIN(KMAX, dyn->NQC->hlm->maxk+1);
4370 /* Add NQC correction where necessary */
4371 for (INT4 k = 0; k < maxk; k++) {
4372 if (dyn->NQC->hlm->activemode[k]) {
4373 hlm->ampli[k] *= hNQC.ampli[k];
4374 hlm->phase[k] -= hNQC.phase[k];
4375 }
4376 }
4377 }
4378
4379 if (usetidal) {
4380 /* Tidal contribution */
4381 REAL8 hlmtidal[KMAX];
4382 eob_wav_hlmTidal(x, dyn, hlmtidal);
4383 if( !(usespins) ) {
4384 /* Correct normalization of point-mass wave for some of the m=odd modes */
4385 hlm->ampli[0] *= X12;
4386 hlm->ampli[2] *= X12;
4387 hlm->ampli[4] *= X12;
4388 hlm->ampli[5] *= X12;
4389 hlm->ampli[7] *= X12;
4390 hlm->ampli[9] *= X12;
4391 hlm->ampli[11] *= X12;
4392 hlm->ampli[13] *= X12;
4393 }
4394 /* Add tidal contribution to waveform */
4395 for (int k = 0; k < KMAX; k++) {
4396 hlm->ampli[k] += (hNewt.ampli[k] * tlm.ampli[k] * hlmtidal[k]);
4397 }
4398
4399 }
4400
4401 return;
4402}
4403
4404/* Fit of c3, TEOBResumS paper Nagar et al. (2018)
4405 Note: c3 = 0 with tides*/
4406REAL8 eob_c3_fit_global(REAL8 nu, REAL8 UNUSED chi1, REAL8 UNUSED chi2, REAL8 UNUSED X1, REAL8 UNUSED X2, REAL8 a1, REAL8 a2)
4407{
4408 const REAL8 nu2 = nu*nu;
4409 const REAL8 nu3 = nu2*nu;
4410 const REAL8 X12 = sqrt(1.-4.*nu);
4411 const REAL8 a12 = a1+a2;
4412
4413 /* Equal-mass, equal-spin coefficients */
4414 const REAL8 c0 = 43.371638;
4415 const REAL8 n1 = -1.174839;
4416 const REAL8 n2 = 0.354064;
4417 const REAL8 d1 = -0.151961;
4418
4419 const REAL8 c3_eq = c0*(1. + n1*a12 + n2*a12*a12)/(1.+d1*a12);
4420
4421 /* Coefficients 10/05/2018 */
4422 const REAL8 cnu = 929.579;
4423 const REAL8 cnu2 = -9178.87;
4424 const REAL8 cnu3 = 23632.3;
4425 const REAL8 ca1_a2 = -104.891;
4426
4427 const REAL8 c3_uneq = cnu*a12*nu*X12 + cnu2*a12*nu2*X12 + cnu3*a12*nu3*X12 + ca1_a2*(a1-a2)*nu2;
4428
4429 return c3_eq + c3_uneq;
4430}
4431
4432/* Time-shift for NQC */
4434{
4435
4436 REAL8 DeltaT_nqc = 1.0;
4437
4438 /* Additional time-shift only needed ONLY for large, negative, spins.
4439 This change from 1.0 to 4.0 eliminates unphysical features in the
4440 frequency related to the imperfect behavior of the NQC functions */
4441
4442 /* Old Delta_T NQC
4443 if ((chi1 <-0.85) && (nu <= 14./225.)) {
4444 DeltaT_nqc = 4.0;
4445 } else {
4446 DeltaT_nqc = 1.0; // standard choice inspired by test-particle results
4447 }
4448 */
4449
4450 /* New Delta_T NQC determined in TEOBResumS paper (arXiv:1806.01772) */
4451 if (((chi1 < -0.9) && (nu < 8./81.)) || ((chi1 < -0.8) && (nu < 11./144.))) {
4452 DeltaT_nqc = 4.0;
4453 } else {
4454 DeltaT_nqc = 1.0; // standard choice inspired by test-particle results
4455 }
4456
4457 return DeltaT_nqc;
4458}
4459
4460/* Set NQC coefficients */
4462{
4463 NQCdata *nqc;
4464 nqc = dyn->NQC;
4465 REAL8 nu = dyn->nu;
4466
4467 nqc->flx->add = 1;
4468 nqc->hlm->add = 1;
4469
4470 if (dyn->nqc_coeffs_hlm == NQC_OFF)
4471 nqc->hlm->add = 0;
4472 if (dyn->nqc_coeffs_flx == NQC_OFF)
4473 nqc->flx->add = 0;
4474
4475 /* Init NQC coefs to zero */
4476 for (int k = 0; k < KMAX; k++) {
4477 for (int j = 0; j < 6; j++) {
4478 nqc->flx->n[k][j] = 0.;
4479 nqc->hlm->n[k][j] = 0.;
4480 }
4481 nqc->flx->a1[k] = 0.;
4482 nqc->flx->a2[k] = 0.;
4483 nqc->flx->a3[k] = 0.;
4484 nqc->flx->b1[k] = 0.;
4485 nqc->flx->b2[k] = 0.;
4486 nqc->flx->b3[k] = 0.;
4487 nqc->flx->activemode[k] = 0;
4488 nqc->hlm->a1[k] = 0.;
4489 nqc->hlm->a2[k] = 0.;
4490 nqc->hlm->a3[k] = 0.;
4491 nqc->hlm->b1[k] = 0.;
4492 nqc->hlm->b2[k] = 0.;
4493 nqc->hlm->b3[k] = 0.;
4494 nqc->hlm->activemode[k] = 0;
4495 }
4496 nqc->flx->maxk = -1;
4497 nqc->hlm->maxk = -1;
4498
4499 if (nqc->flx->add + nqc->hlm->add == 0)
4500 return;
4501
4502 /*
4503 * NOTE: Option coefs from file is not used;
4504 * NR implies nrfit_nospin201602
4505 */
4506
4507 // if (STREQUAL(par_get_s("nqc_coefs_flx"),"nrfit_nospin201602"))
4508 // TODO: ADD HERE YOUR LATEST FITS
4509 //else if (STREQUAL(par_get_s("nqc_coefs_hlm"),"nrfit_spin_202001"))
4512
4513
4514 // if (STREQUAL(par_get_s("nqc_coefs_hlm"),"nrfit_nospin201602"))
4515 // TODO: ADD HERE YOUR LATEST FITS
4516 //else if (STREQUAL(par_get_s("nqc_coefs_hlm"),"nrfit_spin_202001"))
4519
4520}
4521
4522/* Set NQC coefficients
4523 NR fits for nonspinning case 2016/02/09
4524 Hardcoded in eob_wav_hlmNQC_nospin201602() */
4526{
4527
4528 const REAL8 xnu = 1-4*nu;
4529 const REAL8 xnu2 = SQ(xnu);
4530
4531 const INT4 k21 = 0;
4532 const INT4 k22 = 1;
4533 const INT4 k33 = 4;
4534
4535 nqc->activemode[k21]=1;
4536 nqc->activemode[k22]=1;
4537 nqc->activemode[k33]=1;
4538
4539 /* (2,1) */
4540 nqc->a1[k21] = 0.0162387198*(7.32653082*xnu2 + 1.19616248*xnu + 0.73496656);
4541 nqc->a2[k21] = -1.80492460*xnu2 + 1.78172686*xnu + 0.30865284;
4542 nqc->a3[k21] = 0.0;
4543
4544 nqc->b1[k21] = -0.0647955017*(3.59934444*xnu2 - 4.08628784*xnu + 1.37890907);
4545 nqc->b2[k21] = 1.3410693180*(0.38491989*xnu2 + 0.10969453*xnu + 0.97513971);
4546 nqc->b3[k21] = 0.0;
4547
4548 /* (2,2) */
4549 nqc->a1[k22] = -0.0805236959*( 1 - 2.00332326*xnu2)/( 1 + 3.08595088*xnu2);
4550 nqc->a2[k22] = 1.5299534255*( 1 + 1.16438929*xnu2)/( 1 + 1.92033923*xnu2);
4551 nqc->a3[k22] = 0.0;
4552
4553 nqc->b1[k22] = 0.146768094955*( 0.07417121*xnu + 1.01691256);
4554 nqc->b2[k22] = 0.896911234248*(-0.61072011*xnu + 0.94295129);
4555 nqc->b3[k22] = 0.0;
4556
4557 /* (3,3) */
4558 nqc->a1[k33] = -0.0377680000*(1 - 14.61548907*xnu2)/( 1 + 2.44559263*xnu2);
4559 nqc->a2[k33] = 1.9898000000*(1 + 2.09750346 *xnu2)/( 1 + 2.57489466*xnu2);
4560 nqc->a3[k33] = 0.0;
4561
4562 nqc->b1[k33] = 0.1418400000*(1.07430512 - 1.23906804*xnu + 4.44910652*xnu2);
4563 nqc->b2[k33] = 0.6191300000*(0.80672432 + 4.07432829*xnu - 7.47270977*xnu2);
4564 nqc->b3[k33] = 0.0;
4565
4566 nqc->add = 1;
4567 nqc->maxk = k33;
4568
4569}
4570
4571
4572/* QNM fits for the 22 mode for spinning systems */
4574 REAL8 X1,
4575 REAL8 X2,
4576 REAL8 chi1,
4577 REAL8 chi2,
4578 REAL8 aK,
4579 REAL8 Mbh,
4580 REAL8 abh,
4581 REAL8 *a1,
4582 REAL8 *a2,
4583 REAL8 *a3,
4584 REAL8 *a4,
4585 REAL8 *b1,
4586 REAL8 *b2,
4587 REAL8 *b3,
4588 REAL8 *b4,
4589 REAL8 *sigmar,
4590 REAL8 *sigmai,
4591 int usespins)
4592{
4593
4594 const REAL8 a12 = X1*chi1 - X2*chi2;
4595 const REAL8 X12 = X1 - X2;
4596 const REAL8 aeff = aK + 1./3.*a12*X12;
4597 const REAL8 aeff_omg = aK + a12*X12;
4598 const REAL8 af = abh;
4599 const REAL8 nu2 = SQ(nu);
4600 const REAL8 nu3 = nu2*nu;
4601 const REAL8 aeff2 = SQ(aeff);
4602 const REAL8 aeff3 = aeff2*aeff;
4603 const REAL8 af2 = SQ(af);
4604 const REAL8 af3 = af2*af;
4605 const REAL8 aeff_omg2 = SQ(aeff_omg);
4606 const REAL8 aeff_omg3 = aeff_omg2*aeff_omg;
4607 const REAL8 aeff_omg4 = SQ(aeff_omg2);
4608 const REAL8 X12_2 = SQ(X12);
4609
4610 REAL8 alpha21[KMAX], alpha1[KMAX], omega1[KMAX], c3A[KMAX], c3phi[KMAX], c4phi[KMAX], Domg[KMAX], Amrg[KMAX], c2A[KMAX];
4611
4612
4613 INT4 modeon[KMAX];
4614 const INT4 k21 = 0;
4615 const INT4 k22 = 1;
4616 const INT4 k33 = 4;
4617 const INT4 UNUSED k44 = 8;
4618
4619 for (int k=0; k<KMAX; k++) {
4620 modeon[k] = 0; /* off */
4621 sigmar[k] = sigmai[k] = 0.;
4622 a1[k] = a2[k] = a3[k] = a4[k] = 0.;
4623 b1[k] = b2[k] = b3[k] = b4[k] = 0.;
4624 }
4625
4626 if (!(usespins)) {
4627
4628 modeon[k21]=1;
4629 modeon[k22]=1;
4630 modeon[k33]=1;
4631
4632 /* Last updates: 05/09/2017 from CoM extrapolated SXS data */
4633
4634 // l=2 -------------------------------------------------------------------
4635
4636 /* (l=2, m=2)*/
4637 alpha21[k22] = -0.3025985041156393 *nu2 + 0.0032794155172817 *nu + 0.1828276903682022;
4638 alpha1[k22] = -0.1615300454109702 *nu2 + 0.0147030662812516 *nu + 0.0878204175700328;
4639 c3A[k22] = 0.8118901739129283 *nu - 0.5584875090785957;
4640 c3phi[k22] = 0.7156419884962878 *nu + 3.8436474282409803;
4641 c4phi[k22] = 2.2336960710670901 *nu + 1.4736119175780844;
4642 Domg[k22] = 0.8846304360111242 *nu2 + 0.0872792137250448 *nu + 0.1058414813686749;
4643 Amrg[k22] = 1.4935750287318139 *nu2 + 0.2157497669089671 *nu + 1.4292027468283439;
4644
4645 /* (l=2, m=1)*/
4646 alpha21[k21] = -0.2741607253846813 *nu2 + 0.0079342900879431 *nu + 0.1835522430667348;
4647 alpha1[k21] = -0.1277546304610336 *nu2 + 0.0093615534859368 *nu + 0.0882855170502398;
4648 c3A[k21] = -0.9431151070942140 *nu + 0.2569989171628133;
4649 c3phi[k21] = -3.4479482376671666 *nu + 2.4755856452648359;
4650 c4phi[k21] = -3.4024504071619841 *nu + 1.0650118588151427;
4651 Domg[k21] = 0.2660644668923829 *nu2 + 0.2276854484140649 *nu + 0.0884880283627388;
4652 Amrg[k21] = -5.7236432632743952 *nu2 + 0.0390010969627653 *nu + 0.4291847351869338;
4653
4654 // l=3 ------------------------------------------------------------------
4655 /* (l=3,m=3)*/
4656 alpha21[k33] = -0.3620553934265325 *nu2 + 0.0171973908686402 *nu + 0.1865364041200878;
4657 alpha1[k33] = -0.1821867653548689 *nu2 + 0.0134440240947561 *nu + 0.0916720214797975;
4658 c3A[k33] = 2.7565431398030675 *nu - 0.5506682334306747;
4659 c3phi[k33] = -0.2497526471104979 *nu + 2.3737675006958683;
4660 c4phi[k33] = -2.9538823110315420 *nu + 1.4483501341373066;
4661 Domg[k33] = 1.3341439550896721 *nu2 - 0.1717105341058959 *nu + 0.1694617455660599;
4662 Amrg[k33] = -9.3034388918614841 *nu2 + 1.0189351143222705 *nu + 0.4533252110436300;
4663
4664 // l=4 ------------------------------------------------------------------
4665 /* (l=4,m=4)*/
4666 /* alpha21[k44] = -0.3991680748908423 *nu2 + 0.0287698202159666 *nu + 0.1880112530796091; */
4667 /* alpha1[k44] = -0.2003781755488581 *nu2 + 0.0171888841352427 *nu + 0.0930836242032652; */
4668 /* c3A[k44] = 3.1899853343683140 *nu + -0.4131730594856833; */
4669 /* c3phi[k44] = 31.5753575286023747 *nu + -1.0375600524681363; */
4670 /* c4phi[k44] = 25.4170586178559716 *nu + -0.4151371540505313; */
4671 /* Domg[k44] = -1.5342842283421341 *nu2 + 1.5224173843877831 *nu + 0.0897013049238634; */
4672 /* Amrg[k44] = 0.9438333992719329 *nu2 + -1.0464153920266663 *nu + 0.2897769169572948; */
4673
4674 //sigma[k][0] = -0.208936*nu3 - 0.028103*nu2 - 0.005383*nu + 0.08896;
4675 //sigma[k][1] = 0.733477*nu3 + 0.188359*nu2 + 0.220659*nu + 0.37367;
4676 sigmar[k21] = -0.208936*nu3 - 0.028103*nu2 - 0.005383*nu + 0.08896;
4677 sigmai[k21] = 0.733477*nu3 + 0.188359*nu2 + 0.220659*nu + 0.37367;
4678
4679 sigmar[k22] = -0.364177*nu3 + 0.010951*nu2 - 0.010591*nu + 0.08896;
4680 sigmai[k22] = 2.392808*nu3 + 0.051309*nu2 + 0.449425*nu + 0.37365;
4681
4682 sigmar[k33] = -0.319703*nu3 - 0.030076*nu2-0.009034*nu + 0.09270;
4683 sigmai[k33] = 2.957425*nu3 + 0.178146*nu2 + 0.709560*nu + 0.59944;
4684
4685 } else {
4686
4687 modeon[k22]=1;
4688
4689 /* Setting up coefficients from the phenomenological description of the ringdown.
4690 For notation: Damour&Nagar, PRD 90 (2015), 024054 and Del Pozzo & Nagar, PRD 95 (2017), 124034
4691 Current global fits are new. See Nagar+ 2017 (in preparation) for a global performance
4692 and Riemenschneider& Nagar (2017) in preparation for the description of the fits */
4693
4694 /* omg1 - imaginary part of the fundamental mode */
4695 REAL8 omega1_c = -0.0598837831 * af3 + 0.8082136788 * af2 - 1.7408467418 * af + 1;
4696 REAL8 omega1_d = -0.2358960279 * af3 + 1.3152369374 * af2 - 2.0764065380 * af + 1;
4697 omega1[k22] = 0.3736716844 * (omega1_c/omega1_d);
4698
4699 /* alpha1 - real part (damping time) of the fundamental mode */
4700 REAL8 alpha1_c = 0.1211263886 * af3 + 0.7015835813 * af2 - 1.8226060896 * af + 1;
4701 REAL8 alpha1_d = 0.0811633377 * af3 + 0.7201166020 * af2 - 1.8002031358 * af + 1;
4702 alpha1[k22] = 0.0889623157 * (alpha1_c/alpha1_d);
4703
4704 /* alpha2 - alpha1 */
4705 REAL8 alpha21_c = 0.4764196512 * af3 - 0.0593165805 * af2 - 1.4168096833 * af + 1;
4706 REAL8 alpha21_d = 0.4385578151 * af3 - 0.0763529088 * af2 - 1.3595491146 * af + 1;
4707 alpha21[k22] = 0.1849525596 * (alpha21_c/alpha21_d);
4708
4709 /* c3A */
4710 REAL8 a_c3A = 0.0169543;
4711 REAL8 b_c3A = -0.0799343;
4712 REAL8 c_c3A = -0.115928;
4713 REAL8 c3A_nu = 0.8298678603 * nu - 0.5615838975;
4714 REAL8 c3A_eq = (c_c3A * X12 + 0.0907476903) * aeff3 + (b_c3A * X12 + 0.0227344099) * aeff2 + (a_c3A * X12 - 0.1994944332)*aeff;
4715 c3A[k22] = c3A_nu + c3A_eq;
4716
4717 /* c3_phi */
4718 REAL8 a_c3phi = -0.462321;
4719 REAL8 b_c3phi = -0.904512;
4720 REAL8 c_c3phi = 0.437747;
4721 REAL8 d_c3phi = 1.8275;
4722 REAL8 c3phi_nu = 0.4558467286 * nu + 3.8883812141;
4723 REAL8 c3phi_equal = (d_c3phi*X12-2.0575868122) * aeff_omg4 +(c_c3phi*X12-0.5051534498)*aeff_omg3 +(b_c3phi*X12+2.5742292762)*aeff_omg2 +(a_c3phi*X12+2.5599640181)*aeff_omg;
4724 c3phi[k22] = c3phi_nu + c3phi_equal;
4725
4726 /* c4_phi */
4727 REAL8 a_c4phi = -0.449976;
4728 REAL8 b_c4phi = -0.980913;
4729 REAL8 c4phi_nu = 2.0822327682 * nu + 1.4996868401;
4730 REAL8 c4phi_equal = (b_c4phi*X12+3.5695199109) * aeff_omg2 + (a_c4phi * X12 + 4.1312404030) * aeff_omg;
4731 c4phi[k22] = c4phi_nu + c4phi_equal;
4732
4733 /* omg_mrg: the "merger frequency", i.e. the frequency at the peak of |h22| */
4734 /* Special scaling and independent variables used for the fit. AN&GR 2017 */
4735 REAL8 a2_omgmx = -0.122735;
4736 REAL8 a1_omgmx = 0.0857478;
4737 REAL8 b2_omgmx = -0.0760023;
4738 REAL8 b1_omgmx = 0.0826514;
4739 REAL8 omgmx_eq_c = (a2_omgmx*X12_2 +a1_omgmx*X12 -0.1416002395) * aeff_omg + 1;
4740 REAL8 omgmx_eq_d = (b2_omgmx*X12_2 +b1_omgmx*X12 -0.3484804901) * aeff_omg + 1;
4741 REAL8 omgmx_eq = omgmx_eq_c/omgmx_eq_d;
4742 REAL8 omgmx = (0.481958619443355 * nu2 + 0.223976694441952 * nu + 0.273813064427363) * omgmx_eq;
4743
4744 /* the peak of the h22 metric (strain) waveform.*/
4745 /* Special scaling and independent variables used for the fit. AN& GR 2017*/
4746 REAL8 a2_A_scaled = -0.0820894;
4747 REAL8 a1_A_scaled = 0.176126;
4748 REAL8 b2_A_scaled = -0.150239;
4749 REAL8 b1_A_scaled = 0.20491;
4750 REAL8 A_scaled_eq = ((a2_A_scaled*X12*X12 + a1_A_scaled*X12 -0.2935238329)*aeff + 1)/((b2_A_scaled*X12*X12 + b1_A_scaled*X12 -0.4728707630)*aeff + 1);
4751 REAL8 A_scaled = (+1.826573640739664*nu2 +0.100709438291872*nu +1.438424467327531)*A_scaled_eq;
4752
4753 Amrg[k22] = A_scaled*(1-0.5*omgmx*aeff);
4754 Domg[k22] = omega1[k22] - Mbh*omgmx;
4755
4756 /* renaming real & imaginary part of the QNM complex frequency sigma */
4757 //sigma[k22][0] = alpha1[k22];
4758 //sigma[k22][1] = omega1[k22];
4759 sigmar[k22] = alpha1[k22];
4760 sigmai[k22] = omega1[k22];
4761
4762 }
4763
4764 for (int k=0; k<KMAX; k++) {
4765 if (modeon[k]) {
4766 c2A[k] = 0.5*alpha21[k];
4767 REAL8 cosh_c3A = cosh(c3A[k]);
4768 a1[k] = Amrg[k] * alpha1[k] * cosh_c3A * cosh_c3A / c2A[k];
4769 a2[k] = c2A[k];
4770 a3[k] = c3A[k];
4771 a4[k] = Amrg[k] - a1[k] * tanh(c3A[k]);
4772 b2[k] = alpha21[k];
4773 b3[k] = c3phi[k];
4774 b4[k] = c4phi[k];
4775 b1[k] = Domg[k] * (1+c3phi[k]+c4phi[k]) / (b2[k]*(c3phi[k] + 2.*c4phi[k]));
4776 }
4777 }
4778
4779 return;
4780}
4781
4782
4783/* Ringdown waveform template */
4785 REAL8 a1,
4786 REAL8 a2,
4787 REAL8 a3,
4788 REAL8 a4,
4789 REAL8 b1,
4790 REAL8 b2,
4791 REAL8 b3,
4792 REAL8 b4,
4793 REAL8 sigmar,
4794 REAL8 sigmai,
4795 REAL8 *psi)
4796{
4797 REAL8 amp = ( a1 * tanh(a2*x +a3) + a4 ) ;
4798 REAL8 phase = -b1*log((1. + b3*exp(-b2*x) + b4*exp(-2.*b2*x))/(1.+b3+b4));
4799 psi[0] = amp * exp(-sigmar*x); /* amplitude */
4800 psi[1] = - (phase - sigmai*x); /* phase, minus sign in front by convention */
4801}
4802
4803
4804/* Ringdown calculation and match to the dynamics */
4806{
4807 const REAL8 Mbh = dyn->Mbhf;
4808 const REAL8 abh = dyn->abhf;
4809 const REAL8 nu = dyn->nu;
4810 const REAL8 chi1 = dyn->chi1;
4811 const REAL8 chi2 = dyn->chi2;
4812 const REAL8 X1 = dyn->X1;
4813 const REAL8 X2 = dyn->X2;
4814 const REAL8 aK = dyn->a1+dyn->a2;
4815
4816 const REAL8 xnu = (1.-4.*nu);
4817 const REAL8 ooMbh = 1./Mbh;
4818 const REAL8 dt = dyn->dt;
4819
4820 SphHarmPolarTimeSeries *this_hlm = hlm;
4821
4822 //REAL8 *Omega = dyn->data[TEOB_MOMG];
4823 REAL8 *Omega = dyn->data[TEOB_OMGORB]; /* use this for spin */
4824
4825 /* Note:
4826 dynsize < size , since the wf has been extended
4827 but the two time arrays agree up to dynsize */
4828 const UINT4 dynsize = dyn->size;
4829 const INT4 size = hlm->tdata->length;
4830 REAL8 *t = hlm->tdata->data;
4831
4832 const INT4 k21 = 0;
4833 const INT4 k22 = 1;
4834 const INT4 k33 = 4;
4835
4836 /* Find peak of Omega */
4837 /* Assume a monotonically increasing function, then the peak
4838 start from after the peak */
4839 UINT4 index_pk = dynsize-1;
4840 REAL8 Omega_pk = Omega[index_pk];
4841 for (INT4 j = dynsize-2; j-- ; ) {
4842 if (Omega[j] < Omega_pk)
4843 break;
4844 index_pk = j;
4845 Omega_pk = Omega[j];
4846 }
4847
4848#if (1)
4849
4850 /* This is a hard-fix that always guarantee the 7 points */
4851 /* Make sure to comment the following line in main:
4852 dt_merger_interp = MIN(dt_merger_interp, (dyn->time[size-1] - dyn->tMOmgpeak)/4 );
4853 and uncomment:
4854 dt_merger_interp = MIN(dt_merger_interp, dyn->dt);
4855 */
4856 REAL8 *Omega_ptr = &Omega[index_pk-3];
4857 REAL8 tOmg_pk; /* New interpolated value of the Omega peak */
4858 const INT4 n = 7; /* USE 7, it seems we need at least 7 points to determine t_Omega_peak properly */
4859 REAL8 tmax = dyn->time[index_pk];
4860
4861 if ( (index_pk + (n-1)/2) > (dynsize-1) ) {
4862 /* Here there are not enough points after the Omega peak
4863 We always need 3; we compute what we need by linear extrapolation */
4864 REAL8 Omega_pk_grid[7]; /* Temporary buffer for the 7-point interp */
4865 const INT4 ni = (index_pk + (n-1)/2) - (dynsize-1) ; /* Pts to extrap, 0 < ni <= 3 */
4866
4867 /* Copy the pts we have */
4868 for (int j = 0; j < (7-ni); j++)
4869 Omega_pk_grid[j] = Omega_ptr[j];
4870 /* Extrapolate the others */
4871 if (ni==1) {
4872 Omega_pk_grid[6] = 2.*Omega_pk_grid[5]-Omega_pk_grid[4];
4873 //Omega_pk_grid[6] =3.*Omega_pk_grid[5]-3.*Omega_pk_grid[4]+Omega_pk_grid[3];//quadratic, PLEASE CHECK
4874 } else if (ni==2) {
4875 Omega_pk_grid[5] = 2.*Omega_pk_grid[4]-Omega_pk_grid[3];
4876 Omega_pk_grid[6] = 2.*Omega_pk_grid[5]-Omega_pk_grid[4];
4877 } else if (ni==3) {
4878 Omega_pk_grid[4] = 2.*Omega_pk_grid[3]-Omega_pk_grid[2];
4879 Omega_pk_grid[5] = 2.*Omega_pk_grid[4]-Omega_pk_grid[3];
4880 Omega_pk_grid[6] = 2.*Omega_pk_grid[5]-Omega_pk_grid[4];
4881 } else XLAL_ERROR_VOID(XLAL_EBADLEN, "Wrong counting (ni).\n");
4882
4883 /* Now we have 7 */
4884 tOmg_pk = find_max(n, dt, tmax, Omega_pk_grid, NULL);
4885 } else {
4886 /* Here everything is good */
4887 tOmg_pk = find_max(n, dt, tmax, Omega_ptr, NULL);
4888 }
4889
4890 /* Scale peak value by BH mass */
4891 tOmg_pk *= ooMbh;
4892
4893#else
4894
4895 const INT4 n = 7; /* USE 7, it seems we need at least 7 points to determine t_Omega_peak properly */
4896 XLAL_CHECK_VOID( ( (index_pk + (n-1)/2) <= (dynsize-1) ), XLAL_EBADLEN, "Not enough points to interpolate.\n");
4897
4898 REAL8 tmax = dyn->time[index_pk];
4899 REAL8 *Omega_ptr = &Omega[index_pk-3];
4900 REAL8 tOmg_pk = find_max(n, dt, tmax, Omega_ptr, NULL);
4901 tOmg_pk *= ooMbh;
4902
4903#endif
4904
4905 /* Merger time t_max(A22) */
4906 REAL8 DeltaT_nqc = eob_nqc_timeshift(nu, chi1);
4907 REAL8 tmrg[KMAX], tmatch[KMAX], dtmrg[KMAX];
4908
4909 /* nonspinning case */
4910 /* tmrg[k22] = tOmg_pk-3./Mbh; */ /* OLD */
4911 REAL8 tmrgA22 = tOmg_pk-(DeltaT_nqc + 2.)/Mbh;
4912
4913 for (int k=0; k<KMAX; k++) {
4914 tmrg[k] = tmrgA22;
4915 }
4916
4917 /* The following values are the difference between the time of the peak of
4918 the 22 waveform and the 21 and 33. These specific values refer to the
4919 nonspinning case. They are different in the spinning case, which
4920 is however not implemented. These are here only as placeholder */
4921 dtmrg[k21] = 5.70364338 + 1.85804796*xnu + 4.0332262*xnu*xnu; //k21
4922 dtmrg[k33] = 4.29550934 - 0.85938*xnu; //k33
4923 tmrg[k21] = tmrg[k22] + dtmrg[k21]/Mbh; // t_max(A21) => peak of 21 mode
4924 tmrg[k33] = tmrg[k22] + dtmrg[k33]/Mbh; // t_max(A33) => peak of 33 mode
4925
4926 /* Postmerger-Ringdown matching time */
4927 for (int k=0; k<KMAX; k++) {
4928 tmatch[k] = 2.*ooMbh + tmrg[k];
4929 }
4930
4931 /* Compute QNM */
4932 REAL8 sigma[2][KMAX];
4933 REAL8 a1[KMAX], a2[KMAX], a3[KMAX], a4[KMAX];
4934 REAL8 b1[KMAX], b2[KMAX], b3[KMAX], b4[KMAX];
4935 QNMHybridFitCab(nu, X1, X2, chi1, chi2, aK, Mbh, abh,
4936 a1, a2, a3, a4, b1, b2, b3, b4,
4937 sigma[0], sigma[1], dyn->use_spins);
4938
4939 /* Define a time vector for each multipole, scale by mass
4940 Ringdown of each multipole has its own starting time */
4941 REAL8 *t_lm[KMAX];
4942 for (int k=0; k<KMAX; k++) {
4943 t_lm[k] = malloc ( size * sizeof(REAL8) );
4944 for (int j = 0; j < size; j++ ) {
4945 t_lm[k][j] = t[j] * ooMbh;
4946 }
4947 }
4948
4949 /* Find attachment index */
4950 int idx[KMAX];
4951 for (int k = 0; k < KMAX; k++) {
4952 for (int j = size-1; j-- ; ) {
4953 if (t_lm[k][j] < tmatch[k]) {
4954 idx[k] = j - 1;
4955 break;
4956 }
4957 }
4958 }
4959
4960 /* Compute Ringdown waveform for t>=tmatch */
4961 REAL8 t0, tm, psi[2];
4962 REAL8 Deltaphi[KMAX];
4963
4964 for (int k = 0; k < KMAX; k++) {
4965 XLAL_CHECK_VOID(this_hlm, XLAL_EBADLEN, "Mode does not exist. Reached NULL pointer instead.\n");
4966 /* Calculate Deltaphi */
4967 t0 = t_lm[k][idx[k]] - tmrg[k];
4968 eob_wav_ringdown_template(t0, a1[k], a2[k], a3[k], a4[k], b1[k], b2[k], b3[k], b4[k], sigma[0][k], sigma[1][k], psi);
4969 Deltaphi[k] = psi[1] - this_hlm->phase->data->data[idx[k]];
4970 /* Compute and attach ringdown */
4971 for (int j = idx[k]; j < size ; j++ ) {
4972 tm = t_lm[k][j] - tmrg[k];
4973 eob_wav_ringdown_template(tm, a1[k], a2[k], a3[k], a4[k], b1[k], b2[k], b3[k], b4[k], sigma[0][k], sigma[1][k], psi);
4974 this_hlm->ampl->data->data[j] = psi[0];
4975 this_hlm->phase->data->data[j] = psi[1] - Deltaphi[k];
4976 }
4977 this_hlm = this_hlm->next;
4978 }
4979 XLAL_CHECK_VOID( !(this_hlm), XLAL_EBADLEN, "More modes\n");
4980
4981 /* Free mem. */
4982 for (int k=0; k<KMAX; k++)
4983 {
4984 if(t_lm[k]) free(t_lm[k]);
4985 }
4986
4987}
4988
4989
4990/* Root function to compute light-ring */
4991//TODO: THIS IS FOR NOSPIN
4993{
4995 REAL8 A,B,dA,d2A,dB;
4996 //if (dyn->use_spins) eob_metric_s(r, dyn, &A,&B,&dA,&d2A,&dB);
4997 //else
4998 eob_metric (r, dyn, &A,&B,&dA,&d2A,&dB);
4999 REAL8 u = 1./r;
5000 REAL8 dA_u = (-dA)*SQ(r);
5001 return A + 0.5 * u * dA_u;
5002}
5003
5004/* Root finder for adiabatic light-ring */
5006{
5007 int status;
5008 INT4 iter = 0, max_iter = MAX_ITER;
5009 const double epsabs = 0.; /* if converges, precision is |r-r*| = epsabs + epsrel r* */
5010 const double epsrel = 1e-10;
5011 const gsl_root_fsolver_type *T;
5012 double x, x_lo, x_hi;
5013
5014 /* Set interval to search root */
5015 if (dyn->use_tidal) {
5016 /* Tides are always temporarily set as = NNLO to compute LR,
5017 But we may want to define different searches intervals */
5018 switch (tidesFlag) {
5022 /* BNS */
5023 x_lo = 2.1; // nu~1/4 kappaT2 ~ 12
5024 x_hi = 5.9; // nu~1/4 kappaT2 ~ 600
5025 break;
5026 default:
5027 XLAL_ERROR_REAL8(XLAL_EINVAL, "Invalid tides flag.\n");
5028 }
5029 if (dyn->bhns > 0) {
5030 /* BHNS */
5031 x_lo = 1.8;
5032 x_hi = 5.6; // nu~1/4 kappaT2 ~ 600
5033 }
5034 }
5035 else {
5036 /* BBH */
5037 x_lo = 1.8; // 1.818461553848201e+00 nu = 1/4
5038 x_hi = 3.1; // 3. nu = 0
5039 /* x_lo = 0.9*eob_approxLR(dyn->nu);
5040 x_hi = 1.1*eob_approxLR(dyn->nu); */
5041 }
5042
5043 gsl_root_fsolver *s;
5044 gsl_function F;
5045 F.function = &eob_dyn_fLR;
5046 F.params = dyn;
5047 //T = gsl_root_fsolver_bisection;
5048 T = gsl_root_fsolver_brent;
5049 s = gsl_root_fsolver_alloc (T);
5050 gsl_root_fsolver_set (s, &F, x_lo, x_hi);
5051
5052 do
5053 {
5054 iter++;
5055 status = gsl_root_fsolver_iterate (s);
5056 x = gsl_root_fsolver_root (s);
5057 x_lo = gsl_root_fsolver_x_lower (s);
5058 x_hi = gsl_root_fsolver_x_upper (s);
5059 status = gsl_root_test_interval (x_lo, x_hi, epsabs, epsrel);
5060 }
5061 while (status == GSL_CONTINUE && iter < max_iter);
5062 gsl_root_fsolver_free (s);
5063
5064 *rLR = 0.;
5065 if (isfinite(x)) *rLR = (REAL8) x;
5066
5067 //if (status == ???) {
5068 // return ROOT_ERRORS_BRACKET;
5069 //}
5070 if (status == GSL_SUCCESS) {
5071 return XLAL_SUCCESS;
5072 }
5073 if (iter >= max_iter) {
5074 return XLAL_EMAXITER;
5075 }
5076 if (status != GSL_SUCCESS) {
5077 return XLAL_EFUNC;
5078 }
5079
5080 return status;
5081}
5082
5083
5084/* Root function to compute LSO */
5085//TODO: THIS IS FOR NOSPIN
5086//REAL8 eob_dyn_fLSO(REAL8 r, void *params)
5087//{
5088// LALTEOBResumSDynamics *dyn = params;
5089// REAL8 A,B,dA,d2A,dB;
5090// //if (dyn->use_spins) eob_metric_s(r, dyn, &A,&B,&dA,&d2A,&dB);
5091// //else
5092// eob_metric (r, dyn, &A,&B,&dA,&d2A,&dB);
5093// REAL8 u = 1./r;
5094// REAL8 u2 = SQ(u);
5095// REAL8 dA_u = (-dA)*SQ(r);
5096// REAL8 d2A_u = d2A*SQ(r)*SQ(r) + 2*dA*SQ(r)*r;
5097// dB = u2*dA_u + 2.*A*u;
5098// REAL8 d2B = d2A_u*u2 + 4.*u*dA_u + 2*A;
5099// return ( dA_u*d2B - d2A_u*(dB) );
5100//}
5101
5102///* Root finder for adiabatic LSO */
5103//int eob_dyn_adiabLSO(LALTEOBResumSDynamics *dyn, REAL8 *rLSO)
5104//{
5105// int status;
5106// INT4 iter = 0, max_iter = MAX_ITER;
5107// const double epsabs = 0.; /* if converges, precision is |r-r*| = epsabs + epsrel r* */
5108// const double epsrel = 1e-10;
5109// const gsl_root_fsolver_type *T;
5110// double x;
5111// double x_lo = 4.5; // 4.532648e+00 nu= 1/4
5112// double x_hi = 6.2; // 6 nu=0
5113// if (dyn->use_tidal) x_hi = 36.;
5114//
5115// gsl_root_fsolver *s;
5116// gsl_function F;
5117// F.function = &eob_dyn_fLSO;
5118// F.params = dyn;
5119// //T = gsl_root_fsolver_bisection;
5120// T = gsl_root_fsolver_brent;
5121// s = gsl_root_fsolver_alloc (T);
5122// gsl_root_fsolver_set (s, &F, x_lo, x_hi);
5123//
5124// do
5125// {
5126// iter++;
5127// status = gsl_root_fsolver_iterate (s);
5128// x = gsl_root_fsolver_root (s);
5129// x_lo = gsl_root_fsolver_x_lower (s);
5130// x_hi = gsl_root_fsolver_x_upper (s);
5131// status = gsl_root_test_interval (x_lo, x_hi, epsabs, epsrel);
5132// }
5133// while (status == GSL_CONTINUE && iter < max_iter);
5134// gsl_root_fsolver_free (s);
5135//
5136// *rLSO = 0.;
5137// if (isfinite(x)) *rLSO = (REAL8) x;
5138//
5139// //if (status == ???) {
5140// // return ROOT_ERRORS_BRACKET;
5141// //}
5142// if (status == GSL_SUCCESS) {
5143// return ROOT_ERRORS_NO;
5144// }
5145// if (iter >= max_iter) {
5146// return ROOT_ERRORS_MAXITS;
5147// }
5148// if (status != GSL_SUCCESS) {
5149// return ROOT_ERRORS_NOSUCC;
5150// }
5151//
5152// return status;
5153//}
5154
5155
5156/* POST-ADIABATIC MODULE */
5157
5158/* Post-adiabatic dynamics */
5160{
5161 /* Unpack values */
5162 const REAL8 nu = dyn->nu;
5163 const REAL8 S = dyn->S;
5164 const REAL8 Sstar = dyn->Sstar;
5165 const REAL8 chi1 = dyn->chi1;
5166 const REAL8 chi2 = dyn->chi2;
5167 const REAL8 X1 = dyn->X1;
5168 const REAL8 X2 = dyn->X2;
5169 const REAL8 c3 = dyn->cN3LO;
5170 const REAL8 aK2 = dyn->aK2;
5171 const REAL8 a1 = dyn->a1;
5172 const REAL8 a2 = dyn->a2;
5173 const REAL8 C_Q1 = dyn->C_Q1;
5174 const REAL8 C_Q2 = dyn->C_Q2;
5175 const REAL8 C_Oct1 = dyn->C_Oct1;
5176 const REAL8 C_Oct2 = dyn->C_Oct2;
5177 const REAL8 C_Hex1 = dyn->C_Hex1;
5178 const REAL8 C_Hex2 = dyn->C_Hex2;
5179 const REAL8 z3 = 2.0*nu*(4.0-3.0*nu);
5180 const INT4 usetidal = dyn->use_tidal;
5181 const INT4 usespins = dyn->use_spins;
5182 // MA: probably
5183 const INT4 size = dyn->size;
5184
5185 /* Parameters for post adiabatic dynamics */
5186 // const REAL8 rmin = POSTADIABATIC_RMIN;
5187 // const REAL8 dr = (r0 - rmin)/(size-1); /* Uniform grid spacing */
5188 const REAL8 dr = POSTADIABATIC_DR;
5189
5190 /* Additional memory */
5191 REAL8 *buffer[TEOB_NV];
5192 for (int v=0; v < TEOB_NV; v++)
5193 buffer[v] = malloc(size * sizeof (REAL8));
5194
5195 REAL8 *A_vec = buffer[0];
5196 REAL8 *dA_vec = buffer[1];
5197 REAL8 *B_vec = buffer[2];
5198 REAL8 *sqrtAbyB_vec = buffer[3];
5199 REAL8 *rc_vec = buffer[4];
5200 REAL8 *drc_dr_vec = buffer[5];
5201 REAL8 *uc2_vec = buffer[6];
5202 REAL8 *duc_dr_vec = buffer[7];
5203 REAL8 *dAuc2_dr_vec = buffer[8];
5204 REAL8 *dG_dr_vec = buffer[9];
5205 REAL8 *dG_dprstar_vec = buffer[10];
5206 REAL8 *dG_dprstarbyprstar_vec = buffer[11];
5207 REAL8 *G0_vec = buffer[12];
5208 REAL8 *dG_dr0_vec = buffer[13];
5209 REAL8 *E_vec = buffer[14];
5210 REAL8 *Heff_vec = buffer[15];
5211 REAL8 *Heff_orb_vec = buffer[16];
5212 REAL8 *dpphi_dr_vec = buffer[17];
5213 REAL8 *dprstar_dr_vec = buffer[18];
5214 REAL8 *dphi_dr_vec = buffer[19];
5215 REAL8 *dt_dr_vec = buffer[20];
5216
5217 REAL8 ggm[14];
5218 REAL8 a_coeff, b_coeff, c_coeff, Delta, sol_p, sol_m, j02, uc, u2, prstar2, dHeff_dpphi, dHeff_dprstar, dHeff_dr, dHeff_dprstarbyprstar, d2Heff_dprstar20, H, G, pl_hold, x, jhat, psi, r_omg, v_phi, Fphi, dr_dtbyprstar, prstar4, Heff_orb_f, Heff_f, E_f;
5219
5220 /*
5221 * Compute circular dynamics
5222 */
5223
5224 for (int i = 0; i < size; i++)
5225 {
5226 /* Current radius */
5227 dyn->r = r0 - i*dr;
5228
5229 /* Computing metric functions and centrifugal radius */
5230 if(usespins)
5231 {
5232 eob_metric_s(dyn->r,dyn, &A_vec[i], &B_vec[i], &dA_vec[i], &pl_hold, &pl_hold);
5233 dyn->eob_dyn_s_get_rc(dyn->r, nu, a1, a2, aK2, C_Q1, C_Q2, C_Oct1,
5234 C_Oct2, C_Hex1, C_Hex2, usetidal, &rc_vec[i],
5235 &drc_dr_vec[i], &pl_hold);
5236 eob_dyn_s_GS(dyn->r, rc_vec[i], drc_dr_vec[i], aK2, 0.0, 0.0, nu, chi1, chi2, X1, X2, c3, ggm);
5237
5238 G = ggm[2] *S+ggm[3] *Sstar; // tildeG = GS*S+GSs*Ss
5239 dG_dr_vec[i] = ggm[6] *S+ggm[7] *Sstar;
5240 dG_dprstar_vec[i] = ggm[4] *S+ggm[5] *Sstar;
5241 dG_dprstarbyprstar_vec[i] = ggm[10]*S+ggm[11]*Sstar;
5242 }
5243 else
5244 {
5245 eob_metric(dyn->r ,dyn, &A_vec[i], &B_vec[i], &dA_vec[i], &pl_hold, &pl_hold);
5246
5247 rc_vec[i] = dyn->r; //Nonspinning case: rc = r
5248 drc_dr_vec[i] = 1;
5249
5250 G = 0.0;
5251 dG_dr_vec[i] = 0.0;
5252 dG_dprstar_vec[i] = 0.0;
5253 dG_dprstarbyprstar_vec[i] = 0.0;
5254 }
5255
5256 /* Defining circular quantities for the flux calculation.
5257 Must not be overwritten in successive iterations, thus
5258 we define separate quantities with the subscripts 0. */
5259 G0_vec[i] = G;
5260 dG_dr0_vec[i] = dG_dr_vec[i];
5261
5262 /* Auxiliary variables */
5263 sqrtAbyB_vec[i] = sqrt(A_vec[i]/B_vec[i]);
5264 uc = 1./rc_vec[i];
5265 uc2_vec[i] = uc*uc;
5266 duc_dr_vec[i] = -uc2_vec[i]*drc_dr_vec[i];
5267 dAuc2_dr_vec[i] = uc2_vec[i]*(dA_vec[i]-2*A_vec[i]*uc*drc_dr_vec[i]);
5268
5269 /* Computing the circular angular momentum by solving eq. (A15) of TEOBResumS paper
5270 (which is equivalent to solve eq.(4)=0 of arXiv:1805.03891).
5271 */
5272
5273 if (usespins) {
5274 a_coeff = SQ(dAuc2_dr_vec[i]) - 4*A_vec[i]*uc2_vec[i]*SQ(dG_dr_vec[i]); /* First coefficient of the quadratic equation a*x^2+b*x+c=0 */
5275 b_coeff = 2*dA_vec[i]*dAuc2_dr_vec[i] - 4*A_vec[i]*SQ(dG_dr_vec[i]); /* Second coefficient of the quadratic equation */
5276 c_coeff = SQ(dA_vec[i]); /* Third coefficient of the quadratic equation */
5277
5278 Delta = SQ(b_coeff) - 4*a_coeff*c_coeff ; /* Delta of the quadratic equation */
5279 if (Delta<0)
5280 /* If the spins are very small,
5281 numerical fluctuations sometimes make Delta negative (e.g. -1e-30).
5282 Setting it to 0 by hand */
5283 Delta=0.;
5284
5285 sol_p = (-b_coeff + sqrt(Delta))/(2*a_coeff); /* Plus solution of the quadratic equation */
5286 sol_m = (-b_coeff - sqrt(Delta))/(2*a_coeff); /* Minus solution of the quadratic equation */
5287
5288 /* dGdr sign determines choice of solution */
5289 if (dG_dr0_vec[i] > 0) j02 = sol_p;
5290 else j02 = sol_m;
5291
5292 }
5293 else
5294 {
5295
5296 a_coeff = dAuc2_dr_vec[i];
5297 b_coeff = dA_vec[i];
5298
5299 j02 = -b_coeff/a_coeff;
5300
5301 }
5302
5303 /* Define momenta in the circular orbit approximation */
5304 dyn->pphi = sqrt(j02);
5305 dyn->prstar = 0.0;
5306 dprstar_dr_vec[i] = 0.0;
5307
5308 /* Circular Hamiltonians, ref: arXiv: 1406.6913 */
5309 if(usespins) {
5310
5311 eob_ham_s(nu,dyn->r,rc_vec[i],drc_dr_vec[i],dyn->pphi,dyn->prstar,S,
5312 Sstar,chi1,chi2,X1,X2,aK2,c3,A_vec[i],dA_vec[i],
5313 &H, /* real EOB Hamiltonian divided by mu=m1m2/(m1+m2) */
5314 &Heff_vec[i], /* effective EOB Hamiltonian (divided by mu) */
5315 &Heff_orb_vec[i],
5316 &dHeff_dr, /* drvt Heff,r */
5317 NULL, /* drvt Heff,prstar */
5318 &dHeff_dpphi, /* drvt Heff,pphi */
5319 &d2Heff_dprstar20);
5320
5321 E_vec[i] = nu*H;
5322
5323 } else {
5324
5325 eob_ham(nu, dyn->r, dyn->pphi, dyn->prstar, A_vec[i], dA_vec[i],
5326 &H, /* real EOB Hamiltonian divided by mu=m1m2/(m1+m2) */
5327 &Heff_orb_vec[i], /* effective EOB Hamiltonian (divided by mu). */
5328 &dHeff_dr, /* drvt Heff,r */
5329 NULL, /* drvt Heff,prstar */
5330 &dHeff_dpphi); /* drvt Heff,pphi */
5331
5332 d2Heff_dprstar20 = 1/Heff_orb_vec[i];
5333
5334 Heff_vec[i] = Heff_orb_vec[i]; /* Heff coincides with Heff_orb for the non-spinning case */
5335 E_vec[i] = nu*H;
5336
5337 }
5338
5339 /* Circular orbital frequency */
5340 dyn->Omg = dHeff_dpphi/E_vec[i];
5341
5342 /* Circular real orbital frequency */
5343 dyn->Omg_orb = (dyn->pphi*A_vec[i]*uc2_vec[i])/(E_vec[i]*Heff_orb_vec[i]);
5344
5345 /* ddotr */
5346 dyn->ddotr = -A_vec[i]/B_vec[i]*dHeff_dr*d2Heff_dprstar20;
5347
5348 dyn->data[TEOB_RAD][i] = dyn->r;
5349 dyn->data[TEOB_PPHI][i] = dyn->pphi;
5351 dyn->data[TEOB_DDOTR][i] = dyn->ddotr;
5352 dyn->data[TEOB_MOMG][i] = dyn->Omg;
5354
5355 } // END r-GRID FOR
5356
5357 /* Computing angular momentum derivative */
5358 D0(dyn->data[TEOB_PPHI],-dr, size, dpphi_dr_vec); /* dJ0/dr */
5359
5360 /*
5361 * Post-Adiabatic dynamics
5362 */
5363
5364 int parity = 1; /* parity of the post-adiab iteration */
5365
5366 /* For on PA orders */
5367 for (int n = 1; n <= POSTADIABATIC_N; n++) {
5368
5369 /* Separating even and odd orders */
5370 if (n%2==0) parity = 0;
5371 else parity = 1;
5372
5373 /* For on r-grid */
5374 for (int i = 0; i < size; i++) {
5375
5376 /* Setting loop variables to help reader */
5377 dyn->r = dyn->data[TEOB_RAD][i];
5378 dyn->phi = dyn->data[TEOB_PHI][i];
5379 dyn->pphi = dyn->data[TEOB_PPHI][i];
5380 dyn->Omg = dyn->data[TEOB_MOMG][i];
5381 dyn->ddotr = dyn->data[TEOB_DDOTR][i];
5384
5385 if (parity) {
5386
5387 /* ***********************************
5388 * Odd PA orders : prstar corrections
5389 * ********************************** */
5390
5391 /* Calculating the flux Fphi */
5392 //FIXME USE C-routines, jhat etc. are already present inside dynamics
5393
5394 //FIXME Non-spinning routine gives 1e-2 difference between PA and full EOB waveform. Tested cases: bbh q 1 f 0.001 and q 5 f 0.006.
5395 if (usespins) {
5396
5397 /* Variables for which Kepler's law is still valid */
5398 Heff_orb_f = sqrt(A_vec[i]*(1.0 + SQ(dyn->pphi)*uc2_vec[i]));
5399 Heff_f = G0_vec[i]*dyn->pphi + Heff_orb_f;
5400 E_f = sqrt(1 + 2*nu*(Heff_f - 1));
5401 psi = (duc_dr_vec[i] + dG_dr0_vec[i]*rc_vec[i]*sqrt(A_vec[i]/(SQ(dyn->pphi)) + A_vec[i]*uc2_vec[i])/A_vec[i])/(-0.5*dA_vec[i]);
5402 r_omg = 1.0/cbrt(SQ(((1./sqrt(rc_vec[i]*rc_vec[i]*rc_vec[i]*psi))+G0_vec[i])/(E_f)));
5403 v_phi = r_omg*dyn->Omg;
5404 x = SQ(v_phi);
5405 jhat = dyn->pphi/(r_omg*v_phi);
5406
5407 Fphi = eob_flx_Flux_s(x,dyn->Omg,r_omg, E_vec[i], Heff_vec[i],jhat,dyn->r,dyn->prstar, dyn->ddotr, dyn);
5408
5409 } else {
5410
5411 Heff_orb_f = sqrt(A_vec[i]*(1.0 + SQ(dyn->pphi)*uc2_vec[i]));
5412 Heff_f = Heff_orb_f;
5413 psi = 2.*(1.0 + 2.0*nu*(Heff_orb_f - 1.0))/(SQ(dyn->r)*dA_vec[i]);
5414 r_omg = dyn->r*cbrt(psi);
5415 v_phi = r_omg*dyn->Omg;
5416 x = SQ(v_phi);
5417 jhat = dyn->pphi/(r_omg*v_phi);
5418
5419 Fphi = eob_flx_Flux(x,dyn->Omg,r_omg, E_vec[i], Heff_vec[i],jhat,dyn->r,dyn->prstar, dyn->ddotr, dyn);
5420
5421 }
5422
5423 /* Calculating prstar */
5424 dHeff_dprstarbyprstar = dyn->pphi*dG_dprstarbyprstar_vec[i] + (1+2*z3*A_vec[i]*uc2_vec[i]*SQ(dyn->prstar))/Heff_orb_vec[i];
5425 dr_dtbyprstar = sqrtAbyB_vec[i]/(E_vec[i])*dHeff_dprstarbyprstar;
5426 dyn->prstar = Fphi/dpphi_dr_vec[i]/dr_dtbyprstar;
5427
5428 /* Note: p_phi does not change at odd orders
5429 Computing first PA using the approximation detailed above A19 of TEOBResumS paper and Hamilton's equations.
5430 */
5431
5432 /* New GGM functions */
5433 eob_dyn_s_GS(dyn->r, rc_vec[i], drc_dr_vec[i], aK2, dyn->prstar, 0.0, nu, chi1, chi2, X1, X2, c3, ggm);
5434
5435 dG_dr_vec[i] = ggm[6] *S+ggm[7] *Sstar;
5436 dG_dprstar_vec[i] = ggm[4] *S+ggm[5] *Sstar;
5437 dG_dprstarbyprstar_vec[i] = ggm[10]*S+ggm[11]*Sstar;
5438
5439 } else {
5440
5441 /* ***********************************
5442 * Even PA orders : pphi corrections
5443 * ********************************** */
5444
5445 prstar4 = SQ(SQ(dyn->prstar));
5446 a_coeff = dAuc2_dr_vec[i]; /* coefficients of the quadratic equation a*x^2+b*x+c=0 */
5447 b_coeff = 2*Heff_orb_vec[i]*(dG_dr_vec[i] + dG_dprstar_vec[i]*dprstar_dr_vec[i]);
5448 c_coeff = dA_vec[i] + 2*dyn->prstar*dprstar_dr_vec[i]*(1+2*z3*A_vec[i]*uc2_vec[i]*SQ(dyn->prstar)) + z3*dAuc2_dr_vec[i]*prstar4;
5449 Delta = SQ(b_coeff) - 4*a_coeff*c_coeff; /* Delta of the quadratic equation */
5450
5451 /* sol_p = (-b_coeff + sqrt(Delta))/(2*a_coeff); */ /* Plus solution - Unphysical */
5452 sol_m = (-b_coeff - sqrt(Delta))/(2*a_coeff); /* Minus solution of the quadratic equation */
5453 dyn->pphi = sol_m;
5454
5455 /* Note: prstar and G functions do not change at even orders
5456 G does not change because of the chosen gauge,
5457 which eliminates the dependence of G from pphi).
5458 */
5459
5460 } //END IF-ELSE parity
5461
5462 /* New Hamiltonians */
5463 if(usespins) {
5464
5465 eob_ham_s(nu, dyn->r, rc_vec[i], drc_dr_vec[i], dyn->pphi, dyn->prstar, S, Sstar, chi1, chi2, X1, X2, aK2, c3, A_vec[i], dA_vec[i],
5466 &H, /* real EOB Hamiltonian divided by mu=m1m2/(m1+m2) */
5467 &Heff_vec[i], /* effective EOB Hamiltonian (divided by mu). Heff coincides with Heff_orb for the non-spinning case */
5468 &Heff_orb_vec[i],
5469 &dHeff_dr, /* drvt Heff,r */
5470 &dHeff_dprstar, /* drvt Heff,prstar */
5471 &dHeff_dpphi, /* drvt Heff,pphi */
5472 &d2Heff_dprstar20);
5473
5474 E_vec[i] = nu*H;
5475
5476 } else {
5477
5478 eob_ham(nu, dyn->r, dyn->pphi, dyn->prstar, A_vec[i], dA_vec[i],
5479 &H, /* real EOB Hamiltonian divided by mu=m1m2/(m1+m2) */
5480 &Heff_orb_vec[i], /* effective EOB Hamiltonian (divided by mu). Heff coincides with Heff_orb for the non-spinning case */
5481 &dHeff_dr, /* drvt Heff,r */
5482 &dHeff_dprstar, /* drvt Heff,prstar */
5483 &dHeff_dpphi); /* drvt Heff,pphi */
5484
5485 u2 = 1./((dyn->r)*(dyn->r));
5486 prstar2 = (dyn->prstar)*(dyn->prstar);
5487 d2Heff_dprstar20 = (1. + 2.*A_vec[i]*u2*z3*prstar2)/Heff_orb_vec[i];
5488
5489 Heff_vec[i] = Heff_orb_vec[i]; /* Heff coincides with Heff_orb for the non-spinning case */
5490 E_vec[i] = nu*H;
5491
5492 }
5493
5494 /* Orbital Frequency */
5495 dyn->Omg = dHeff_dpphi/E_vec[i];
5496
5497 /* Real Orbital Frequency */
5498 dyn->Omg_orb = (dyn->pphi*A_vec[i]*uc2_vec[i])/(E_vec[i]*Heff_orb_vec[i]);
5499
5500 /* ddotr */
5501 dyn->ddotr = -A_vec[i]/B_vec[i]*dHeff_dr*d2Heff_dprstar20;
5502
5503 /* Time and phase radial derivatives */
5504 dt_dr_vec[i] = E_vec[i]/(sqrtAbyB_vec[i]*dHeff_dprstar); /* dt_dr = 1/dr_dt */
5505 dphi_dr_vec[i] = dyn->Omg*dt_dr_vec[i]; /* d(phi)_dr = d(phi)_dt*dt_dr */
5506
5507 /* Re-assigning quantities to array elements */
5508 dyn->data[TEOB_PHI][i] = dyn->phi;
5509 dyn->data[TEOB_PPHI][i] = dyn->pphi;
5510 dyn->data[TEOB_MOMG][i] = dyn->Omg;
5511 dyn->data[TEOB_DDOTR][i] = dyn->ddotr;
5514
5515 } // END R-GRID FOR
5516
5517 /* Computing derivatives of the momenta */
5518 if (parity) D0(dyn->data[TEOB_PRSTAR],-dr, size, dprstar_dr_vec);
5519 else D0(dyn->data[TEOB_PPHI],-dr, size, dpphi_dr_vec);
5520
5521 } // END PA-CORRECTIONS FOR
5522
5523 /*
5524 * Computing integrals for time and phase
5525 */
5526
5527 /* Compute time */
5528 cumint3(dt_dr_vec, dyn->data[TEOB_RAD], size, dyn->time);
5529
5530 /* Set last value for evolution */
5531 dyn->t = dyn->time[size-1];
5532
5533 /* Compute orbital phase */
5534 cumint3(dphi_dr_vec, dyn->data[TEOB_RAD], size, dyn->data[TEOB_PHI]);
5535
5536
5537 /* Free memory */
5538 for (int v=0; v < TEOB_NV; v++)
5539 LALFree(buffer[v]);
5540
5541 /*
5542 XLALFree(A_vec);
5543 XLALFree(dA_vec);
5544 XLALFree(B_vec);
5545 XLALFree(sqrtAbyB_vec);
5546 XLALFree(rc_vec);
5547 XLALFree(drc_dr_vec);
5548 XLALFree(uc2_vec);
5549 XLALFree(duc_dr_vec);
5550 XLALFree(dAuc2_dr_vec);
5551 XLALFree(dG_dr_vec);
5552 XLALFree(dG_dprstar_vec);
5553 XLALFree(dG_dprstarbyprstar_vec);
5554 XLALFree(G0_vec);
5555 XLALFree(dG_dr0_vec);
5556 XLALFree(E_vec);
5557 XLALFree(Heff_vec);
5558 XLALFree(Heff_orb_vec);
5559 XLALFree(dpphi_dr_vec);
5560 XLALFree(dprstar_dr_vec);
5561 XLALFree(dphi_dr_vec);
5562 XLALFree(dt_dr_vec);
5563 */
5564
5565 return XLAL_SUCCESS;
5566}
double cosh(double)
#define LALFree(p)
static const REAL8 k33
static const REAL8 k22
static const REAL8 k21
const double b1
const double c1
const double b2
const double c2
const double c0
#define MIN(a, b)
#define DEBUG
const INT4 TEOB_MINDEX[KMAX]
const INT4 TEOB_LINDEX[KMAX]
GSL routines for ODE integration https://www.gnu.org/software/gsl/doc/html/ode-initval....
void eob_dyn_s_GS(REAL8 r, REAL8 rc, REAL8 drc_dr, REAL8 UNUSED aK2, REAL8 prstar, REAL8 UNUSED pph, REAL8 nu, REAL8 UNUSED chi1, REAL8 UNUSED chi2, REAL8 UNUSED X1, REAL8 UNUSED X2, REAL8 cN3LO, REAL8 *ggm)
#define TEOB_IC_N
void eob_wav_hlm(LALTEOBResumSDynamics *dyn, LALTEOBResumSWaveformModeSingleTime *hlm)
void eob_wav_hlmNQC(REAL8 UNUSED nu, REAL8 r, REAL8 prstar, REAL8 Omega, REAL8 ddotr, NQCcoefs *nqc, LALTEOBResumSWaveformModeSingleTime *hlmnqc)
void eob_ham(REAL8 nu, REAL8 r, REAL8 pphi, REAL8 prstar, REAL8 A, REAL8 dA, REAL8 *H, REAL8 *Heff, REAL8 *dHeff_dr, REAL8 *dHeff_dprstar, REAL8 *dHeff_dpphi)
void eob_nqc_setcoefs(LALTEOBResumSDynamics *dyn)
int eob_dyn_Npostadiabatic(LALTEOBResumSDynamics *dyn, const REAL8 r0)
static const REAL8 ChlmNewt_phase[35]
REAL8 eob_flx_Flux_s(REAL8 x, REAL8 Omega, REAL8 r_omega, REAL8 E, REAL8 Heff, REAL8 jhat, REAL8 r, REAL8 pr_star, REAL8 ddotr, LALTEOBResumSDynamics *dyn)
static const REAL8 f14[]
void eob_metric(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *A, REAL8 *B, REAL8 *dA, REAL8 *d2A, REAL8 *dB)
void eob_flx_Tlm(const REAL8 w, REAL8 *MTlm)
REAL8 eob_dyn_bisecOmegaorb0(LALTEOBResumSDynamics *dyn, REAL8 omg_orb0, REAL8 r0_kepl)
void eob_dyn_ic_s(REAL8 r0, LALTEOBResumSDynamics *dyn, REAL8 y_init[])
void eob_wav_flm(REAL8 x, REAL8 nu, REAL8 clm[KMAX][6], REAL8 *rholm, REAL8 *flm)
int eob_dyn_rhs(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
void eob_dyn_s_get_rc_NNLO(REAL8 r, REAL8 nu, REAL8 at1, REAL8 at2, REAL8 aK2, REAL8 C_Q1, REAL8 C_Q2, REAL8 UNUSED C_Oct1, REAL8 UNUSED C_Oct2, REAL8 UNUSED C_Hex1, REAL8 UNUSED C_Hex2, int usetidal, REAL8 *rc, REAL8 *drc_dr, REAL8 *d2rc_dr2)
static const double CNlm[35]
void eob_wav_flm_s_SSNLO(REAL8 x, REAL8 nu, REAL8 X1, REAL8 X2, REAL8 UNUSED chi1, REAL8 UNUSED chi2, REAL8 a1, REAL8 a2, REAL8 C_Q1, REAL8 C_Q2, REAL8 clm[KMAX][6], int usetidal, REAL8 *rholm, REAL8 *flm)
void eob_wav_deltalm(REAL8 Hreal, REAL8 Omega, REAL8 nu, REAL8 *dlm)
int eob_dyn_adiabLR(LALTEOBResumSDynamics *dyn, REAL8 *rLR, INT4 tidesFlag)
void eob_ham_s(REAL8 nu, REAL8 r, REAL8 rc, REAL8 drc_dr, REAL8 pphi, REAL8 prstar, REAL8 S, REAL8 Sstar, REAL8 chi1, REAL8 chi2, REAL8 X1, REAL8 X2, REAL8 aK2, REAL8 c3, REAL8 A, REAL8 dA, REAL8 *H, REAL8 *Heff, REAL8 *Heff_orb, REAL8 *dHeff_dr, REAL8 *dHeff_dprstar, REAL8 *dHeff_dpphi, REAL8 *d2Heff_dprstar20)
void eob_wav_ringdown_template(REAL8 x, REAL8 a1, REAL8 a2, REAL8 a3, REAL8 a4, REAL8 b1, REAL8 b2, REAL8 b3, REAL8 b4, REAL8 sigmar, REAL8 sigmai, REAL8 *psi)
void eob_wav_speedyTail(REAL8 Omega, REAL8 Hreal, REAL8 bphys, LALTEOBResumSWaveformModeSingleTime *tlm)
void eob_dyn_s_get_rc_LO(REAL8 r, REAL8 nu, REAL8 at1, REAL8 at2, REAL8 aK2, REAL8 C_Q1, REAL8 C_Q2, REAL8 UNUSED C_Oct1, REAL8 UNUSED C_Oct2, REAL8 UNUSED C_Hex1, REAL8 UNUSED C_Hex2, int usetidal, REAL8 *rc, REAL8 *drc_dr, REAL8 *d2rc_dr2)
REAL8 eob_flx_Flux(REAL8 x, REAL8 Omega, REAL8 r_omega, REAL8 E, REAL8 Heff, REAL8 jhat, REAL8 r, REAL8 pr_star, REAL8 ddotr, LALTEOBResumSDynamics *dyn)
void eob_flx_FlmNewt(REAL8 x, REAL8 nu, REAL8 *Nlm)
void eob_metric_Atidal(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *AT, REAL8 *dAT, REAL8 *d2AT)
REAL8 eob_flx_HorizonFlux_s(REAL8 x, REAL8 UNUSED Heff, REAL8 UNUSED jhat, REAL8 UNUSED nu, REAL8 X1, REAL8 X2, REAL8 chi1, REAL8 chi2)
void eob_wav_hlmNewt(REAL8 r, REAL8 Omega, REAL8 phi, REAL8 nu, LALTEOBResumSWaveformModeSingleTime *hlmNewt)
void eob_dyn_s_get_rc_NLO(REAL8 r, REAL8 nu, REAL8 at1, REAL8 at2, REAL8 aK2, REAL8 C_Q1, REAL8 C_Q2, REAL8 UNUSED C_Oct1, REAL8 UNUSED C_Oct2, REAL8 UNUSED C_Hex1, REAL8 UNUSED C_Hex2, int usetidal, REAL8 *rc, REAL8 *drc_dr, REAL8 *d2rc_dr2)
void QNMHybridFitCab(REAL8 nu, REAL8 X1, REAL8 X2, REAL8 chi1, REAL8 chi2, REAL8 aK, REAL8 Mbh, REAL8 abh, REAL8 *a1, REAL8 *a2, REAL8 *a3, REAL8 *a4, REAL8 *b1, REAL8 *b2, REAL8 *b3, REAL8 *b4, REAL8 *sigmar, REAL8 *sigmai, int usespins)
void eob_wav_hlmNQC_nospin201602(REAL8 nu, REAL8 r, REAL8 prstar, REAL8 Omega, REAL8 ddotr, LALTEOBResumSWaveformModeSingleTime *hlmnqc)
void eob_wav_flm_coeffs(REAL8 nu, REAL8 clm[KMAX][6])
void eob_wav_hlmNQC_find_a1a2a3_mrg(LALTEOBResumSDynamics *dyn_mrg, SphHarmPolarTimeSeries *hlm_mrg, SphHarmPolarTimeSeries *hnqc, LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *hlm)
REAL8 eob_dyn_bisecHeff0_s(REAL8 nu, REAL8 chi1, REAL8 chi2, REAL8 X1, REAL8 X2, REAL8 c3, REAL8 pph, REAL8 rorb, REAL8 A, REAL8 dA, REAL8 rc, REAL8 drc_dr, REAL8 ak2, REAL8 S, REAL8 Ss)
void eob_metric_s(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *A, REAL8 *B, REAL8 *dA, REAL8 *d2A, REAL8 *dB)
REAL8 eob_dyn_r0_eob(REAL8 f0, LALTEOBResumSDynamics *dyn)
void eob_wav_flm_s_SSLO(REAL8 x, REAL8 nu, REAL8 X1, REAL8 X2, REAL8 UNUSED chi1, REAL8 UNUSED chi2, REAL8 a1, REAL8 a2, REAL8 C_Q1, REAL8 C_Q2, REAL8 clm[KMAX][6], int usetidal, REAL8 *rholm, REAL8 *flm)
void eob_dyn_s_get_rc_NOTIDES(REAL8 r, REAL8 nu, REAL8 at1, REAL8 at2, REAL8 aK2, REAL8 UNUSED C_Q1, REAL8 UNUSED C_Q2, REAL8 UNUSED C_Oct1, REAL8 UNUSED C_Oct2, REAL8 UNUSED C_Hex1, REAL8 UNUSED C_Hex2, int usetidal, REAL8 *rc, REAL8 *drc_dr, REAL8 *d2rc_dr2)
void eob_dyn_s_get_rc_NOSPIN(REAL8 r, REAL8 UNUSED nu, REAL8 UNUSED at1, REAL8 UNUSED at2, REAL8 UNUSED aK2, REAL8 UNUSED C_Q1, REAL8 UNUSED C_Q2, REAL8 UNUSED C_Oct1, REAL8 UNUSED C_Oct2, REAL8 UNUSED C_Hex1, REAL8 UNUSED C_Hex2, int UNUSED usetidal, REAL8 UNUSED *rc, REAL8 UNUSED *drc_dr, REAL8 UNUSED *d2rc_dr2)
void eob_nqc_setcoefs_nospin201602(REAL8 nu, NQCcoefs *nqc)
void eob_wav_ringdown(LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *hlm)
#define RTAIL
REAL8 eob_nqc_timeshift(REAL8 nu, REAL8 chi1)
void eob_wav_hhatlmTail(REAL8 Omega, REAL8 Hreal, REAL8 bphys, LALTEOBResumSWaveformModeSingleTime *tlm)
REAL8 eob_flx_HorizonFlux(REAL8 x, REAL8 Heff, REAL8 jhat, REAL8 nu)
void eob_metric_A5PNlog(REAL8 r, REAL8 nu, REAL8 *A, REAL8 *dA, REAL8 *d2A)
REAL8 eob_c3_fit_global(REAL8 nu, REAL8 UNUSED chi1, REAL8 UNUSED chi2, REAL8 UNUSED X1, REAL8 UNUSED X2, REAL8 a1, REAL8 a2)
void eob_wav_hlmNQC_find_a1a2a3(LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *h, SphHarmPolarTimeSeries *hnqc)
static const REAL8 ChlmNewt_ampli[35]
void eob_dyn_s_get_rc_NNLO_S4(REAL8 r, REAL8 nu, REAL8 at1, REAL8 at2, REAL8 aK2, REAL8 C_Q1, REAL8 C_Q2, REAL8 C_Oct1, REAL8 C_Oct2, REAL8 C_Hex1, REAL8 C_Hex2, int usetidal, REAL8 *rc, REAL8 *drc_dr, REAL8 *d2rc_dr2)
int eob_dyn_rhs_s(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
REAL8 eob_dyn_Omegaorb0(REAL8 r, void *params)
#define TEOB_IC_S_N
REAL8 eob_dyn_r0_Kepler(REAL8 f0)
REAL8 eob_dyn_fLR(REAL8 r, void *params)
void eob_wav_hlmTidal(REAL8 x, LALTEOBResumSDynamics *dyn, REAL8 *hTidallm)
REAL8 eob_dyn_DHeff0(REAL8 x, void *params)
void eob_dyn_ic(REAL8 r0, LALTEOBResumSDynamics *dyn, REAL8 y_init[])
REAL8 cumint3(REAL8 *f, REAL8 *x, const INT4 n, REAL8 *sum)
INT4 D0(REAL8 *f, REAL8 dx, INT4 n, REAL8 *df)
XLALWignerdMatrix, XLALWignerDMatrix in <lal/SphericalHarmonics.h>
REAL8 Eulerlog(const REAL8 x, const INT4 m)
INT4 D2(REAL8 *f, REAL8 dx, INT4 n, REAL8 *d2f)
REAL8 find_max(const INT4 n, REAL8 dx, REAL8 x0, REAL8 *f, REAL8 *fmax)
static double sigma(const double a, const double b, const sysq *system)
Internal function that computes the spin-spin couplings.
static vector d(const double L_norm, const double J_norm, const vector roots)
Internal function that returns the coefficients "d_0", "d_2" and "d_4" from 1703.03967 corresponding ...
#define c
#define G
static REAL8 UNUSED C2(REAL8 e0, REAL8 f0)
static REAL8 UNUSED C1(REAL8 Mtotal)
static REAL8 UNUSED C4(REAL8 e0, REAL8 f0)
static REAL8 UNUSED C5(REAL8 e0, REAL8 f0)
static REAL8 UNUSED C3(REAL8 e0, REAL8 f0)
static REAL8 UNUSED C0(REAL8 eta)
static REAL8 UNUSED z3(REAL8 e0, REAL8 f0, REAL8 inc, REAL8 bet, REAL8 FPlus, REAL8 FCross)
static REAL8 UNUSED C6(REAL8 eta)
This file is part of TEOBResumS.
#define Log2
#define TOLERANCE
#define DEQUAL(a, b, eps)
#define POSTADIABATIC_DR
#define KMAX
@ TEOB_EVOLVE_RAD
@ TEOB_EVOLVE_PHI
@ TEOB_EVOLVE_PPHI
@ TEOB_EVOLVE_PRSTAR
#define PMTERMS_eps
#define POSTADIABATIC_N
@ NQC_NR_NOSPIN
@ NQC_OFF
@ NQC_COMPUTE
@ TEOB_ID_PRSTAR
@ TEOB_ID_PR
@ TEOB_ID_E0
@ TEOB_ID_PHI
@ TEOB_ID_RAD
@ TEOB_ID_PPHI
@ TEOB_ID_OMGJ
@ TEOB_ID_J
#define MAX_ITER
#define SQ(a)
@ TEOB_PRSTAR
@ TEOB_OMGORB
@ TEOB_DDOTR
@ TEOB_RAD
@ TEOB_MOMG
@ TEOB_PHI
@ TEOB_PPHI
REAL8 Hreal
int s
Definition: bh_qnmode.c:137
int l
Definition: bh_qnmode.c:135
REAL8 M
Definition: bh_qnmode.c:133
double dt
Definition: bh_ringdown.c:113
double i
Definition: bh_ringdown.c:118
double e
Definition: bh_ringdown.c:117
const double H
const double pr
const double u
const double w2
const double a4
const double logu
const double u3
const double r2
const double u5
const double a2
const double w
const double u2
const double u4
const double B
#define LAL_PI
#define LAL_GAMMA
double REAL8
uint32_t UINT4
int32_t INT4
void XLALFree(void *p)
@ LAL_SIM_INSPIRAL_GETIDES_GSF23
@ LAL_SIM_INSPIRAL_GETIDES_NNLO
@ LAL_SIM_INSPIRAL_GETIDES_GSF2
@ LAL_SIM_INSPIRAL_GMTIDES_GSF
@ LAL_SIM_INSPIRAL_GMTIDES_PN
static const INT4 r
static const INT4 a
#define XLAL_ERROR_VOID(...)
#define XLAL_ERROR_REAL8(...)
#define XLAL_CHECK_VOID(assertion,...)
XLAL_EBADLEN
XLAL_SUCCESS
XLAL_EFAULT
XLAL_EFUNC
XLAL_EMAXITER
XLAL_EINVAL
list y
string status
p
x
Dynamics data type.
EOBDynSGetRCFunc eob_dyn_s_get_rc
EOBWavFlmSFunc eob_wav_flm_s
REAL8 * data[TEOB_DYNAMICS_NVARS]
Multipolar waveform at given time, comes at handy.
Multipolar coefficients for NQC waveform.
double b1[KMAX]
double a3[KMAX]
double n[KMAX][6]
int activemode[KMAX]
double a2[KMAX]
double b3[KMAX]
double a1[KMAX]
double b2[KMAX]
NQC data for flux and waveform.
NQCcoefs * hlm
NQCcoefs * flx
REAL8Sequence * data
REAL8 * data
REAL8TimeSeries * ampl
The sequences of mode amplitude.
REAL8TimeSeries * phase
The sequences of mode phase (not modulo 2Pi).
struct tagSphHarmPolarTimeSeries * next
next pointer
REAL8Sequence * tdata
Timestamp values.
Definition: burst.c:245