LALSimulation  5.4.0.1-fe68b98
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 */
44 static 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 */
48 static 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 */
52 static 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 */
63 void 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 */
90 void eob_ham_s(REAL8 nu,
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 */
152 struct DHeff0_tmp_params
153 {
154  REAL8 rorb, A, dA, rc, drc_dr, ak2, S, Ss, nu, chi1, chi2, X1, X2, c3;
155 };
156 
157 
158 REAL8 eob_dyn_DHeff0(REAL8 x, void *params)
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 */
197 REAL8 eob_dyn_bisecHeff0_s(REAL8 nu,
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,
208  REAL8 drc_dr,
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;
223  struct DHeff0_tmp_params p = {rorb,A,dA,rc,drc_dr,ak2,S,Ss,nu,chi1,chi2,X1,X2,c3};
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 */
246 REAL8 eob_dyn_r0_Kepler (REAL8 f0)
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 */
253 REAL8 eob_dyn_r0_eob (REAL8 f0, LALTEOBResumSDynamics *dyn)
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 */
261 struct Omegaorb0_tmp_params {
262  REAL8 omg_orb0;
263  LALTEOBResumSDynamics *dyn;
264 };
265 
266 REAL8 eob_dyn_Omegaorb0(REAL8 r, void *params)
267 {
268 
269  /* Unpack parameters */
270  struct Omegaorb0_tmp_params *p = (struct Omegaorb0_tmp_params *) params;
271  REAL8 omg_orb0 = p->omg_orb0;
272  LALTEOBResumSDynamics *dyn = p->dyn;
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 */
367 REAL8 eob_dyn_bisecOmegaorb0(LALTEOBResumSDynamics *dyn, REAL8 omg_orb0, REAL8 r0_kepl)
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 
377  struct Omegaorb0_tmp_params p = {omg_orb0,dyn};
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  */
411 void eob_dyn_ic(REAL8 r0, LALTEOBResumSDynamics *dyn, REAL8 y_init[])
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 */
484 void eob_dyn_ic_s(REAL8 r0, LALTEOBResumSDynamics *dyn, REAL8 y_init[])
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 */
662 int eob_dyn_rhs(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
663 {
664 
665  (void)(t); /* avoid unused parameter warning */
666  LALTEOBResumSDynamics *dyn = d;
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;
732  dyn->phi = y[TEOB_EVOLVE_PHI];
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 */
758 int eob_dyn_rhs_s(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
759 {
760 
761  (void)(t); /* avoid unused parameter warning */
762  LALTEOBResumSDynamics *dyn = d;
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;
858  dyn->phi = y[TEOB_EVOLVE_PHI];
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 
890 void eob_dyn_s_GS(REAL8 r,
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  */
1018 void eob_dyn_s_get_rc_LO(REAL8 r,
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 */
1088 void eob_dyn_s_get_rc_NLO(REAL8 r,
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 */
1142 void eob_dyn_s_get_rc_NNLO(REAL8 r,
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 */
1217 void eob_dyn_s_get_rc_NNLO_S4(REAL8 r,
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 */
1298 void eob_dyn_s_get_rc_NOSPIN(REAL8 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*/
1320 void eob_dyn_s_get_rc_NOTIDES(REAL8 r,
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. */
1380 void eob_metric_A5PNlog(REAL8 r, REAL8 nu, REAL8 *A, REAL8 *dA, REAL8 *d2A)
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 */
1471 void eob_metric_Atidal(REAL8 r,
1472  LALTEOBResumSDynamics *dyn,
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 
1527  if (dyn->use_tidal==LAL_SIM_INSPIRAL_GETIDES_NNLO) {
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 
1540  } else if (dyn->use_tidal==LAL_SIM_INSPIRAL_GETIDES_GSF2) {
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  }
1593  } else if (dyn->use_tidal==LAL_SIM_INSPIRAL_GETIDES_GSF23) {
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 
1688  if (dyn->use_tidal_gravitomagnetic==LAL_SIM_INSPIRAL_GMTIDES_PN) {
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 
1698  } else if (dyn->use_tidal_gravitomagnetic==LAL_SIM_INSPIRAL_GMTIDES_GSF) {
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 */
1752 void eob_metric(REAL8 r,
1753  LALTEOBResumSDynamics *dyn,
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 */
1811 void eob_metric_s(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *A, REAL8 *B, REAL8 *dA, REAL8 *d2A, REAL8 *dB)
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 */
1878 void eob_flx_FlmNewt(REAL8 x, REAL8 nu, REAL8 *Nlm)
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 */
1920 static 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) */
1929 void 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  */
1952 REAL8 eob_flx_HorizonFlux(REAL8 x, REAL8 Heff, REAL8 jhat, REAL8 nu)
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. */
2009 REAL8 eob_flx_HorizonFlux_s(REAL8 x,
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!
2049 REAL8 eob_flx_Flux_s(REAL8 x,
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,
2058  LALTEOBResumSDynamics *dyn)
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  {
2131  LALTEOBResumSWaveformModeSingleTime hNQC;
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. */
2191 REAL8 eob_flx_Flux(REAL8 x,
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,
2200  LALTEOBResumSDynamics *dyn)
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 */
2207 void eob_wav_speedyTail(REAL8 Omega, REAL8 Hreal, REAL8 bphys, LALTEOBResumSWaveformModeSingleTime *tlm)
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) */
2263 void eob_wav_hhatlmTail(REAL8 Omega, REAL8 Hreal, REAL8 bphys, LALTEOBResumSWaveformModeSingleTime *tlm)
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 */
2312 void eob_wav_flm_s_SSLO(REAL8 x,
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. */
2431 void eob_wav_flm_s_SSNLO(REAL8 x,
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  */
2584 void eob_wav_flm_coeffs(REAL8 nu, REAL8 clm[KMAX][6])
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  */
2784 void 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)
2908 void eob_wav_deltalm(REAL8 Hreal, REAL8 Omega, REAL8 nu, REAL8 *dlm)
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) */
2971 void eob_wav_hlmNewt(REAL8 r,
2972  REAL8 Omega,
2973  REAL8 phi,
2974  REAL8 nu,
2975  LALTEOBResumSWaveformModeSingleTime *hlmNewt)
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 */
3047 void eob_wav_hlmTidal(REAL8 x, LALTEOBResumSDynamics *dyn, REAL8 *hTidallm)
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 
3108  if ( (dyn->use_tidal_gravitomagnetic==LAL_SIM_INSPIRAL_GMTIDES_GSF) || (dyn->use_tidal_gravitomagnetic==LAL_SIM_INSPIRAL_GMTIDES_PN) ) {
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 */
3123 void eob_wav_hlmNQC_nospin201602(REAL8 nu,
3124  REAL8 r,
3125  REAL8 prstar,
3126  REAL8 Omega,
3127  REAL8 ddotr,
3128  LALTEOBResumSWaveformModeSingleTime *hlmnqc)
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 */
3233 void eob_wav_hlmNQC(REAL8 UNUSED nu, REAL8 r, REAL8 prstar, REAL8 Omega, REAL8 ddotr, NQCcoefs *nqc,
3234  LALTEOBResumSWaveformModeSingleTime *hlmnqc)
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 */
3286 void eob_wav_hlmNQC_find_a1a2a3(LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *h, SphHarmPolarTimeSeries *hnqc)
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];
3363  SphHarmPolarTimeSeries *this;
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 */
3736 void eob_wav_hlmNQC_find_a1a2a3_mrg(LALTEOBResumSDynamics *dyn_mrg, SphHarmPolarTimeSeries *hlm_mrg, SphHarmPolarTimeSeries *hnqc, LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *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];
3812  SphHarmPolarTimeSeries *this;
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 */
4248 void eob_wav_hlm(LALTEOBResumSDynamics *dyn, LALTEOBResumSWaveformModeSingleTime *hlm)
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 */
4291  LALTEOBResumSWaveformModeSingleTime hNewt;
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;
4344  LALTEOBResumSWaveformModeSingleTime tlm;
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) &&
4363  !(dyn->nqc_coeffs_hlm == NQC_COMPUTE))
4364  {
4365  LALTEOBResumSWaveformModeSingleTime hNQC;
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*/
4406 REAL8 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 */
4433 REAL8 eob_nqc_timeshift(REAL8 nu, REAL8 chi1)
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 */
4461 void eob_nqc_setcoefs(LALTEOBResumSDynamics *dyn)
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"))
4510  if (dyn->nqc_coeffs_flx == NQC_NR_NOSPIN)
4511  eob_nqc_setcoefs_nospin201602(nu, nqc->flx);
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"))
4517  if (dyn->nqc_coeffs_hlm == NQC_NR_NOSPIN)
4518  eob_nqc_setcoefs_nospin201602(nu, nqc->hlm);
4519 
4520 }
4521 
4522 /* Set NQC coefficients
4523  NR fits for nonspinning case 2016/02/09
4524  Hardcoded in eob_wav_hlmNQC_nospin201602() */
4525 void eob_nqc_setcoefs_nospin201602(REAL8 nu, NQCcoefs *nqc)
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 */
4573 void QNMHybridFitCab(REAL8 nu,
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 */
4784 void eob_wav_ringdown_template(REAL8 x,
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 */
4805 void eob_wav_ringdown(LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *hlm)
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
4992 REAL8 eob_dyn_fLR(REAL8 r, void *params)
4993 {
4994  LALTEOBResumSDynamics *dyn = params;
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 */
5005 int eob_dyn_adiabLR(LALTEOBResumSDynamics *dyn, REAL8 *rLR, INT4 tidesFlag)
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) {
5019  case LAL_SIM_INSPIRAL_GETIDES_NNLO:
5020  case LAL_SIM_INSPIRAL_GETIDES_GSF2:
5021  case LAL_SIM_INSPIRAL_GETIDES_GSF23:
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 */
5159 int eob_dyn_Npostadiabatic(LALTEOBResumSDynamics *dyn, const REAL8 r0)
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;
5350  dyn->data[TEOB_PRSTAR][i] = dyn->prstar;
5351  dyn->data[TEOB_DDOTR][i] = dyn->ddotr;
5352  dyn->data[TEOB_MOMG][i] = dyn->Omg;
5353  dyn->data[TEOB_OMGORB][i] = dyn->Omg_orb;
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];
5382  dyn->prstar = dyn->data[TEOB_PRSTAR][i];
5383  dyn->Omg_orb = dyn->data[TEOB_OMGORB][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;
5512  dyn->data[TEOB_PRSTAR][i] = dyn->prstar;
5513  dyn->data[TEOB_OMGORB][i] = dyn->Omg_orb;
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 }
cosh
double cosh(double)
LALFree
#define LALFree(p)
k33
static const REAL8 k33
Definition: LALSimBlackHoleRingdown.h:110
k22
static const REAL8 k22
Definition: LALSimBlackHoleRingdown.h:104
k21
static const REAL8 k21
Definition: LALSimBlackHoleRingdown.h:103
b1
const double b1
Definition: LALSimIMRLackeyTidal2013.c:48
c1
const double c1
Definition: LALSimIMRLackeyTidal2013.c:51
b2
const double b2
Definition: LALSimIMRLackeyTidal2013.c:49
c2
const double c2
Definition: LALSimIMRLackeyTidal2013.c:52
c0
const double c0
Definition: LALSimIMRLackeyTidal2013.c:50
MIN
#define MIN(a, b)
Definition: LALSimIMRPhenomTPHM_EulerAngles.c:51
DEBUG
#define DEBUG
Definition: LALSimIMRPhenomX.c:47
TEOB_MINDEX
const INT4 TEOB_MINDEX[KMAX]
Definition: LALSimIMRTEOBResumS.c:68
TEOB_LINDEX
const INT4 TEOB_LINDEX[KMAX]
GSL routines for ODE integration https://www.gnu.org/software/gsl/doc/html/ode-initval....
Definition: LALSimIMRTEOBResumS.c:59
eob_dyn_s_GS
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)
Definition: LALSimIMRTEOBResumS_Internals.c:890
TEOB_IC_N
#define TEOB_IC_N
eob_wav_hlm
void eob_wav_hlm(LALTEOBResumSDynamics *dyn, LALTEOBResumSWaveformModeSingleTime *hlm)
Definition: LALSimIMRTEOBResumS_Internals.c:4248
eob_wav_hlmNQC
void eob_wav_hlmNQC(REAL8 UNUSED nu, REAL8 r, REAL8 prstar, REAL8 Omega, REAL8 ddotr, NQCcoefs *nqc, LALTEOBResumSWaveformModeSingleTime *hlmnqc)
Definition: LALSimIMRTEOBResumS_Internals.c:3233
eob_ham
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)
Definition: LALSimIMRTEOBResumS_Internals.c:63
eob_nqc_setcoefs
void eob_nqc_setcoefs(LALTEOBResumSDynamics *dyn)
Definition: LALSimIMRTEOBResumS_Internals.c:4461
eob_dyn_Npostadiabatic
int eob_dyn_Npostadiabatic(LALTEOBResumSDynamics *dyn, const REAL8 r0)
Definition: LALSimIMRTEOBResumS_Internals.c:5159
ChlmNewt_phase
static const REAL8 ChlmNewt_phase[35]
Definition: LALSimIMRTEOBResumS_Internals.c:48
eob_flx_Flux_s
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)
Definition: LALSimIMRTEOBResumS_Internals.c:2049
f14
static const REAL8 f14[]
Definition: LALSimIMRTEOBResumS_Internals.c:1920
eob_metric
void eob_metric(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *A, REAL8 *B, REAL8 *dA, REAL8 *d2A, REAL8 *dB)
Definition: LALSimIMRTEOBResumS_Internals.c:1752
eob_flx_Tlm
void eob_flx_Tlm(const REAL8 w, REAL8 *MTlm)
Definition: LALSimIMRTEOBResumS_Internals.c:1929
eob_dyn_bisecOmegaorb0
REAL8 eob_dyn_bisecOmegaorb0(LALTEOBResumSDynamics *dyn, REAL8 omg_orb0, REAL8 r0_kepl)
Definition: LALSimIMRTEOBResumS_Internals.c:367
eob_dyn_ic_s
void eob_dyn_ic_s(REAL8 r0, LALTEOBResumSDynamics *dyn, REAL8 y_init[])
Definition: LALSimIMRTEOBResumS_Internals.c:484
eob_wav_flm
void eob_wav_flm(REAL8 x, REAL8 nu, REAL8 clm[KMAX][6], REAL8 *rholm, REAL8 *flm)
Definition: LALSimIMRTEOBResumS_Internals.c:2784
eob_dyn_rhs
int eob_dyn_rhs(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
Definition: LALSimIMRTEOBResumS_Internals.c:662
eob_dyn_s_get_rc_NNLO
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)
Definition: LALSimIMRTEOBResumS_Internals.c:1142
CNlm
static const double CNlm[35]
Definition: LALSimIMRTEOBResumS_Internals.c:52
eob_wav_flm_s_SSNLO
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)
Definition: LALSimIMRTEOBResumS_Internals.c:2431
eob_wav_deltalm
void eob_wav_deltalm(REAL8 Hreal, REAL8 Omega, REAL8 nu, REAL8 *dlm)
Definition: LALSimIMRTEOBResumS_Internals.c:2908
eob_dyn_adiabLR
int eob_dyn_adiabLR(LALTEOBResumSDynamics *dyn, REAL8 *rLR, INT4 tidesFlag)
Definition: LALSimIMRTEOBResumS_Internals.c:5005
eob_ham_s
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)
Definition: LALSimIMRTEOBResumS_Internals.c:90
eob_wav_ringdown_template
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)
Definition: LALSimIMRTEOBResumS_Internals.c:4784
TEOB_NV
#define TEOB_NV
Definition: LALSimIMRTEOBResumS_Internals.c:41
eob_wav_speedyTail
void eob_wav_speedyTail(REAL8 Omega, REAL8 Hreal, REAL8 bphys, LALTEOBResumSWaveformModeSingleTime *tlm)
Definition: LALSimIMRTEOBResumS_Internals.c:2207
eob_dyn_s_get_rc_LO
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)
Definition: LALSimIMRTEOBResumS_Internals.c:1018
eob_flx_Flux
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)
Definition: LALSimIMRTEOBResumS_Internals.c:2191
eob_flx_FlmNewt
void eob_flx_FlmNewt(REAL8 x, REAL8 nu, REAL8 *Nlm)
Definition: LALSimIMRTEOBResumS_Internals.c:1878
eob_metric_Atidal
void eob_metric_Atidal(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *AT, REAL8 *dAT, REAL8 *d2AT)
Definition: LALSimIMRTEOBResumS_Internals.c:1471
eob_flx_HorizonFlux_s
REAL8 eob_flx_HorizonFlux_s(REAL8 x, REAL8 UNUSED Heff, REAL8 UNUSED jhat, REAL8 UNUSED nu, REAL8 X1, REAL8 X2, REAL8 chi1, REAL8 chi2)
Definition: LALSimIMRTEOBResumS_Internals.c:2009
eob_wav_hlmNewt
void eob_wav_hlmNewt(REAL8 r, REAL8 Omega, REAL8 phi, REAL8 nu, LALTEOBResumSWaveformModeSingleTime *hlmNewt)
Definition: LALSimIMRTEOBResumS_Internals.c:2971
eob_dyn_s_get_rc_NLO
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)
Definition: LALSimIMRTEOBResumS_Internals.c:1088
QNMHybridFitCab
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)
Definition: LALSimIMRTEOBResumS_Internals.c:4573
eob_wav_hlmNQC_nospin201602
void eob_wav_hlmNQC_nospin201602(REAL8 nu, REAL8 r, REAL8 prstar, REAL8 Omega, REAL8 ddotr, LALTEOBResumSWaveformModeSingleTime *hlmnqc)
Definition: LALSimIMRTEOBResumS_Internals.c:3123
eob_wav_flm_coeffs
void eob_wav_flm_coeffs(REAL8 nu, REAL8 clm[KMAX][6])
Definition: LALSimIMRTEOBResumS_Internals.c:2584
eob_wav_hlmNQC_find_a1a2a3_mrg
void eob_wav_hlmNQC_find_a1a2a3_mrg(LALTEOBResumSDynamics *dyn_mrg, SphHarmPolarTimeSeries *hlm_mrg, SphHarmPolarTimeSeries *hnqc, LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *hlm)
Definition: LALSimIMRTEOBResumS_Internals.c:3736
eob_dyn_bisecHeff0_s
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)
Definition: LALSimIMRTEOBResumS_Internals.c:197
eob_metric_s
void eob_metric_s(REAL8 r, LALTEOBResumSDynamics *dyn, REAL8 *A, REAL8 *B, REAL8 *dA, REAL8 *d2A, REAL8 *dB)
Definition: LALSimIMRTEOBResumS_Internals.c:1811
eob_dyn_r0_eob
REAL8 eob_dyn_r0_eob(REAL8 f0, LALTEOBResumSDynamics *dyn)
Definition: LALSimIMRTEOBResumS_Internals.c:253
eob_wav_flm_s_SSLO
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)
Definition: LALSimIMRTEOBResumS_Internals.c:2312
eob_dyn_s_get_rc_NOTIDES
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)
Definition: LALSimIMRTEOBResumS_Internals.c:1320
eob_dyn_s_get_rc_NOSPIN
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)
Definition: LALSimIMRTEOBResumS_Internals.c:1298
eob_nqc_setcoefs_nospin201602
void eob_nqc_setcoefs_nospin201602(REAL8 nu, NQCcoefs *nqc)
Definition: LALSimIMRTEOBResumS_Internals.c:4525
eob_wav_ringdown
void eob_wav_ringdown(LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *hlm)
Definition: LALSimIMRTEOBResumS_Internals.c:4805
RTAIL
#define RTAIL
eob_nqc_timeshift
REAL8 eob_nqc_timeshift(REAL8 nu, REAL8 chi1)
Definition: LALSimIMRTEOBResumS_Internals.c:4433
eob_wav_hhatlmTail
void eob_wav_hhatlmTail(REAL8 Omega, REAL8 Hreal, REAL8 bphys, LALTEOBResumSWaveformModeSingleTime *tlm)
Definition: LALSimIMRTEOBResumS_Internals.c:2263
eob_flx_HorizonFlux
REAL8 eob_flx_HorizonFlux(REAL8 x, REAL8 Heff, REAL8 jhat, REAL8 nu)
Definition: LALSimIMRTEOBResumS_Internals.c:1952
eob_metric_A5PNlog
void eob_metric_A5PNlog(REAL8 r, REAL8 nu, REAL8 *A, REAL8 *dA, REAL8 *d2A)
Definition: LALSimIMRTEOBResumS_Internals.c:1380
eob_c3_fit_global
REAL8 eob_c3_fit_global(REAL8 nu, REAL8 UNUSED chi1, REAL8 UNUSED chi2, REAL8 UNUSED X1, REAL8 UNUSED X2, REAL8 a1, REAL8 a2)
Definition: LALSimIMRTEOBResumS_Internals.c:4406
eob_wav_hlmNQC_find_a1a2a3
void eob_wav_hlmNQC_find_a1a2a3(LALTEOBResumSDynamics *dyn, SphHarmPolarTimeSeries *h, SphHarmPolarTimeSeries *hnqc)
Definition: LALSimIMRTEOBResumS_Internals.c:3286
ChlmNewt_ampli
static const REAL8 ChlmNewt_ampli[35]
Definition: LALSimIMRTEOBResumS_Internals.c:44
eob_dyn_s_get_rc_NNLO_S4
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)
Definition: LALSimIMRTEOBResumS_Internals.c:1217
eob_dyn_rhs_s
int eob_dyn_rhs_s(REAL8 t, const REAL8 y[], REAL8 dy[], void *d)
Definition: LALSimIMRTEOBResumS_Internals.c:758
eob_dyn_Omegaorb0
REAL8 eob_dyn_Omegaorb0(REAL8 r, void *params)
Definition: LALSimIMRTEOBResumS_Internals.c:266
TEOB_IC_S_N
#define TEOB_IC_S_N
eob_dyn_r0_Kepler
REAL8 eob_dyn_r0_Kepler(REAL8 f0)
Definition: LALSimIMRTEOBResumS_Internals.c:246
eob_dyn_fLR
REAL8 eob_dyn_fLR(REAL8 r, void *params)
Definition: LALSimIMRTEOBResumS_Internals.c:4992
eob_wav_hlmTidal
void eob_wav_hlmTidal(REAL8 x, LALTEOBResumSDynamics *dyn, REAL8 *hTidallm)
Definition: LALSimIMRTEOBResumS_Internals.c:3047
eob_dyn_DHeff0
REAL8 eob_dyn_DHeff0(REAL8 x, void *params)
Definition: LALSimIMRTEOBResumS_Internals.c:158
eob_dyn_ic
void eob_dyn_ic(REAL8 r0, LALTEOBResumSDynamics *dyn, REAL8 y_init[])
Definition: LALSimIMRTEOBResumS_Internals.c:411
cumint3
REAL8 cumint3(REAL8 *f, REAL8 *x, const INT4 n, REAL8 *sum)
Definition: LALSimIMRTEOBResumSUtils.c:513
D0
INT4 D0(REAL8 *f, REAL8 dx, INT4 n, REAL8 *df)
XLALWignerdMatrix, XLALWignerDMatrix in <lal/SphericalHarmonics.h>
Definition: LALSimIMRTEOBResumSUtils.c:473
Eulerlog
REAL8 Eulerlog(const REAL8 x, const INT4 m)
Definition: LALSimIMRTEOBResumSUtils.c:65
D2
INT4 D2(REAL8 *f, REAL8 dx, INT4 n, REAL8 *d2f)
Definition: LALSimIMRTEOBResumSUtils.c:493
find_max
REAL8 find_max(const INT4 n, REAL8 dx, REAL8 x0, REAL8 *f, REAL8 *fmax)
Definition: LALSimIMRTEOBResumSUtils.c:193
sigma
static double sigma(const double a, const double b, const sysq *system)
Internal function that computes the spin-spin couplings.
Definition: LALSimInspiralFDPrecAngles_internals.c:806
d
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 ...
Definition: LALSimInspiralFDPrecAngles_internals.c:604
c
#define c
Definition: LALSimInspiralHGimri.c:35
G
#define G
Definition: LALSimInspiralHGimri.c:36
C2
static REAL8 UNUSED C2(REAL8 e0, REAL8 f0)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:50
C1
static REAL8 UNUSED C1(REAL8 Mtotal)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:42
C4
static REAL8 UNUSED C4(REAL8 e0, REAL8 f0)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:74
C5
static REAL8 UNUSED C5(REAL8 e0, REAL8 f0)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:87
C3
static REAL8 UNUSED C3(REAL8 e0, REAL8 f0)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:62
C0
static REAL8 UNUSED C0(REAL8 eta)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:36
z3
static REAL8 UNUSED z3(REAL8 e0, REAL8 f0, REAL8 inc, REAL8 bet, REAL8 FPlus, REAL8 FCross)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:549
C6
static REAL8 UNUSED C6(REAL8 eta)
Definition: LALSimInspiralOptimizedCoefficientsEccentricityFD.c:101
LALSimTEOBResumS.h
This file is part of TEOBResumS.
Log2
#define Log2
Definition: LALSimTEOBResumS.h:161
TOLERANCE
#define TOLERANCE
Definition: LALSimTEOBResumS.h:96
DEQUAL
#define DEQUAL(a, b, eps)
Definition: LALSimTEOBResumS.h:142
POSTADIABATIC_DR
#define POSTADIABATIC_DR
Definition: LALSimTEOBResumS.h:101
KMAX
#define KMAX
Definition: LALSimTEOBResumS.h:215
TEOB_EVOLVE_RAD
@ TEOB_EVOLVE_RAD
Definition: LALSimTEOBResumS.h:171
TEOB_EVOLVE_PHI
@ TEOB_EVOLVE_PHI
Definition: LALSimTEOBResumS.h:172
TEOB_EVOLVE_PPHI
@ TEOB_EVOLVE_PPHI
Definition: LALSimTEOBResumS.h:174
TEOB_EVOLVE_PRSTAR
@ TEOB_EVOLVE_PRSTAR
Definition: LALSimTEOBResumS.h:173
PMTERMS_eps
#define PMTERMS_eps
Definition: LALSimTEOBResumS.h:216
POSTADIABATIC_N
#define POSTADIABATIC_N
Definition: LALSimTEOBResumS.h:103
NQC_NR_NOSPIN
@ NQC_NR_NOSPIN
Definition: LALSimTEOBResumS.h:267
NQC_OFF
@ NQC_OFF
Definition: LALSimTEOBResumS.h:265
NQC_COMPUTE
@ NQC_COMPUTE
Definition: LALSimTEOBResumS.h:266
TEOB_ID_PRSTAR
@ TEOB_ID_PRSTAR
Definition: LALSimTEOBResumS.h:184
TEOB_ID_PR
@ TEOB_ID_PR
Definition: LALSimTEOBResumS.h:185
TEOB_ID_E0
@ TEOB_ID_E0
Definition: LALSimTEOBResumS.h:187
TEOB_ID_PHI
@ TEOB_ID_PHI
Definition: LALSimTEOBResumS.h:182
TEOB_ID_RAD
@ TEOB_ID_RAD
Definition: LALSimTEOBResumS.h:181
TEOB_ID_PPHI
@ TEOB_ID_PPHI
Definition: LALSimTEOBResumS.h:183
TEOB_ID_OMGJ
@ TEOB_ID_OMGJ
Definition: LALSimTEOBResumS.h:188
TEOB_ID_J
@ TEOB_ID_J
Definition: LALSimTEOBResumS.h:186
MAX_ITER
#define MAX_ITER
Definition: LALSimTEOBResumS.h:95
SQ
#define SQ(a)
Definition: LALSimTEOBResumS.h:141
TEOB_PRSTAR
@ TEOB_PRSTAR
Definition: LALSimTEOBResumS.h:200
TEOB_OMGORB
@ TEOB_OMGORB
Definition: LALSimTEOBResumS.h:201
TEOB_DDOTR
@ TEOB_DDOTR
Definition: LALSimTEOBResumS.h:199
TEOB_RAD
@ TEOB_RAD
Definition: LALSimTEOBResumS.h:195
TEOB_MOMG
@ TEOB_MOMG
Definition: LALSimTEOBResumS.h:198
TEOB_PHI
@ TEOB_PHI
Definition: LALSimTEOBResumS.h:196
TEOB_PPHI
@ TEOB_PPHI
Definition: LALSimTEOBResumS.h:197
Hreal
REAL8 Hreal
Definition: SEOBNRv2_opt_.h:164
s
int s
Definition: bh_qnmode.c:137
l
int l
Definition: bh_qnmode.c:135
M
REAL8 M
Definition: bh_qnmode.c:133
dt
double dt
Definition: bh_ringdown.c:113
i
double i
Definition: bh_ringdown.c:118
e
double e
Definition: bh_ringdown.c:117
H
const double H
Definition: exact_derivatives-Hreal.c:146
pr
const double pr
Definition: exact_derivatives-Hreal.c:16
k0
coeffs k0
Definition: exact_derivatives-HrealHeader.c:38
u
const double u
Definition: exact_derivatives-HrealHeader.c:17
w2
const double w2
Definition: exact_derivatives-HrealHeader.c:55
a4
const double a4
Definition: exact_derivatives-HrealHeader.c:34
logu
const double logu
Definition: exact_derivatives-HrealHeader.c:58
u3
const double u3
Definition: exact_derivatives-HrealHeader.c:19
r2
const double r2
Definition: exact_derivatives-HrealHeader.c:15
u5
const double u5
Definition: exact_derivatives-HrealHeader.c:21
a2
const double a2
Definition: exact_derivatives-HrealHeader.c:33
w
const double w
Definition: exact_derivatives-HrealHeader.c:106
u2
const double u2
Definition: exact_derivatives-HrealHeader.c:18
u4
const double u4
Definition: exact_derivatives-HrealHeader.c:20
B
const double B
Definition: exact_derivatives-HrealHeader.c:97
LAL_PI
#define LAL_PI
LAL_GAMMA
#define LAL_GAMMA
REAL8
double REAL8
UINT4
uint32_t UINT4
INT4
int32_t INT4
XLALFree
void XLALFree(void *p)
LAL_SIM_INSPIRAL_GETIDES_GSF23
@ LAL_SIM_INSPIRAL_GETIDES_GSF23
Definition: LALSimInspiralWaveformFlags.h:94
LAL_SIM_INSPIRAL_GETIDES_NNLO
@ LAL_SIM_INSPIRAL_GETIDES_NNLO
Definition: LALSimInspiralWaveformFlags.h:92
LAL_SIM_INSPIRAL_GETIDES_GSF2
@ LAL_SIM_INSPIRAL_GETIDES_GSF2
Definition: LALSimInspiralWaveformFlags.h:93
LAL_SIM_INSPIRAL_GMTIDES_GSF
@ LAL_SIM_INSPIRAL_GMTIDES_GSF
Definition: LALSimInspiralWaveformFlags.h:101
LAL_SIM_INSPIRAL_GMTIDES_PN
@ LAL_SIM_INSPIRAL_GMTIDES_PN
Definition: LALSimInspiralWaveformFlags.h:100
r
static const INT4 r
a
static const INT4 a
XLAL_ERROR_VOID
#define XLAL_ERROR_VOID(...)
XLAL_ERROR_REAL8
#define XLAL_ERROR_REAL8(...)
XLAL_CHECK_VOID
#define XLAL_CHECK_VOID(assertion,...)
XLAL_EBADLEN
XLAL_EBADLEN
XLAL_SUCCESS
XLAL_SUCCESS
XLAL_EFAULT
XLAL_EFAULT
XLAL_EFUNC
XLAL_EFUNC
XLAL_EMAXITER
XLAL_EMAXITER
XLAL_EINVAL
XLAL_EINVAL
x
list x
p
list p
y
list y
status
string status
DHeff0_tmp_params
Definition: LALSimIMRTEOBResumS_Internals.c:153
DHeff0_tmp_params::chi1
REAL8 chi1
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::nu
REAL8 nu
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::drc_dr
REAL8 drc_dr
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::X2
REAL8 X2
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::rorb
REAL8 rorb
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::S
REAL8 S
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::A
REAL8 A
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::chi2
REAL8 chi2
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::Ss
REAL8 Ss
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::c3
REAL8 c3
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::X1
REAL8 X1
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::ak2
REAL8 ak2
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::rc
REAL8 rc
Definition: LALSimIMRTEOBResumS_Internals.c:154
DHeff0_tmp_params::dA
REAL8 dA
Definition: LALSimIMRTEOBResumS_Internals.c:154
LALTEOBResumSDynamics
Dynamics data type.
Definition: LALSimTEOBResumS.h:326
LALTEOBResumSDynamics::eob_dyn_s_get_rc
EOBDynSGetRCFunc eob_dyn_s_get_rc
Definition: LALSimTEOBResumS.h:351
LALTEOBResumSDynamics::eob_wav_flm_s
EOBWavFlmSFunc eob_wav_flm_s
Definition: LALSimTEOBResumS.h:352
LALTEOBResumSDynamics::data
REAL8 * data[TEOB_DYNAMICS_NVARS]
Definition: LALSimTEOBResumS.h:349
LALTEOBResumSWaveformModeSingleTime
Multipolar waveform at given time, comes at handy.
Definition: LALSimTEOBResumS.h:290
NQCcoefs
Multipolar coefficients for NQC waveform.
Definition: LALSimTEOBResumS.h:304
NQCcoefs::b1
double b1[KMAX]
Definition: LALSimTEOBResumS.h:308
NQCcoefs::a3
double a3[KMAX]
Definition: LALSimTEOBResumS.h:307
NQCcoefs::n
double n[KMAX][6]
Definition: LALSimTEOBResumS.h:311
NQCcoefs::activemode
int activemode[KMAX]
Definition: LALSimTEOBResumS.h:312
NQCcoefs::a2
double a2[KMAX]
Definition: LALSimTEOBResumS.h:306
NQCcoefs::b3
double b3[KMAX]
Definition: LALSimTEOBResumS.h:310
NQCcoefs::a1
double a1[KMAX]
Definition: LALSimTEOBResumS.h:305
NQCcoefs::b2
double b2[KMAX]
Definition: LALSimTEOBResumS.h:309
NQCdata
NQC data for flux and waveform.
Definition: LALSimTEOBResumS.h:319
NQCdata::hlm
NQCcoefs * hlm
Definition: LALSimTEOBResumS.h:321
NQCdata::flx
NQCcoefs * flx
Definition: LALSimTEOBResumS.h:320
Omegaorb0_tmp_params
Definition: LALSimIMRTEOBResumS_Internals.c:261
Omegaorb0_tmp_params::dyn
LALTEOBResumSDynamics * dyn
Definition: LALSimIMRTEOBResumS_Internals.c:263
Omegaorb0_tmp_params::omg_orb0
REAL8 omg_orb0
Definition: LALSimIMRTEOBResumS_Internals.c:262
REAL8TimeSeries::data
REAL8Sequence * data
REAL8Vector::data
REAL8 * data
SphHarmPolarTimeSeries::ampl
REAL8TimeSeries * ampl
The sequences of mode amplitude.
Definition: LALSimSphHarmSeries.h:59
SphHarmPolarTimeSeries::phase
REAL8TimeSeries * phase
The sequences of mode phase (not modulo 2Pi).
Definition: LALSimSphHarmSeries.h:60
SphHarmPolarTimeSeries::next
struct tagSphHarmPolarTimeSeries * next
next pointer
Definition: LALSimSphHarmSeries.h:64
SphHarmPolarTimeSeries::tdata
REAL8Sequence * tdata
Timestamp values.
Definition: LALSimSphHarmSeries.h:63
params
Definition: burst.c:245