Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALInspiral 5.0.3.1-5e288d3
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
LALInspiralComputePTFMetric.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2007 Yi Pan, Duncan Brown
3*
4* This program is free software; you can redistribute it and/or modify
5* it under the terms of the GNU General Public License as published by
6* the Free Software Foundation; either version 2 of the License, or
7* (at your option) any later version.
8*
9* This program is distributed in the hope that it will be useful,
10* but WITHOUT ANY WARRANTY; without even the implied warranty of
11* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12* GNU General Public License for more details.
13*
14* You should have received a copy of the GNU General Public License
15* along with with program; see the file COPYING. If not, write to the
16* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
17* MA 02110-1301 USA
18*/
19
20/**
21 * \author Yi Pan, Duncan Brown
22 * \file
23 * \ingroup LALInspiralBank_h
24 *
25 * \brief Module to compute the components of the metric which is used to describe
26 * distances on Physical Template Family signal manifold.
27 *
28 * ### Prototypes ###
29 *
30 * <tt>XLALInspiralComputePTFIntrinsicMetric()</tt>:
31 * <ul>
32 * <li> <tt>metric,</tt> Output, the metric at the lattice point defined by \c params
33 * </li><li> <tt>psd,</tt> Input, the power spectral density of the data
34 * </li><li> <tt>params,</tt> Input, the parameters where metric must be computed
35 * in the computation of the metric.</li>
36 * </ul>
37 *
38 * <tt>XLALInspiralComputePTFFullMetric()</tt>:
39 * <ul>
40 * <li> <tt>metric,</tt> Output, the metric at the lattice point defined by \c params
41 * </li><li> <tt>psd,</tt> Input, the power spectral density of the data
42 * </li><li> <tt>params,</tt> Input, the parameters where metric must be computed
43 * in the computation of the metric.</li>
44 * </ul>
45 *
46 * <tt>XLALInspiralComputePTFWaveform()</tt>:
47 * <ul>
48 * <li> <tt>ptfwave,</tt> Output, the waveform at the lattice point defined
49 * by \c params
50 * </li><li> <tt>params,</tt> Input, the parameters where metric must be computed
51 * in the computation of the metric.</li>
52 * </ul>
53 *
54 * <tt>XLALInspiralComputePTFWDeriv()</tt>:
55 * <ul>
56 * <li> <tt>Wderiv,</tt> Output, the time derivative of waveform at the lattice
57 * point defined by \c params
58 * </li><li> <tt>psd,</tt> Input, the power spectral density of the data
59 * </li><li> <tt>params,</tt> Input, the parameters where metric must be computed
60 * in the computation of the metric
61 * </li><li> <tt>paramid,</tt> Input, id of the parameter to take derivative on
62 * </li><li> <tt>initdelta,</tt> Input, initial difference in parameters
63 * </li><li> <tt>tolerance,</tt> Input, stop iteration when difference between two
64 * bisections is smaller than tolerance.</li>
65 * </ul>
66 *
67 * ### Description ###
68 *
69 * We calculate the components of the metric using the procedure outlined
70 * by Yi.
71 *
72 * ### Algorithm ###
73 *
74 *
75 * ### Uses ###
76 *
77 * \code
78 * LALMalloc
79 * LALFree
80 * \endcode
81 *
82 * ### Notes ###
83 *
84 */
85
86#include <stdlib.h>
87#include <lal/LALStdlib.h>
88#include <stdio.h>
89#include <lal/AVFactories.h>
90#include <lal/SeqFactories.h>
91#include <lal/LALInspiralBank.h>
92#include <lal/LALNoiseModels.h>
93#include <lal/MatrixUtils.h>
94#include <lal/FindChirpPTF.h>
95
96#ifdef __GNUC__
97#define UNUSED __attribute__ ((unused))
98#else
99#define UNUSED
100#endif
101
102
103INT4 XLALInspiralComputePTFIntrinsicMetric (
104 InspiralMetric *metric,
105 REAL8Vector *fullmetric,
106 REAL8FrequencySeries *psd,
107 InspiralTemplate *params
108 )
109
110{
111 /* XLAL error handling */
112 INT4 errcode = XLAL_SUCCESS;
113
114 /* number of points in a time-domain segment */
115 UINT4 N = 2 * (psd->data->length - 1);
116 UINT4 i, j, k;
117
118 /* some useful numbers */
119 REAL4 sqrtoftwo = sqrt(2.0);
120 REAL4 onebysqrtoftwo = 1.0 / sqrtoftwo;
121 REAL4 onebysqrtofsix = 1.0 / sqrt(6.0);
122
123 /* get a local copy of the extrinstic parameters */
124 REAL8 Theta = params->sourceTheta;
125 REAL8 Phi = params->sourcePhi;
126 REAL8 Psi = params->polarisationAngle;
127 REAL8 phi0 = params->startPhase;
128
129 /* bounds on the power spectrum integration for the moments */
130 REAL8 deltaT = params->tSampling;
131 REAL8 deltaF = 1.0 / ((REAL8)N * deltaT);
132
133 /* local pointers to the Q and Qtilde data */
134 REAL8 P[5];
135 REAL8 PdTh[5];
136 REAL8 PdPh[5];
137 REAL8 PdPs[5];
138 REAL8Vector Q[5];
139 COMPLEX16Vector Qtilde[5];
140
141 FILE *derivsfile;
142 /* should really check that deltaT from the template agrees with N */
143 /* and deltaF from the power spectrum */
144
145 /* these variables, and the memory allocation following them should be */
146 /* moved to a differnent function at some point in the future (preferably */
147 /* before this function is ever called multiple times inside a loop) */
148 REAL8VectorSequence *PTFQ;
149 COMPLEX16VectorSequence *PTFQtilde;
150 REAL4Vector *PTFphi;
151 REAL4Vector *PTFomega_2_3;
152 REAL4VectorSequence *PTFe1;
153 REAL4VectorSequence *PTFe2;
154 REAL8FFTPlan *fwdPlan;
155 REAL8FFTPlan *revPlan;
156 COMPLEX16Vector *fsig0;
157 COMPLEX16Vector *fsig1;
158 COMPLEX16Vector *fsig;
159 COMPLEX16Vector *intrinsicderiv;
160 COMPLEX16VectorSequence *derivs;
161 REAL8 initdelta = 0.001;
162 REAL8 tolerance = 0.001;
163 REAL8Vector *invpsd;
164 REAL8Vector *tempnorm;
165 COMPLEX16Vector *tempnormtilde;
166 REAL8 wavenorm;
167 REAL8Array *IntInt_matrix;
168 REAL8Array *ExtExt_matrix;
169 REAL8Array *ExtExt_inverse;
170 REAL8Array *IntExt_matrix;
171 REAL8Array *IntExt_transp;
172 REAL8Array *matrix_5_x_4;
173 REAL8Array *matrix_4_x_4;
174 REAL8 *det;
175 LALStatus status;
176
177 PTFQ = XLALCreateREAL8VectorSequence( 5, N );
178 PTFQtilde = XLALCreateCOMPLEX16VectorSequence( 5, N / 2 + 1 );
179 PTFphi = XLALCreateVector( N );
180 PTFomega_2_3 = XLALCreateVector( N );
181 PTFe1 = XLALCreateVectorSequence( 3, N );
182 PTFe2 = XLALCreateVectorSequence( 3, N );
183 fwdPlan = XLALCreateForwardREAL8FFTPlan( N, 0 );
184 revPlan = XLALCreateReverseREAL8FFTPlan( N, 0 );
185 IntInt_matrix = XLALCreateREAL8ArrayL ( 2, 4, 4 );
186 ExtExt_matrix = XLALCreateREAL8ArrayL ( 2, 5, 5 );
187 ExtExt_inverse = XLALCreateREAL8ArrayL ( 2, 5, 5 );
188 IntExt_matrix = XLALCreateREAL8ArrayL ( 2, 4, 5 );
189 IntExt_transp = XLALCreateREAL8ArrayL ( 2, 5, 4 );
190 matrix_5_x_4 = XLALCreateREAL8ArrayL ( 2, 5, 4 );
191 matrix_4_x_4 = XLALCreateREAL8ArrayL ( 2, 4, 4 );
192
193 det = NULL;
194
195 memset( &status, 0, sizeof(LALStatus) );
196
197 /* call the PTF waveform code */
198 errcode = XLALFindChirpPTFWaveform( PTFphi, PTFomega_2_3, PTFe1, PTFe2,
199 params, deltaT);
200
201 if ( errcode != XLAL_SUCCESS ) XLAL_ERROR( errcode );
202
203 /* point the dummy variables Q and Qtilde to the actual output structures */
204 for ( i = 0; i < 5; ++i )
205 {
206 Q[i].length = N;
207 Qtilde[i].length = N / 2 + 1;
208 Q[i].data = PTFQ->data + (i * N);
209 Qtilde[i].data = PTFQtilde->data + (i * (N / 2 + 1)) ;
210 }
211
212 /* evaluate the Q^I factors from the dynamical variables */
213 for ( j = 0; j < N; ++j )
214 {
215 REAL8 omega_2_3 = PTFomega_2_3->data[j];
216 REAL8 phi = PTFphi->data[j];
217 REAL8 e1x = PTFe1->data[j];
218 REAL8 e1y = PTFe1->data[N + j];
219 REAL8 e1z = PTFe1->data[2 * N + j];
220 REAL8 e2x = PTFe2->data[j];
221 REAL8 e2y = PTFe2->data[N + j];
222 REAL8 e2z = PTFe2->data[2 * N + j];
223
224 Q[0].data[j] = omega_2_3 * onebysqrtoftwo * ( cos(2 * phi) * ( e1x * e1x +
225 e2y * e2y - e2x * e2x - e1y * e1y ) + 2 * sin(2 * phi) *
226 ( e1x * e2x - e1y * e2y ));
227 Q[1].data[j] = omega_2_3 * sqrtoftwo * ( cos(2 * phi) * ( e1x * e1y -
228 e2x * e2y ) + sin(2 * phi) * ( e1x * e2y + e1y * e2x ));
229 Q[2].data[j] = omega_2_3 * sqrtoftwo * ( cos(2 * phi) * ( e1x * e1z -
230 e2x * e2z ) + sin(2 * phi) * ( e1x * e2z + e1z * e2x ));
231 Q[3].data[j] = omega_2_3 * sqrtoftwo * ( cos(2 * phi) * ( e1y * e1z -
232 e2y * e2z ) + sin(2 * phi) * ( e1y * e2z + e1z * e2y ));
233 Q[4].data[j] = omega_2_3 * onebysqrtofsix * ( cos(2 * phi) *
234 ( 2 * e2z * e2z - 2 * e1z * e1z + e1x * e1x + e1y * e1y -
235 e2x * e2x - e2y * e2y ) + 2 * sin(2 * phi) * ( e1x * e2x +
236 e1y * e2y - 2 * e1z * e2z ));
237 }
238
239 /* Fourier transform the Q's into the Qtilde's */
240 for ( i = 0; i < 5; ++i )
241 {
242 XLALREAL8ForwardFFT( &Qtilde[i], &Q[i], fwdPlan);
243 }
244
245 /* evaluate the P_I factors from the extrinsic parameters */
246 P[0] = -(1 + cos(Theta) * cos(Theta)) * cos(2 * Phi) * cos(Psi)
247 + 2 * cos(Theta) * sin(2 * Phi) * sin(Psi);
248 P[1] = - 2 * cos(Theta) * cos(2 * Phi) * sin(Psi)
249 -(1 + cos(Theta) * cos(Theta)) * sin(2 * Phi) * cos(Psi);
250 P[2] = 2 * sin(Theta) * (-sin(Phi) * sin(Psi) + cos(Theta) * cos(Phi) * cos(Psi));
251 P[3] = 2 * sin(Theta) * ( cos(Phi) * sin(Psi) + cos(Theta) * sin(Phi) * cos(Psi));
252 P[4] = 3 * sin(Theta) * sin(Theta) * cos(Psi);
253
254 /* P_I derivative over Theta */
255 PdTh[0] = -(1 - sin(2 * Theta)) * cos(2 * Phi) * cos(Psi)
256 - 2 * sin(Theta) * sin(2 * Phi) * sin(Psi);
257 PdTh[1] = 2 * sin(Theta) * cos(2 * Phi) * sin(Psi)
258 -(1 - sin(2 * Theta)) * sin(2 * Phi) * cos(Psi);
259 PdTh[2] = 2 * cos(Theta) * (-sin(Phi) * sin(Psi) - sin(Theta) * cos(Phi) * cos(Psi));
260 PdTh[3] = 2 * cos(Theta) * ( cos(Phi) * sin(Psi) - sin(Theta) * sin(Phi) * cos(Psi));
261 PdTh[4] = 3 * sin(2 * Theta) * cos(Psi);
262
263 /* P_I derivative over Phi */
264 PdPh[0] = - 2 * (1 + cos(Theta) * cos(Theta)) * sin(2 * Phi) * cos(Psi)
265 + 4 * cos(Theta) * cos(2 * Phi) * sin(Psi);
266 PdPh[1] = 4 * cos(Theta) * sin(2 * Phi) * sin(Psi)
267 - 2 * (1 + cos(Theta) * cos(Theta)) * cos(2 * Phi) * cos(Psi);
268 PdPh[2] = 2 * sin(Theta) * (-cos(Phi) * sin(Psi) - cos(Theta) * sin(Phi) * cos(Psi));
269 PdPh[3] = 2 * sin(Theta) * (-sin(Phi) * sin(Psi) + cos(Theta) * cos(Phi) * cos(Psi));
270 PdPh[4] = 0;
271
272 /* P_I derivative over Psi */
273 PdPs[0] = (1 + cos(Theta) * cos(Theta)) * cos(2 * Phi) * sin(Psi)
274 + 2 * cos(Theta) * sin(2 * Phi) * cos(Psi);
275 PdPs[1] = - 2 * cos(Theta) * cos(2 * Phi) * cos(Psi)
276 + (1 + cos(Theta) * cos(Theta)) * sin(2 * Phi) * sin(Psi);
277 PdPs[2] = 2 * sin(Theta) * (-sin(Phi) * cos(Psi) - cos(Theta) * cos(Phi) * sin(Psi));
278 PdPs[3] = 2 * sin(Theta) * ( cos(Phi) * cos(Psi) - cos(Theta) * sin(Phi) * sin(Psi));
279 PdPs[4] = - 3 * sin(Theta) * sin(Theta) * sin(Psi);
280
281 /* Prepare frequency domain signals */
282 fsig0 = XLALCreateCOMPLEX16Vector(N / 2 + 1);
283 fsig1 = XLALCreateCOMPLEX16Vector(N / 2 + 1);
284 fsig = XLALCreateCOMPLEX16Vector(N / 2 + 1);
285
286 for (k = 0; k < N / 2 + 1; ++k)
287 {
288 fsig0->data[k] = 0.0;
289 fsig1->data[k] = 0.0;
290 for (i = 0; i < 5; ++i)
291 {
292 fsig0->data[k] += (((REAL8) P[i]) * Qtilde[i].data[k]);
293 }
294 fsig1->data[k] = crect( cimag(fsig0->data[k]), - creal(fsig0->data[k]) );
295 }
296 fsig1->data[0] = fsig0->data[0];
297 fsig1->data[N/2] = fsig0->data[N / 2];
298 for (k = 0; k < N / 2 + 1; ++k)
299 {
300 fsig->data[k] = crect( cos(phi0) * creal(fsig0->data[k]) + sin(phi0) * creal(fsig1->data[k]), cos(phi0) * cimag(fsig0->data[k]) + sin(phi0) * cimag(fsig1->data[k]) );
301 }
302
303 /* Waveform derivatives */
304 intrinsicderiv = XLALCreateCOMPLEX16Vector(N / 2 + 1);
305 derivs = XLALCreateCOMPLEX16VectorSequence(9, N / 2 + 1);
306
307 /* Compute extrinsic derivatives */
308 for (k = 0; k < N / 2 + 1; ++k)
309 {
310 /* t0 */
311 derivs->data[k] = crect( - LAL_TWOPI * deltaF * k * cimag(fsig->data[k]), LAL_TWOPI * deltaF * k * creal(fsig->data[k]) );
312 /* phi0 */
313 derivs->data[N/2+1+k] = crect( - sin(phi0) * creal(fsig0->data[k]) + cos(phi0) * creal(fsig1->data[k]), - sin(phi0) * cimag(fsig0->data[k]) + cos(phi0) * cimag(fsig1->data[k]) );
314 /* Theta */
315 derivs->data[N+2+k] = 0.0;
316 for (i = 0; i < 5; ++i)
317 {
318 derivs->data[N+2+k] += (((REAL8) PdTh[i]) * Qtilde[i].data[k]);
319 }
320 /* Phi */
321 derivs->data[3*N/2+3+k] = 0.0;
322 for (i = 0; i < 5; ++i)
323 {
324 derivs->data[3*N/2+3+k] += (((REAL8) PdPh[i]) * Qtilde[i].data[k]);
325 }
326 /* Psi */
327 derivs->data[2*N+4+k] = 0.0;
328 for (i = 0; i < 5; ++i)
329 {
330 derivs->data[2*N+4+k] += (((REAL8) PdPs[i]) * Qtilde[i].data[k]);
331 }
332 }
333
334 /* Compute intrinsic derivatives */
335 for (i = 5; i < 9; ++i)
336 {
337 errcode = XLALInspiralComputePTFWDeriv(intrinsicderiv, psd, params, i - 4, initdelta, tolerance);
338 if ( errcode != XLAL_SUCCESS )
339 {
340 fprintf( stderr, "XLALInspiralComputePTFDeriv failed\n" );
341 exit( 1 );
342 }
343 for (k = 0; k < N / 2 + 1; ++k)
344 {
345 derivs->data[i*(N/2+1)+k] = crect( cos(phi0) * creal(intrinsicderiv->data[k]) + sin(phi0) * cimag(intrinsicderiv->data[k]), cos(phi0) * cimag(intrinsicderiv->data[k]) - sin(phi0) * creal(intrinsicderiv->data[k]) );
346 }
347 derivs->data[i*(N/2+1)] = crect( (cos(phi0) + sin(phi0)) * creal(intrinsicderiv->data[0]), (cos(phi0) + sin(phi0)) * cimag(intrinsicderiv->data[0]) );
348 derivs->data[i*(N/2+1)+N/2] = crect( (cos(phi0) + sin(phi0)) * creal(intrinsicderiv->data[N / 2]), (cos(phi0) + sin(phi0)) * cimag(intrinsicderiv->data[N / 2]) );
349 }
350
351
352 derivsfile = fopen( "myderivs.dat", "w" );
353
354 if( derivsfile != NULL )
355 {
356 for (j = 0; j < N / 2 + 1; ++j)
357 {
358 fprintf( derivsfile, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
359 creal(derivs->data[j]), cimag(derivs->data[j]),
360 creal(derivs->data[(N / 2 + 1) + j]), cimag(derivs->data[(N / 2 + 1) + j]),
361 creal(derivs->data[2 * (N / 2 + 1) + j]), cimag(derivs->data[2 * (N / 2 + 1) + j]),
362 creal(derivs->data[3 * (N / 2 + 1) + j]), cimag(derivs->data[3 * (N / 2 + 1) + j]),
363 creal(derivs->data[4 * (N / 2 + 1) + j]), cimag(derivs->data[4 * (N / 2 + 1) + j]),
364 creal(derivs->data[5 * (N / 2 + 1) + j]), cimag(derivs->data[5 * (N / 2 + 1) + j]),
365 creal(derivs->data[6 * (N / 2 + 1) + j]), cimag(derivs->data[6 * (N / 2 + 1) + j]),
366 creal(derivs->data[7 * (N / 2 + 1) + j]), cimag(derivs->data[7 * (N / 2 + 1) + j]),
367 creal(derivs->data[8 * (N / 2 + 1) + j]), cimag(derivs->data[8 * (N / 2 + 1) + j]));
368 }
369 }
370 fclose(derivsfile);
371
372 /* Compute full metric */
373 invpsd = XLALCreateREAL8Vector(N / 2 + 1);
374 tempnorm = XLALCreateREAL8Vector(N);
375 tempnormtilde = XLALCreateCOMPLEX16Vector(N / 2 + 1);
376
377 for (k = 0; k < N / 2 + 1; ++k)
378 {
379 if (psd->data->data[k] == 0.)
380 invpsd->data[k] = 0.;
381 else
382 invpsd->data[k] = 1.0 / psd->data->data[k];
383 }
384
385 for (i = 0; i < 9; ++i)
386 {
387 for (j = 0; j < i + 1; ++j)
388 {
389 for (k = 0; k < N / 2 + 1; ++k)
390 {
391 tempnormtilde->data[k] = crect( ( creal(derivs->data[i * (N/2+1) + k]) * creal(derivs->data[j * (N/2+1) + k]) + cimag(derivs->data[i * (N/2+1) + k]) * cimag(derivs->data[j * (N/2+1) + k])) * invpsd->data[k], ( cimag(derivs->data[i * (N/2+1) + k]) * creal(derivs->data[j * (N/2+1) + k]) - creal(derivs->data[i * (N/2+1) + k]) * cimag(derivs->data[j * (N/2+1) + k])) * invpsd->data[k] );
392 }
393 /* Inverse Fourier of tempnorm */
394 XLALREAL8ReverseFFT(tempnorm, tempnormtilde, revPlan);
395 fullmetric->data[i * (i + 1) / 2 + j] = 4.0 * tempnorm->data[0];
396 }
397 }
398
399 wavenorm = fullmetric->data[2];
400 for (i = 0; i < 45; ++i)
401 {
402 fullmetric->data[i] /= wavenorm;
403 }
404
405 /* Calculating the extrinsic-extrinsic block of the metric */
406 for (i = 0; i < 5; ++i)
407 {
408 for (j = 0; j < i + 1; ++j)
409 {
410 ExtExt_matrix->data[ 5 * i + j] = ExtExt_matrix->data[ 5 * j + i] =
411 fullmetric->data[i * (i + 1) / 2 + j];
412 }
413 }
414
415 /* Calculating the inverse of ext-ext */
416 LALDMatrixInverse( &status, det, ExtExt_matrix, ExtExt_inverse );
417 if ( status.statusCode )
418 {
419 REPORTSTATUS( &status );
420 exit( 1 );
421 }
422
423 /* Calculating the intrinsic-intrinsic block of the metric */
424 for (i = 5; i < 9; ++i)
425 {
426 for (j = 5; j < i + 1; ++j)
427 {
428 IntInt_matrix->data[ 4 * (i-5) + j - 5] = IntInt_matrix->data[ 4 * (j-5) + i - 5]=
429 fullmetric->data[i * (i + 1) / 2 + j];
430 }
431 }
432
433 /* Calculating the mixed intrinsic-extrinsic block of the metric */
434 for (i = 5; i < 9; ++i)
435 {
436 for (j = 0; j < 5; ++j)
437 {
438 IntExt_matrix->data[ 5 * (i-5) + j] = fullmetric->data[i * (i + 1) / 2 + j];
439 }
440 }
441
442 /* Calculating the transpose of int-ext */
443 LALDMatrixTranspose ( &status, IntExt_transp, IntExt_matrix );
444 if ( status.statusCode )
445 {
446 REPORTSTATUS( &status );
447 exit( 1 );
448 }
449
450 for (i = 0; i < 5; ++i)
451 {
452 for (j=0; j < 4; ++j)
453 {
454 IntExt_transp->data[ 4 * i + j] = IntExt_matrix->data[ j * 5 + i];
455 }
456 }
457
458 /* Compute the projected metric from eq.(72) of PBCV*/
459
460 LALDMatrixMultiply ( &status, matrix_5_x_4, ExtExt_inverse, IntExt_transp );
461 if ( status.statusCode )
462 {
463 REPORTSTATUS( &status );
464 exit( 1 );
465 }
466
467 LALDMatrixMultiply ( &status, matrix_4_x_4, IntExt_matrix, matrix_5_x_4 );
468 if ( status.statusCode )
469 {
470 REPORTSTATUS( &status );
471 exit( 1 );
472 }
473
474 for ( i = 0; i < 4; ++i )
475 {
476 for ( j = 0; j < i + 1; ++j )
477 {
478 params->Gamma[i * (i + 1) / 2 + j] = metric->Gamma[i * (i + 1) / 2 + j] =
479 IntInt_matrix->data[i * 4 + j] - matrix_4_x_4->data[i * 4 + j];
480 }
481 }
482
483 /* this memory deallocation code should be moved to a separate function */
484 XLALDestroyCOMPLEX16Vector(fsig0);
485 XLALDestroyCOMPLEX16Vector(fsig1);
486 XLALDestroyCOMPLEX16Vector(fsig);
487 XLALDestroyCOMPLEX16Vector(intrinsicderiv);
488 XLALDestroyCOMPLEX16VectorSequence(derivs);
489 XLALDestroyCOMPLEX16Vector(tempnormtilde);
490 XLALDestroyREAL8Vector(tempnorm);
491 XLALDestroyREAL8VectorSequence( PTFQ );
492 XLALDestroyCOMPLEX16VectorSequence( PTFQtilde );
493 XLALDestroyVector( PTFphi );
494 XLALDestroyVector( PTFomega_2_3 );
495 XLALDestroyVectorSequence( PTFe1 );
496 XLALDestroyVectorSequence( PTFe2 );
497 XLALDestroyREAL8FFTPlan( fwdPlan );
498 XLALDestroyREAL8FFTPlan( revPlan );
499 XLALDestroyREAL8Array( IntInt_matrix );
500 XLALDestroyREAL8Array( ExtExt_matrix );
501 XLALDestroyREAL8Array( IntExt_matrix );
502 XLALDestroyREAL8Array( IntExt_transp );
503 XLALDestroyREAL8Array( ExtExt_inverse );
504 XLALDestroyREAL8Array( matrix_5_x_4 );
505 XLALDestroyREAL8Array( matrix_4_x_4 );
506
507 /* normal exit */
508 return errcode;
509}
510
511
512INT4 XLALInspiralComputePTFWaveform (
513 REAL8Vector *ptfwave,
514 InspiralTemplate *params
515 )
516
517{
518 /* XLAL error handling */
519 INT4 errcode = XLAL_SUCCESS;
520
521 /* number of points in a time-domain segment */
522 UINT4 N = ptfwave->length;
523 UINT4 i, j;
524
525 /* some useful numbers */
526 REAL8 sqrtoftwo = sqrt(2.0);
527 REAL8 onebysqrtoftwo = 1.0 / sqrtoftwo;
528 REAL8 onebysqrtofsix = 1.0 / sqrt(6.0);
529
530 /* get a local copy of the extrinstic parameters */
531 REAL8 Theta = params->sourceTheta;
532 REAL8 Phi = params->sourcePhi;
533 REAL8 Psi = params->polarisationAngle;
534 REAL8 phi0 = params->startPhase;
535
536 /* bounds on the power spectrum integration for the moments */
537 REAL8 deltaT = params->tSampling;
538
539 /* P-factors */
540 REAL8 P[5];
541 /* local pointers to the Q and Qtilde data */
542 REAL8Vector Q[5];
543 REAL8Vector Qp[5];
544
545 /* should really check that deltaT from the template agrees with N */
546 /* and deltaF from the power spectrum */
547
548 /* these variables, and the memory allocation following them should be */
549 /* moved to a differnent function at some point in the future (preferably */
550 /* before this function is ever called multiple times inside a loop) */
551 REAL8VectorSequence *PTFQ;
552 REAL8VectorSequence *PTFQp;
553 REAL4Vector *PTFphi;
554 REAL4Vector *PTFomega_2_3;
555 REAL4VectorSequence *PTFe1;
556 REAL4VectorSequence *PTFe2;
557 REAL8FFTPlan *fwdPlan;
558
559 PTFQ = XLALCreateREAL8VectorSequence( 5, N );
560 PTFQp = XLALCreateREAL8VectorSequence( 5, N );
561 PTFphi = XLALCreateREAL4Vector( N );
562 PTFomega_2_3 = XLALCreateREAL4Vector( N );
563 PTFe1 = XLALCreateREAL4VectorSequence( 3, N );
564 PTFe2 = XLALCreateREAL4VectorSequence( 3, N );
565 fwdPlan = XLALCreateForwardREAL8FFTPlan( N, 0 );
566
567 /* call the PTF waveform code */
568 errcode = XLALFindChirpPTFWaveform( PTFphi, PTFomega_2_3, PTFe1, PTFe2,
569 params, deltaT);
570
571 if ( errcode != XLAL_SUCCESS ) XLAL_ERROR( errcode );
572
573 /* point the dummy variables Q and Qp to the actual output structures */
574 for ( i = 0; i < 5; ++i )
575 {
576 Q[i].length = N;
577 Qp[i].length = N;
578 Q[i].data = PTFQ->data + (i * N);
579 Qp[i].data = PTFQp->data + (i * N);
580 }
581
582 /* evaluate the Q^I factors from the dynamical variables */
583 for ( j = 0; j < N; ++j )
584 {
585 REAL8 omega_2_3 = PTFomega_2_3->data[j];
586 REAL8 phi = PTFphi->data[j];
587 REAL8 e1x = PTFe1->data[j];
588 REAL8 e1y = PTFe1->data[N + j];
589 REAL8 e1z = PTFe1->data[2 * N + j];
590 REAL8 e2x = PTFe2->data[j];
591 REAL8 e2y = PTFe2->data[N + j];
592 REAL8 e2z = PTFe2->data[2 * N + j];
593
594 Q[0].data[j] = omega_2_3 * onebysqrtoftwo * ( cos(2 * phi) * ( e1x * e1x +
595 e2y * e2y - e2x * e2x - e1y * e1y ) + 2 * sin(2 * phi) *
596 ( e1x * e2x - e1y * e2y ));
597 Q[1].data[j] = omega_2_3 * sqrtoftwo * ( cos(2 * phi) * ( e1x * e1y -
598 e2x * e2y ) + sin(2 * phi) * ( e1x * e2y + e1y * e2x ));
599 Q[2].data[j] = omega_2_3 * sqrtoftwo * ( cos(2 * phi) * ( e1x * e1z -
600 e2x * e2z ) + sin(2 * phi) * ( e1x * e2z + e1z * e2x ));
601 Q[3].data[j] = omega_2_3 * sqrtoftwo * ( cos(2 * phi) * ( e1y * e1z -
602 e2y * e2z ) + sin(2 * phi) * ( e1y * e2z + e1z * e2y ));
603 Q[4].data[j] = omega_2_3 * onebysqrtofsix * ( cos(2 * phi) *
604 ( 2 * e2z * e2z - 2 * e1z * e1z + e1x * e1x + e1y * e1y -
605 e2x * e2x - e2y * e2y ) + 2 * sin(2 * phi) * ( e1x * e2x +
606 e1y * e2y - 2 * e1z * e2z ));
607
608 Qp[0].data[j] = omega_2_3 * onebysqrtoftwo * ( - sin(2 * phi) * ( e1x * e1x +
609 e2y * e2y - e2x * e2x - e1y * e1y ) + 2 * cos(2 * phi) *
610 ( e1x * e2x - e1y * e2y ));
611 Qp[1].data[j] = omega_2_3 * sqrtoftwo * ( - sin(2 * phi) * ( e1x * e1y -
612 e2x * e2y ) + cos(2 * phi) * ( e1x * e2y + e1y * e2x ));
613 Qp[2].data[j] = omega_2_3 * sqrtoftwo * ( - sin(2 * phi) * ( e1x * e1z -
614 e2x * e2z ) + cos(2 * phi) * ( e1x * e2z + e1z * e2x ));
615 Qp[3].data[j] = omega_2_3 * sqrtoftwo * ( - sin(2 * phi) * ( e1y * e1z -
616 e2y * e2z ) + cos(2 * phi) * ( e1y * e2z + e1z * e2y ));
617 Qp[4].data[j] = omega_2_3 * onebysqrtofsix * ( - sin(2 * phi) *
618 ( 2 * e2z * e2z - 2 * e1z * e1z + e1x * e1x + e1y * e1y -
619 e2x * e2x - e2y * e2y ) + 2 * cos(2 * phi) * ( e1x * e2x +
620 e1y * e2y - 2 * e1z * e2z ));
621 }
622
623 /* evaluate the P_I factors from the extrinsic parameters */
624 P[0] = -(1 + cos(Theta) * cos(Theta)) * cos(2 * Phi) * cos(Psi)
625 + 2 * cos(Theta) * sin(2 * Phi) * sin(Psi);
626 P[1] = - 2 * cos(Theta) * cos(2 * Phi) * sin(Psi)
627 -(1 + cos(Theta) * cos(Theta)) * sin(2 * Phi) * cos(Psi);
628 P[2] = 2 * sin(Theta) * (-sin(Phi) * sin(Psi) + cos(Theta) * cos(Phi) * cos(Psi));
629 P[3] = 2 * sin(Theta) * ( cos(Phi) * sin(Psi) + cos(Theta) * sin(Phi) * cos(Psi));
630 P[4] = 3 * sin(Theta) * sin(Theta) * cos(Psi);
631
632 /* Build the time domain PTF waveform */
633 /* fprintf( stdout, "initial phase: %f\n", phi0); */
634 for ( j = 0; j < N; ++j )
635 {
636 ptfwave->data[j] = P[0] * ( Q[0].data[j] * cos(phi0) + Qp[0].data[j] * sin(phi0) )
637 + P[1] * ( Q[1].data[j] * cos(phi0) + Qp[1].data[j] * sin(phi0) )
638 + P[2] * ( Q[2].data[j] * cos(phi0) + Qp[2].data[j] * sin(phi0) )
639 + P[3] * ( Q[3].data[j] * cos(phi0) + Qp[3].data[j] * sin(phi0) )
640 + P[4] * ( Q[4].data[j] * cos(phi0) + Qp[4].data[j] * sin(phi0) );
641 }
642
643 /* this memory deallocation code should be moved to a separate function */
644 XLALDestroyREAL8VectorSequence( PTFQ );
645 XLALDestroyREAL8VectorSequence( PTFQp );
646 XLALDestroyREAL4Vector( PTFphi );
647 XLALDestroyREAL4Vector( PTFomega_2_3 );
648 XLALDestroyREAL4VectorSequence( PTFe1 );
649 XLALDestroyREAL4VectorSequence( PTFe2 );
650 XLALDestroyREAL8FFTPlan( fwdPlan );
651
652 /* normal exit */
653 return XLAL_SUCCESS;
654
655}
656
657
658INT4 XLALInspiralComputePTFWDeriv (
659 COMPLEX16Vector *Wderiv,
660 REAL8FrequencySeries *psd,
661 InspiralTemplate *params,
662 INT4 paramid,
663 REAL8 initdelta,
664 REAL8 tolerance
665 )
666
667{
668 /* XLAL error handling */
669 INT4 errcode = XLAL_SUCCESS;
670
671 /* number of points in a time-domain segment */
672 UINT4 N = (Wderiv->length - 1) * 2;
673 UINT4 j, k;
674
675 /* get a local copy of the intrinstic parameters */
676 REAL8 totalMass = params->totalMass;
677 REAL8 eta = params->eta;
678 REAL8 chi = params->chi;
679 REAL8 kappa = params->kappa;
680
681 /* bounds on the power spectrum integration for the moments */
682 REAL8 deltaT = params->tSampling;
683
684 /* deviated template parameters */
685 InspiralTemplate pparams = *params;
686 InspiralTemplate mparams = *params;
687
688 /* Waveform length recorder */
689 UINT4 clen, plen, mlen;
690 INT4 dlen;
691
692 /* local pointers to the waveforms data */
693 /* this memory deallocation code should be moved to a separate function */
694 REAL8Vector *cwave;
695 REAL8Vector *pwavenew;
696 REAL8Vector *mwavenew;
697 REAL8Vector *pwaveold;
698 REAL8Vector *mwaveold;
699 REAL8Vector *pwaveold2;
700 REAL8Vector *mwaveold2;
701 REAL8Vector *wavederivnew;
702 REAL8Vector *wavederivold;
703 REAL8Vector *wavederivdiff;
704 REAL8Vector *wavederiv_2;
705 REAL8Vector *wavederivdiff_2;
706 COMPLEX16Vector *derivtilde;
707 COMPLEX16Vector *derivdifftilde;
708 COMPLEX16Vector *derivpowertilde;
709 COMPLEX16Vector *derivdiffpowertilde;
710 REAL8FFTPlan *fwdPlan;
711 REAL8FFTPlan *revPlan;
712 UINT4 iter = 1;
713 UINT4 maxiter = 20;
714 REAL8 reldelta = initdelta;
715 REAL8 absdelta = 0;
716 REAL8 relderivdiff = 1.0;
717 REAL8 invpsd;
718 REAL8 powerderiv;
719 REAL8 powerderivdiff;
720
721 LALStatus status;
722 memset( &status, 0, sizeof(LALStatus) );
723 pparams.massChoice = totalMassAndEta;
724 mparams.massChoice = totalMassAndEta;
725
726 cwave = XLALCreateREAL8Vector( N );
727 pwavenew = XLALCreateREAL8Vector( N );
728 mwavenew = XLALCreateREAL8Vector( N );
729 pwaveold = XLALCreateREAL8Vector( N );
730 mwaveold = XLALCreateREAL8Vector( N );
731 pwaveold2 = XLALCreateREAL8Vector( N );
732 mwaveold2 = XLALCreateREAL8Vector( N );
733 wavederivnew = XLALCreateREAL8Vector( N );
734 wavederivold = XLALCreateREAL8Vector( N );
735 wavederivdiff = XLALCreateREAL8Vector( N );
736 wavederiv_2 = XLALCreateREAL8Vector( N );
737 wavederivdiff_2 = XLALCreateREAL8Vector( N );
738 derivtilde = XLALCreateCOMPLEX16Vector( N / 2 + 1 );
739 derivdifftilde = XLALCreateCOMPLEX16Vector( N / 2 + 1 );
740 derivpowertilde = XLALCreateCOMPLEX16Vector( N / 2 + 1 );
741 derivdiffpowertilde = XLALCreateCOMPLEX16Vector( N / 2 + 1 );
742 fwdPlan = XLALCreateForwardREAL8FFTPlan( N, 0 );
743 revPlan = XLALCreateReverseREAL8FFTPlan( N, 0 );
744
745 /* main loop */
746
747 /* Generate central waveform */
748 errcode = XLALInspiralComputePTFWaveform(cwave, params);
749 if ( errcode != XLAL_SUCCESS )
750 {
751 fprintf( stderr, "XLALInspiralComputePTFWaveform failed\n" );
752 exit( 1 );
753 }
754 clen = params->tC / deltaT + 0.5;
755
756 /* Finite differencing */
757 while (relderivdiff > tolerance && iter < maxiter + 1)
758 {
759 switch (paramid)
760 {
761 case 1:
762 absdelta = totalMass * reldelta;
763 pparams.totalMass = totalMass + absdelta;
764 mparams.totalMass = totalMass - absdelta;
765 break;
766 case 2:
767 absdelta = params->eta * reldelta;
768 pparams.eta = eta + absdelta;
769 mparams.eta = eta - absdelta;
770 break;
771 case 3:
772 absdelta = reldelta;
773 pparams.chi = chi + absdelta;
774 mparams.chi = chi - absdelta;
775 break;
776 case 4:
777 absdelta = reldelta;
778 pparams.kappa = kappa + absdelta;
779 mparams.kappa = kappa - absdelta;
780 break;
781 default:
782 fprintf( stdout, "XLALInspiralComputePTFWDeriv failed\n" );
783 break;
784 }
785 /* Update masses according to totalMass and eta */
786 LALInspiralParameterCalc(&status, &pparams);
787 if ( status.statusCode )
788 {
789 REPORTSTATUS( &status );
790 exit( 1 );
791 }
792 LALInspiralParameterCalc(&status, &mparams);
793 if ( status.statusCode )
794 {
795 REPORTSTATUS( &status );
796 exit( 1 );
797 }
798
799 /* Generate new waveforms */
800 errcode = XLALInspiralComputePTFWaveform(pwavenew, &pparams);
801 errcode = XLALInspiralComputePTFWaveform(mwavenew, &mparams);
802 if ( errcode != XLAL_SUCCESS )
803 {
804 fprintf( stderr, "XLALInspiralComputePTFWaveform failed\n" );
805 exit( 1 );
806 }
807 plen = pparams.tC / deltaT + 0.5;
808 mlen = mparams.tC / deltaT + 0.5;
809
810 /* Shift deviated waveforms to start the same time as the center waveform */
811 dlen = plen - clen;
812 if (dlen > 0)
813 {
814 memmove(pwavenew->data + dlen, pwavenew->data, (N - dlen) * sizeof(REAL8));
815 memset(pwavenew->data, 0, dlen * sizeof(REAL8));
816 }
817 else if (dlen < 0)
818 {
819 memmove(pwavenew->data, pwavenew->data - dlen, (N + dlen) * sizeof(REAL8));
820 memset(pwavenew->data + (N + dlen), 0, (- dlen) * sizeof(REAL8));
821 }
822 dlen = mlen - clen;
823 if (dlen > 0)
824 {
825 memmove(mwavenew->data + dlen, mwavenew->data, (N - dlen) * sizeof(REAL8));
826 memset(mwavenew->data, 0, dlen * sizeof(REAL8));
827 }
828 else if (dlen < 0)
829 {
830 memmove(mwavenew->data, mwavenew->data - dlen, (N + dlen) * sizeof(REAL8));
831 memset(mwavenew->data + (N + dlen), 0, (- dlen) * sizeof(REAL8));
832 }
833
834 /* Calculate waveform derivative using finite differencing formula */
835 if (iter == 1)
836 {
837 for (j = 0; j < N; ++j)
838 {
839 wavederivnew->data[j] =
840 (pwavenew->data[j]/2 - mwavenew->data[j]/2) / absdelta;
841 wavederivdiff->data[j] = wavederivnew->data[j];
842 wavederivold->data[j] = wavederivnew->data[j];
843 pwaveold2->data[j] = pwavenew->data[j];
844 mwaveold2->data[j] = mwavenew->data[j];
845 pwaveold->data[j] = pwavenew->data[j];
846 mwaveold->data[j] = mwavenew->data[j];
847 }
848 }
849 else /* if (iter == 2) */
850 {
851 for (j = 0; j < N; ++j)
852 {
853 wavederivnew->data[j] =
854 (- pwaveold->data[j] / 12 + 2 * pwavenew->data[j] / 3
855 - 2 * mwavenew->data[j] / 3 + mwaveold->data[j] / 12) / absdelta;
856 wavederivdiff->data[j] = wavederivnew->data[j] - wavederivold->data[j];
857 wavederivold->data[j] = wavederivnew->data[j];
858 pwaveold2->data[j] = pwaveold->data[j];
859 mwaveold2->data[j] = mwaveold->data[j];
860 pwaveold->data[j] = pwavenew->data[j];
861 mwaveold->data[j] = mwavenew->data[j];
862 }
863 }
864 /* else
865 {
866 for (j = 0; j < N; ++j)
867 {
868 wavederivnew->data[j] =
869 (pwaveold2->data[j] / 60 - pwaveold->data[j] * 3 / 20 + pwavenew->data[j] * 3 / 4
870 - mwavenew->data[j] * 3 / 4 + mwaveold->data[j] * 3 / 20 - mwaveold2->data[j] / 60) / absdelta;
871 wavederivdiff->data[j] = wavederivnew->data[j] - wavederivold->data[j];
872 wavederivold->data[j] = wavederivnew->data[j];
873 pwaveold2->data[j] = pwaveold->data[j];
874 mwaveold2->data[j] = mwaveold->data[j];
875 pwaveold->data[j] = pwavenew->data[j];
876 mwaveold->data[j] = mwavenew->data[j];
877 }
878 } */
879
880 /* Fourier transform of derivative and derivative difference of waveforms */
881 XLALREAL8ForwardFFT( derivtilde, wavederivold, fwdPlan);
882 XLALREAL8ForwardFFT( derivdifftilde, wavederivdiff, fwdPlan);
883
884 for (k = 0; k < N/2 + 1; ++k)
885 {
886 if (psd->data->data[k] == 0.)
887 invpsd = 0.;
888 else
889 invpsd = 1.0 / psd->data->data[k];
890 derivpowertilde->data[k] = crect( (creal(derivtilde->data[k]) * creal(derivtilde->data[k]) +cimag(derivtilde->data[k]) * cimag(derivtilde->data[k])) * invpsd, 0 );
891 derivdiffpowertilde->data[k] = crect( (creal(derivdifftilde->data[k]) * creal(derivdifftilde->data[k]) +cimag(derivdifftilde->data[k]) * cimag(derivdifftilde->data[k])) * invpsd, 0 );
892 }
893
894 /* Inverse Fourier of derivdifftilde */
895 XLALREAL8ReverseFFT( wavederiv_2, derivpowertilde, revPlan);
896 XLALREAL8ReverseFFT( wavederivdiff_2, derivdiffpowertilde, revPlan);
897 /* I will take the power for now */
898 powerderiv = 4.0 * wavederiv_2->data[0];
899 powerderivdiff = 4.0 * wavederivdiff_2->data[0];
900
901 relderivdiff = powerderivdiff / powerderiv;
902
903 if (relderivdiff < tolerance)
904 {
905 for (k = 0; k < N / 2 + 1; ++k)
906 {
907 Wderiv->data[k] = derivtilde->data[k];
908 }
909 break;
910 }
911
912 reldelta *= 0.5;
913 iter += 1;
914 }
915
916 /* this memory deallocation code should be moved to a separate function */
917 XLALDestroyREAL8Vector( cwave );
918 XLALDestroyREAL8Vector( pwavenew );
919 XLALDestroyREAL8Vector( mwavenew );
920 XLALDestroyREAL8Vector( pwaveold );
921 XLALDestroyREAL8Vector( mwaveold );
922 XLALDestroyREAL8Vector( pwaveold2 );
923 XLALDestroyREAL8Vector( mwaveold2 );
924 XLALDestroyREAL8Vector( wavederivold );
925 XLALDestroyREAL8Vector( wavederivnew );
926 XLALDestroyREAL8Vector( wavederivdiff );
927 XLALDestroyREAL8Vector( wavederiv_2 );
928 XLALDestroyREAL8Vector( wavederivdiff_2 );
929 XLALDestroyCOMPLEX16Vector( derivtilde );
930 XLALDestroyCOMPLEX16Vector( derivdifftilde );
931 XLALDestroyCOMPLEX16Vector( derivpowertilde );
932 XLALDestroyCOMPLEX16Vector( derivdiffpowertilde );
933 XLALDestroyREAL8FFTPlan( fwdPlan );
934 XLALDestroyREAL8FFTPlan( revPlan );
935
936 /* normal exit */
937 return XLAL_SUCCESS;
938}
REPORTSTATUS
void REPORTSTATUS(LALStatus *status)
LALInspiralParameterCalc
void LALInspiralParameterCalc(LALStatus *status, InspiralTemplate *params)
Definition: LALInspiralParameterCalc.c:117
fprintf
#define fprintf
i
double i
Q
const double Q
data
sigmaKerr data[0]
XLALDestroyREAL8Array
void XLALDestroyREAL8Array(REAL8Array *)
XLALCreateREAL8ArrayL
REAL8Array * XLALCreateREAL8ArrayL(UINT4,...)
XLALCreateREAL8VectorSequence
REAL8VectorSequence * XLALCreateREAL8VectorSequence(UINT4 length, UINT4 veclen)
XLALDestroyCOMPLEX16VectorSequence
void XLALDestroyCOMPLEX16VectorSequence(COMPLEX16VectorSequence *vecseq)
XLALDestroyREAL4VectorSequence
void XLALDestroyREAL4VectorSequence(REAL4VectorSequence *vecseq)
XLALDestroyVectorSequence
void XLALDestroyVectorSequence(REAL4VectorSequence *vecseq)
XLALDestroyREAL8VectorSequence
void XLALDestroyREAL8VectorSequence(REAL8VectorSequence *vecseq)
XLALCreateREAL4VectorSequence
REAL4VectorSequence * XLALCreateREAL4VectorSequence(UINT4 length, UINT4 veclen)
XLALCreateCOMPLEX16VectorSequence
COMPLEX16VectorSequence * XLALCreateCOMPLEX16VectorSequence(UINT4 length, UINT4 veclen)
XLALCreateVectorSequence
REAL4VectorSequence * XLALCreateVectorSequence(UINT4 length, UINT4 veclen)
LALDMatrixInverse
void LALDMatrixInverse(LALStatus *stat, REAL8 *det, REAL8Array *matrix, REAL8Array *inverse)
XLALFindChirpPTFWaveform
INT4 XLALFindChirpPTFWaveform(REAL4Vector *PTFphi, REAL4Vector *PTFomega_2_3, REAL4VectorSequence *PTFe1, REAL4VectorSequence *PTFe2, InspiralTemplate *InspTmplt, REAL8 deltaT)
Definition: FindChirpPTFWaveform.c:426
LAL_TWOPI
#define LAL_TWOPI
crect
#define crect(re, im)
REAL8
double REAL8
UINT4
uint32_t UINT4
INT4
int32_t INT4
REAL4
float REAL4
totalMassAndEta
@ totalMassAndEta
total mass and symmetric mass ratio
Definition: LALInspiral.h:180
XLALInspiralComputePTFIntrinsicMetric
INT4 XLALInspiralComputePTFIntrinsicMetric(InspiralMetric *metric, REAL8Vector *fullmetric, REAL8FrequencySeries *psd, InspiralTemplate *params)
Definition: LALInspiralComputePTFMetric.c:103
XLALInspiralComputePTFWaveform
INT4 XLALInspiralComputePTFWaveform(REAL8Vector *ptfwave, InspiralTemplate *params)
Definition: LALInspiralComputePTFMetric.c:512
XLALInspiralComputePTFWDeriv
INT4 XLALInspiralComputePTFWDeriv(COMPLEX16Vector *Wderiv, REAL8FrequencySeries *psd, InspiralTemplate *params, INT4 paramid, REAL8 initdelta, REAL8 tolerance)
Definition: LALInspiralComputePTFMetric.c:658
LALDMatrixMultiply
void LALDMatrixMultiply(LALStatus *, REAL8Array *out, REAL8Array *in1, REAL8Array *in2)
LALDMatrixTranspose
void LALDMatrixTranspose(LALStatus *, REAL8Array *out, REAL8Array *in1)
XLALREAL8ForwardFFT
int XLALREAL8ForwardFFT(COMPLEX16Vector *output, const REAL8Vector *input, const REAL8FFTPlan *plan)
XLALREAL8ReverseFFT
int XLALREAL8ReverseFFT(REAL8Vector *output, const COMPLEX16Vector *input, const REAL8FFTPlan *plan)
XLALDestroyREAL8FFTPlan
void XLALDestroyREAL8FFTPlan(REAL8FFTPlan *plan)
XLALCreateReverseREAL8FFTPlan
REAL8FFTPlan * XLALCreateReverseREAL8FFTPlan(UINT4 size, int measurelvl)
XLALCreateForwardREAL8FFTPlan
REAL8FFTPlan * XLALCreateForwardREAL8FFTPlan(UINT4 size, int measurelvl)
XLALCreateREAL4Vector
REAL4Vector * XLALCreateREAL4Vector(UINT4 length)
XLALDestroyVector
void XLALDestroyVector(REAL4Vector *vector)
XLALDestroyREAL4Vector
void XLALDestroyREAL4Vector(REAL4Vector *vector)
XLALCreateVector
REAL4Vector * XLALCreateVector(UINT4 length)
XLALCreateREAL8Vector
REAL8Vector * XLALCreateREAL8Vector(UINT4 length)
XLALCreateCOMPLEX16Vector
COMPLEX16Vector * XLALCreateCOMPLEX16Vector(UINT4 length)
XLALDestroyREAL8Vector
void XLALDestroyREAL8Vector(REAL8Vector *vector)
XLALDestroyCOMPLEX16Vector
void XLALDestroyCOMPLEX16Vector(COMPLEX16Vector *vector)
XLAL_ERROR
#define XLAL_ERROR(...)
XLAL_SUCCESS
XLAL_SUCCESS
lalinspiral.git_version.status
string status
Definition: git_version.py:32
N
int N
COMPLEX16Vector::data
COMPLEX16 * data
InspiralMetric
Structure to store metric at various points the signal manifold.
Definition: LALInspiralBank.h:235
InspiralMetric::Gamma
REAL4 Gamma[10]
3d metric co-efficients in coordinates; Gamma[6] is a vector that stores the upper triangular part o...
Definition: LALInspiralBank.h:244
InspiralTemplate
The inspiral waveform parameter structure containing information about the waveform to be generated.
Definition: LALInspiral.h:205
InspiralTemplate::eta
REAL8 eta
symmetric mass ratio (input/output)
Definition: LALInspiral.h:291
InspiralTemplate::totalMass
REAL8 totalMass
total mass of the binary in solar mass (input/output)
Definition: LALInspiral.h:292
InspiralTemplate::tC
REAL8 tC
total chirp time seconds (output)
Definition: LALInspiral.h:301
InspiralTemplate::massChoice
InputMasses massChoice
The pair of (mass) parameters given (see structure defining this member for more details) (input)
Definition: LALInspiral.h:323
InspiralTemplate::chi
REAL8 chi
dimensionless spin of black hole (ie mass1)
Definition: LALInspiral.h:274
InspiralTemplate::kappa
REAL8 kappa
cosine of angle between spin of mass1 and orb ang mom
Definition: LALInspiral.h:275
REAL4Vector::data
REAL4 * data
REAL8Array::data
REAL8 * data
REAL8FrequencySeries::data
REAL8Sequence * data
REAL8Vector::data
REAL8 * data
deltaT
double deltaT