LALSimulation  5.4.0.1-fe68b98
LALSimIMRSpinPrecEOBHcapExactDerivative.c
Go to the documentation of this file.
1 /** Static function file **/
2 #ifndef _LALSIMIMRSPINPRECEOBHCAPEXACTDERIVATIVE_C
3 #define _LALSIMIMRSPINPRECEOBHCAPEXACTDERIVATIVE_C
4 
5 #include "LALSimIMRCalculateSpinPrecEOBHCoeffs.c" /* SEOBNRv3_opt */
6 
7 /*------------------------------------------------------------------------------------------
8  *
9  * Prototypes of functions defined in this code.
10  *
11  *------------------------------------------------------------------------------------------
12  */
13 
14 static INT4 XLALSEOBNRv3_opt_HDerivs_for_Omega(
15  const REAL8 * valuestort,
16  const REAL8 mass1, const REAL8 mass2, const REAL8 eta,
17  SpinEOBHCoeffs * coeffs,
18  REAL8 * derivs,
19  SpinEOBParams * params);
20 
21 static INT4 XLALSEOBNRv3_opt_ComputeHamiltonianDerivatives(
22  const REAL8 * valuestort1, const REAL8 * valuestort2,
23  SpinEOBHCoeffs * coeffs,
24  REAL8 * derivs,
25  SpinEOBParams * params,
26  REAL8 * HReal);
27 
28 /*------------------------------------------------------------------------------------------
29  *
30  * Defintions of functions.
31  *
32  *------------------------------------------------------------------------------------------
33  */
34 
35 static INT4 XLALSEOBNRv3_opt_HDerivs_for_Omega(
36  const REAL8 * valuestort,
37  const REAL8 mass1, const REAL8 mass2, const REAL8 eta,
38  SpinEOBHCoeffs * coeffs,
39  REAL8 * derivs,
40  SpinEOBParams * params){
41 
42  REAL8 sigmaKerrData[3];
43  REAL8 sigmaStarData[3];
44  REAL8 s1VecData[3];
45  REAL8 s2VecData[3];
46 
47  /* Spins are independent of tortoise value */
48  memcpy(s1VecData, valuestort + 6, 3 * sizeof(REAL8));
49  memcpy(s2VecData, valuestort + 9, 3 * sizeof(REAL8));
50 
51  for(int i=0; i<3; i++){
52  sigmaKerrData[i] = s1VecData[i]+s2VecData[i];
53  sigmaStarData[i] = (mass2/mass1)*s1VecData[i]+(mass1/mass2)*s2VecData[i];
54  }
55 
56  REAL8Vector dsigmaKerr;
57  REAL8Vector dsigmaStar;
58  REAL8Vector ds1Vec;
59  REAL8Vector ds2Vec;
60 
61  dsigmaKerr.data = sigmaKerrData;
62  dsigmaStar.data = sigmaStarData;
63  ds1Vec.data = s1VecData;
64  ds2Vec.data = s2VecData;
65 
66  REAL8Vector * sigmaKerr;
67  REAL8Vector * sigmaStar;
68  REAL8Vector * s1Vec;
69  REAL8Vector * s2Vec;
70 
71  s1Vec = &ds1Vec;
72  s2Vec = &ds2Vec;
73  sigmaKerr = &dsigmaKerr;
74  sigmaStar = &dsigmaStar;
75 
76  SEOBHCoeffConstants * seobCoeffConsts = params->seobCoeffConsts;
77 
78  if(coeffs->updateHCoeffs){
79  SpinEOBHCoeffs tmpCoeffs;
80  REAL8 tmpa;
81 
82  tmpa = sqrt(sigmaKerr->data[0]*sigmaKerr->data[0]
83  + sigmaKerr->data[1]*sigmaKerr->data[1]
84  + sigmaKerr->data[2]*sigmaKerr->data[2]);
85 
86  if ( XLALSimIMRCalculateSpinPrecEOBHCoeffs( &tmpCoeffs, eta, tmpa, coeffs->SpinAlignedEOBversion ) == XLAL_FAILURE )
87  {
88  XLAL_ERROR( XLAL_EFUNC );
89  }
90 
91  tmpCoeffs.SpinAlignedEOBversion = coeffs->SpinAlignedEOBversion;
92  tmpCoeffs.updateHCoeffs = coeffs->updateHCoeffs;
93 
94  coeffs = &tmpCoeffs;
95  }
96 
97  REAL8 a2_prederiv = sigmaKerr->data[0] * sigmaKerr->data[0] + sigmaKerr->data[1] * sigmaKerr->data[1] + sigmaKerr->data[2] * sigmaKerr->data[2];
98  REAL8 a_prederiv = sqrt(a2_prederiv);
99 
100  INT4 divby0 = 0;
101 
102  REAL8 e3_x, e3_y, e3_z;
103 
104  if(a_prederiv !=0.)
105  {
106  const REAL8 inva = 1./a_prederiv;
107  e3_x = sigmaKerr->data[0] * inva;
108  e3_y = sigmaKerr->data[1] * inva;
109  e3_z = sigmaKerr->data[2] * inva;
110  }
111  else
112  {
113  /* SEOBNRv3_opt: Since spin=0, we are free to choose the "spin direction". */
114  e3_x = 1./sqrt(3.);
115  e3_y = 1./sqrt(3.);
116  e3_z = 1./sqrt(3.);
117 
118  divby0=1;
119  }
120 
121  REAL8Vector xVec, pVec;
122  xVec.length = pVec.length= 3;
123 
124  REAL8 xData[3] = {0.}, pData[3] = {0.};
125  xVec.data = xData;
126  pVec.data = pData;
127 
128  REAL8Vector * x;
129  REAL8Vector * p;
130  x=&xVec;
131  p=&pVec;
132 
133  memcpy(xVec.data,valuestort,3*sizeof(REAL8));
134  memcpy(pVec.data,valuestort+3,3*sizeof(REAL8));
135 
136  const REAL8 invr = 1./sqrt(xData[0]*xData[0]+xData[1]*xData[1]+xData[2]*xData[2]);
137 
138  if (1. - fabs(e3_x*(xData[0]*invr) + e3_y*(xData[1]*invr) + e3_z*(xData[2]*invr)) <= 1.e-8) {
139  e3_x = e3_x+0.1;
140  e3_y = e3_y+0.1;
141  const REAL8 invnorm = 1./sqrt(e3_x*e3_x + e3_y*e3_y + e3_z*e3_z);
142  e3_x = e3_x*invnorm;
143  e3_y = e3_y*invnorm;
144  e3_z = e3_z*invnorm;
145  divby0 = 1;
146  }
147 
148  if(divby0) {
149  /* s1 & s2Vec's cannot all be zero when taking spin derivatives, because naturally
150  some s1Vec's & s2Vec's appear in denominators of exact deriv expressions.
151  */
152  const double epsilon_spin=1e-14;
153  if(fabs(s1Vec->data[0] + s2Vec->data[0])<epsilon_spin &&
154  fabs(s1Vec->data[1] + s2Vec->data[1])<epsilon_spin &&
155  fabs(s1Vec->data[2] + s2Vec->data[2])<epsilon_spin) {
156  s1Vec->data[0] = epsilon_spin;
157  s1Vec->data[1] = epsilon_spin;
158  s1Vec->data[2] = epsilon_spin;
159  s2Vec->data[0] = epsilon_spin;
160  s2Vec->data[1] = epsilon_spin;
161  s2Vec->data[2] = epsilon_spin;
162  }
163  }
164  const REAL8 etainv = 1.0/eta;
165 
166  /* SEOBNRv3_opt: Must define the seob coeffs constants for spin derivatives */
167  UNUSED REAL8 c0k2 = seobCoeffConsts->a0k2;
168  UNUSED REAL8 c1k2 = seobCoeffConsts->a1k2;
169  UNUSED REAL8 c0k3 = seobCoeffConsts->a0k3;
170  UNUSED REAL8 c1k3 = seobCoeffConsts->a1k3;
171  UNUSED REAL8 c0k4 = seobCoeffConsts->a0k4;
172  UNUSED REAL8 c1k4 = seobCoeffConsts->a1k4;
173  UNUSED REAL8 c2k4 = seobCoeffConsts->a2k4;
174  UNUSED REAL8 c0k5 = seobCoeffConsts->a0k5;
175  UNUSED REAL8 c1k5 = seobCoeffConsts->a1k5;
176  UNUSED REAL8 c2k5 = seobCoeffConsts->a2k5;
177 
178  #include "seobnrv3_opt_exactderivs/exact_derivatives-HrealHeader.c"
179 
180  /* Momentum derivatives */
181  INT4 tortoise = 1;
182  {
183  #include "seobnrv3_opt_exactderivs/exact_derivatives-Hreal.c"
184  {
185  #include "seobnrv3_opt_exactderivs/exact_derivatives-px.c"
186  derivs[0]=Hrealprm*etainv;}
187  {
188  #include "seobnrv3_opt_exactderivs/exact_derivatives-py.c"
189  derivs[1]=Hrealprm*etainv;}
190  {
191  #include "seobnrv3_opt_exactderivs/exact_derivatives-pz.c"
192  derivs[2]=Hrealprm*etainv;}
193  }
194 
195  if(isnan(derivs[0]*derivs[1]*derivs[2])){
196  XLALPrintError("XLALSEOBNRv3_opt_HDerivs_for_Omega failed!\n");
197  XLALPrintError("NAN in derivative! derivs0,1,2 = %e %e %e | divby0 = %d\n",derivs[0],derivs[1],derivs[2],divby0);
198  XLAL_ERROR( XLAL_EFAILED );
199  }
200 
201  return 0;
202 }
203 
204 UNUSED static INT4 XLALSEOBNRv3_opt_ComputeHamiltonianDerivatives(const REAL8 * valuestort1 , const REAL8 * valuestort2, SpinEOBHCoeffs * coeffs, REAL8 * derivs, SpinEOBParams * params,REAL8 * HReal){
205 
206  REAL8 mass1 = params->eobParams->m1;
207  REAL8 mass2 = params->eobParams->m2;
208  REAL8 eta = params->eobParams->eta;
209 
210  REAL8 sigmaKerrData[3];
211  REAL8 sigmaStarData[3];
212  REAL8 s1VecData[3];
213  REAL8 s2VecData[3];
214 
215  REAL8Vector * sigmaKerr;
216  REAL8Vector * sigmaStar;
217  REAL8Vector * s1Vec;
218  REAL8Vector * s2Vec;
219 
220  REAL8Vector dsigmaKerr;
221  REAL8Vector dsigmaStar;
222  REAL8Vector ds1Vec;
223  REAL8Vector ds2Vec;
224 
225  s1Vec = &ds1Vec;
226  s2Vec = &ds2Vec;
227  sigmaKerr = &dsigmaKerr;
228  sigmaStar = &dsigmaStar;
229 
230  /* Spins are independent of tortoise value */
231  memcpy(s1VecData, valuestort1 + 6, 3 * sizeof(REAL8));
232  memcpy(s2VecData, valuestort1 + 9, 3 * sizeof(REAL8));
233 
234  const REAL8 m1divm2 = mass1/mass2;
235  const REAL8 m2divm1 = mass2/mass1;
236 
237  for(int i=0; i<3; i++){
238  sigmaKerrData[i] = s1VecData[i]+s2VecData[i];
239  sigmaStarData[i] = m2divm1*s1VecData[i]+m1divm2*s2VecData[i];
240  }
241 
242  dsigmaKerr.data = sigmaKerrData;
243  dsigmaStar.data = sigmaStarData;
244  ds1Vec.data = s1VecData;
245  ds2Vec.data = s2VecData;
246 
247  SEOBHCoeffConstants * seobCoeffConsts = params->seobCoeffConsts;
248 
249  REAL8 a2_prederiv = sigmaKerr->data[0] * sigmaKerr->data[0] + sigmaKerr->data[1] * sigmaKerr->data[1] + sigmaKerr->data[2] * sigmaKerr->data[2];
250  REAL8 a_prederiv = sqrt(a2_prederiv);
251 
252  if(coeffs->updateHCoeffs){
253  SpinEOBHCoeffs tmpCoeffs;
254 
255  if ( XLALSimIMRCalculateSpinPrecEOBHCoeffs( &tmpCoeffs, eta, a_prederiv, coeffs->SpinAlignedEOBversion ) == XLAL_FAILURE ){
256  XLAL_ERROR( XLAL_EFUNC );
257  }
258 
259  tmpCoeffs.SpinAlignedEOBversion = coeffs->SpinAlignedEOBversion;
260  tmpCoeffs.updateHCoeffs = coeffs->updateHCoeffs;
261 
262  coeffs = &tmpCoeffs;
263  }
264 
265  INT4 divby0 = 0;
266 
267  REAL8 e3_x, e3_y, e3_z, e3x, e3y, e3z;
268  const REAL8 inva = 1./a_prederiv;
269  const REAL8 inva3 = inva * inva * inva;
270 
271  if(a_prederiv !=0.){
272  e3x = sigmaKerr->data[0] * inva;
273  e3y = sigmaKerr->data[1] * inva;
274  e3z = sigmaKerr->data[2] * inva;
275 
276  e3_x = e3x;
277  e3_y = e3y;
278  e3_z = e3z;
279  }
280  else{
281  /* SEOBNRv3_opt: Since spin=0, we are free to choose the "spin direction". */
282  e3x = 1./sqrt(3.);
283  e3y = 1./sqrt(3.);
284  e3z = 1./sqrt(3.);
285 
286  e3_x = e3x;
287  e3_y = e3y;
288  e3_z = e3z;
289 
290  divby0=1;
291  }
292  REAL8Vector xVec, pVec;
293  xVec.length = pVec.length = 3;
294 
295  REAL8 xData[3] = {0.}, pData[3] = {0.};
296  xVec.data = xData;
297  pVec.data = pData;
298 
299  REAL8Vector * x;
300  REAL8Vector * p;
301 
302  x=&xVec;
303  p=&pVec;
304 
305  memcpy(xVec.data,valuestort1,3*sizeof(REAL8));
306  memcpy(pVec.data,valuestort1+3,3*sizeof(REAL8));
307 
308  const REAL8 invr = 1./sqrt(xData[0]*xData[0]+xData[1]*xData[1]+xData[2]*xData[2]);
309 
310  REAL8 invnorm = 0.;
311  if (1. - fabs(e3_x*(xData[0]*invr) + e3_y*(xData[1]*invr) + e3_z*(xData[2]*invr)) <= 1.e-8) {
312  e3_x = e3_x+0.1;
313  e3_y = e3_y+0.1;
314  invnorm = 1./sqrt(e3_x*e3_x + e3_y*e3_y + e3_z*e3_z);
315  e3_x = e3_x*invnorm;
316  e3_y = e3_y*invnorm;
317  e3_z = e3_z*invnorm;
318  divby0 = 1;
319  }
320 
321  const REAL8 invnorm3 = invnorm * invnorm * invnorm;
322 
323  if(divby0) {
324  /* s1 & s2Vec's cannot all be zero when taking spin derivatives, because naturally
325  some s1Vec's & s2Vec's appear in denominators of exact deriv expressions.
326  */
327  const double epsilon_spin=1e-14;
328  if(fabs(s1Vec->data[0] + s2Vec->data[0])<epsilon_spin &&
329  fabs(s1Vec->data[1] + s2Vec->data[1])<epsilon_spin &&
330  fabs(s1Vec->data[2] + s2Vec->data[2])<epsilon_spin) {
331  s1Vec->data[0] = epsilon_spin;
332  s1Vec->data[1] = epsilon_spin;
333  s1Vec->data[2] = epsilon_spin;
334  s2Vec->data[0] = epsilon_spin;
335  s2Vec->data[1] = epsilon_spin;
336  s2Vec->data[2] = epsilon_spin;
337  }
338  }
339 
340  const REAL8 etainv = 1.0/eta;
341 
342  /* SEOBNRv3_opt: Must define the seob coeffs constants for spin derivatives */
343  UNUSED REAL8 c0k2 = seobCoeffConsts->a0k2;
344  UNUSED REAL8 c1k2 = seobCoeffConsts->a1k2;
345  UNUSED REAL8 c0k3 = seobCoeffConsts->a0k3;
346  UNUSED REAL8 c1k3 = seobCoeffConsts->a1k3;
347  UNUSED REAL8 c0k4 = seobCoeffConsts->a0k4;
348  UNUSED REAL8 c1k4 = seobCoeffConsts->a1k4;
349  UNUSED REAL8 c2k4 = seobCoeffConsts->a2k4;
350  UNUSED REAL8 c0k5 = seobCoeffConsts->a0k5;
351  UNUSED REAL8 c1k5 = seobCoeffConsts->a1k5;
352  UNUSED REAL8 c2k5 = seobCoeffConsts->a2k5;
353 
354 #include "seobnrv3_opt_exactderivs/exact_derivatives-HrealHeader.c"
355 
356  /* Position derivatives */
357  INT4 tortoise = 2;
358  {
359  #include "seobnrv3_opt_exactderivs/exact_derivatives-Hreal.c"
360  {
361  #include "seobnrv3_opt_exactderivs/exact_derivatives-x.c"
362  derivs[0]=Hrealprm*etainv;}
363  {
364  #include "seobnrv3_opt_exactderivs/exact_derivatives-y.c"
365  derivs[1]=Hrealprm*etainv;}
366  {
367  #include "seobnrv3_opt_exactderivs/exact_derivatives-z.c"
368  derivs[2]=Hrealprm*etainv;}
369  }
370 
371  memcpy(xVec.data,valuestort2,3*sizeof(REAL8));
372  memcpy(pVec.data,valuestort2+3,3*sizeof(REAL8));
373 
374  /* Momentum and spin derivatives */
375  tortoise = 1;
376  {
377  #include "seobnrv3_opt_exactderivs/exact_derivatives-Hreal.c"
378  *HReal = Hreal;
379  {
380  #include "seobnrv3_opt_exactderivs/exact_derivatives-px.c"
381  derivs[3]=Hrealprm*etainv;}
382  {
383  #include "seobnrv3_opt_exactderivs/exact_derivatives-py.c"
384  derivs[4]=Hrealprm*etainv;}
385  {
386  #include "seobnrv3_opt_exactderivs/exact_derivatives-pz.c"
387  derivs[5]=Hrealprm*etainv;}
388  {
389  double e3USCORExprm = inva - sigmaKerr->data[0] * sigmaKerr->data[0] * inva3;
390  double e3USCOREyprm = - sigmaKerr->data[1] * sigmaKerr->data[0] * inva3;
391  double e3USCOREzprm = - sigmaKerr->data[2] * sigmaKerr->data[0] * inva3;
392 
393  if(divby0){
394  double e3xprm = e3USCORExprm;
395  double e3yprm = e3USCOREyprm;
396  double e3zprm = e3USCOREzprm;
397 
398  e3USCORExprm = e3xprm * invnorm - (e3x + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
399  e3USCOREyprm = e3yprm * invnorm - (e3y + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
400  e3USCOREzprm = e3zprm * invnorm - e3z * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
401  }
402 
403  #include "seobnrv3_opt_exactderivs/exact_derivatives-s1x.c"
404  derivs[6]=Hrealprm*etainv;}
405  {
406  double e3USCORExprm = - sigmaKerr->data[0] * sigmaKerr->data[1] * inva3;
407  double e3USCOREyprm = inva - sigmaKerr->data[1] * sigmaKerr->data[1] * inva3;
408  double e3USCOREzprm = - sigmaKerr->data[2] * sigmaKerr->data[1] * inva3;
409 
410  if(divby0){
411  double e3xprm = e3USCORExprm;
412  double e3yprm = e3USCOREyprm;
413  double e3zprm = e3USCOREzprm;
414 
415  e3USCORExprm = e3xprm * invnorm - (e3x + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
416  e3USCOREyprm = e3yprm * invnorm - (e3y + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
417  e3USCOREzprm = e3zprm * invnorm - e3z * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
418  }
419 
420  #include "seobnrv3_opt_exactderivs/exact_derivatives-s1y.c"
421  derivs[7]=Hrealprm*etainv;}
422  {
423  double e3USCORExprm = - sigmaKerr->data[0] * sigmaKerr->data[2] * inva3;
424  double e3USCOREyprm = - sigmaKerr->data[1] * sigmaKerr->data[2] * inva3;
425  double e3USCOREzprm = inva - sigmaKerr->data[2] * sigmaKerr->data[2] * inva3;
426 
427  if(divby0){
428  double e3xprm = e3USCORExprm;
429  double e3yprm = e3USCOREyprm;
430  double e3zprm = e3USCOREzprm;
431 
432  e3USCORExprm = e3xprm * invnorm - (e3x + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
433  e3USCOREyprm = e3yprm * invnorm - (e3y + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
434  e3USCOREzprm = e3zprm * invnorm - e3z * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
435  }
436 
437  #include "seobnrv3_opt_exactderivs/exact_derivatives-s1z.c"
438  derivs[8]=Hrealprm*etainv;}
439  {
440  double e3USCORExprm = inva - sigmaKerr->data[0] * sigmaKerr->data[0] * inva3;
441  double e3USCOREyprm = - sigmaKerr->data[1] * sigmaKerr->data[0] * inva3;
442  double e3USCOREzprm = - sigmaKerr->data[2] * sigmaKerr->data[0] * inva3;
443 
444  if(divby0){
445  double e3xprm = e3USCORExprm;
446  double e3yprm = e3USCOREyprm;
447  double e3zprm = e3USCOREzprm;
448 
449  e3USCORExprm = e3xprm * invnorm - (e3x + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
450  e3USCOREyprm = e3yprm * invnorm - (e3y + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
451  e3USCOREzprm = e3zprm * invnorm - e3z * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
452  }
453  #include "seobnrv3_opt_exactderivs/exact_derivatives-s2x.c"
454  derivs[9]=Hrealprm*etainv;}
455  {
456  double e3USCORExprm = - sigmaKerr->data[0] * sigmaKerr->data[1] * inva3;
457  double e3USCOREyprm = inva - sigmaKerr->data[1] * sigmaKerr->data[1] * inva3;
458  double e3USCOREzprm = - sigmaKerr->data[2] * sigmaKerr->data[1] * inva3;
459 
460  if(divby0){
461  double e3xprm = e3USCORExprm;
462  double e3yprm = e3USCOREyprm;
463  double e3zprm = e3USCOREzprm;
464 
465  e3USCORExprm = e3xprm * invnorm - (e3x + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
466  e3USCOREyprm = e3yprm * invnorm - (e3y + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
467  e3USCOREzprm = e3zprm * invnorm - e3z * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
468  }
469  #include "seobnrv3_opt_exactderivs/exact_derivatives-s2y.c"
470  derivs[10]=Hrealprm*etainv;}
471  {
472  double e3USCORExprm = - sigmaKerr->data[0] * sigmaKerr->data[2] * inva3;
473  double e3USCOREyprm = - sigmaKerr->data[1] * sigmaKerr->data[2] * inva3;
474  double e3USCOREzprm = inva - sigmaKerr->data[2] * sigmaKerr->data[2] * inva3;
475 
476  if(divby0){
477  double e3xprm = e3USCORExprm;
478  double e3yprm = e3USCOREyprm;
479  double e3zprm = e3USCOREzprm;
480 
481  e3USCORExprm = e3xprm * invnorm - (e3x + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
482  e3USCOREyprm = e3yprm * invnorm - (e3y + 0.1) * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
483  e3USCOREzprm = e3zprm * invnorm - e3z * (((e3x + 0.1) * e3xprm + (e3y + 0.1) * e3yprm + e3z * e3zprm) * invnorm3);
484  }
485  #include "seobnrv3_opt_exactderivs/exact_derivatives-s2z.c"
486  derivs[11]=Hrealprm*etainv;}
487  }
488 
489  if(isnan(derivs[0]*derivs[1]*derivs[2]*derivs[3]*derivs[4]*derivs[5]*derivs[6]*derivs[7]*derivs[8]*derivs[9]*derivs[10]*derivs[11])){
490  XLALPrintError("XLALSEOBNRv3_opt_ComputeHamiltonianDerivatives failed!\n");
491  XLALPrintError("NAN in derivative! derivs0,1,2,3,4,5,6,7,8,9,10,11 = %e %e %e %e %e %e %e %e %e %e %e %e | divby0 = %d\n",derivs[0],derivs[1],derivs[2],derivs[3],derivs[4],derivs[5],derivs[6],derivs[7],derivs[8],derivs[9],derivs[10],derivs[11],divby0);
492  XLAL_ERROR( XLAL_EFAILED );
493  }
494 
495  return 0;
496 }
497 
498 #endif // _LALSIMIMRSPINPRECEOBHCAPEXACTDERIVATIVE_C
XLALSimIMRCalculateSpinPrecEOBHCoeffs
static int XLALSimIMRCalculateSpinPrecEOBHCoeffs(SpinEOBHCoeffs *coeffs, const REAL8 eta, const REAL8 a, const UINT4 SpinAlignedEOBversion)
This function is used to calculate some coefficients which will be used in the spinning EOB Hamiltoni...
Definition: LALSimIMRCalculateSpinPrecEOBHCoeffs.c:52
XLALSEOBNRv3_opt_ComputeHamiltonianDerivatives
static INT4 XLALSEOBNRv3_opt_ComputeHamiltonianDerivatives(const REAL8 *valuestort1, const REAL8 *valuestort2, SpinEOBHCoeffs *coeffs, REAL8 *derivs, SpinEOBParams *params, REAL8 *HReal)
Definition: LALSimIMRSpinPrecEOBHcapExactDerivative.c:204
XLALSEOBNRv3_opt_HDerivs_for_Omega
static INT4 XLALSEOBNRv3_opt_HDerivs_for_Omega(const REAL8 *valuestort, const REAL8 mass1, const REAL8 mass2, const REAL8 eta, SpinEOBHCoeffs *coeffs, REAL8 *derivs, SpinEOBParams *params)
Definition: LALSimIMRSpinPrecEOBHcapExactDerivative.c:35
Hreal
REAL8 Hreal
Definition: SEOBNRv2_opt_.h:164
i
double i
Definition: bh_ringdown.c:118
e
double e
Definition: bh_ringdown.c:117
exact_derivatives-Hreal.c
exact_derivatives-HrealHeader.c
exact_derivatives-px.c
Hrealprm
const double Hrealprm
Definition: exact_derivatives-px.c:137
exact_derivatives-py.c
exact_derivatives-pz.c
exact_derivatives-s1x.c
exact_derivatives-s1y.c
exact_derivatives-s1z.c
exact_derivatives-s2x.c
exact_derivatives-s2y.c
exact_derivatives-s2z.c
exact_derivatives-x.c
exact_derivatives-y.c
exact_derivatives-z.c
REAL8
double REAL8
INT4
int32_t INT4
XLAL_ERROR
#define XLAL_ERROR(...)
XLALPrintError
int XLALPrintError(const char *fmt,...) _LAL_GCC_PRINTF_FORMAT_(1
XLAL_EFUNC
XLAL_EFUNC
XLAL_EFAILED
XLAL_EFAILED
XLAL_FAILURE
XLAL_FAILURE
x
list x
p
list p
REAL8Vector::data
REAL8 * data
SpinEOBHCoeffs
Parameters for the spinning EOB model, used in calculating the Hamiltonian.
Definition: LALSimIMRSpinEOB.h:57
SpinEOBHCoeffs::SpinAlignedEOBversion
UINT4 SpinAlignedEOBversion
Definition: LALSimIMRSpinEOB.h:72
SpinEOBParams
Parameters for the spinning EOB model.
Definition: LALSimIMRSpinEOB.h:116
params
Definition: burst.c:245
params::m1
double m1
Definition: inspiral.c:237
params::m2
double m2
Definition: inspiral.c:238