LALPulsar  6.1.0.1-89842e6
DriveHough.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005 Badri Krishnan, Alicia Sintes
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 #include <lal/LALHough.h>
21 
22 /** \cond DONT_DOXYGEN */
23 
24 #ifdef __GNUC__
25 #define UNUSED __attribute__ ((unused))
26 #else
27 #define UNUSED
28 #endif
29 
30 /** \endcond */
31 
32 /*
33  * The functions that make up the guts of this module
34  */
35 
36 #define SQ(x) (x) * (x)
37 
38 static void LALComputeAM (LALStatus *, AMCoeffs *coe, LIGOTimeGPS *ts, AMCoeffsParams *params);
39 
40 /** \addtogroup LALHough_h */
41 /** @{ */
42 
43 /**
44  * constructs the space of <tt>phmd</tt> <tt>PHMDVectorSequence *phmdVS</tt>, given a
45  * HOUGHPeakGramVector *pgV and HOUGHptfLUTVector *lutV.
46  * The minimum frequency bin present corresponds to <tt>phmdVS->fBinMin</tt> and the
47  * total number of different frequencies is
48  * <tt>phmdVS->nfSize</tt>. At this moment the \c fBinMin line corresponds to the
49  * first row of the cylinder and <tt>phmdVS->breakLine</tt> is set to zero.
50  * <tt>phmdVS->breakLine</tt>
51  * \f$ \in\, [0, \f$ \c nfSize) is <em>the pointer</em> which
52  * identifies the position of the \c fBinMin row in the circular-cylinder buffer.
53  */
54 void LALHOUGHConstructSpacePHMD (LALStatus *status, /**< pointer to LALStatus structure */
55  PHMDVectorSequence *phmdVS, /**< Cylindrical buffer of PHMDs */
56  HOUGHPeakGramVector *pgV, /**< Vetor of peakgrams */
57  HOUGHptfLUTVector *lutV /**< vector of look up tables */)
58 {
59 
60  UINT4 k,j;
61  UINT4 nfSize; /* number of different frequencies */
62  UINT4 length; /* number of elements for each frequency */
63  UINT8 fBinMin; /* present minimum frequency bin */
64  UINT8 fBin; /* present frequency bin */
65 
66 
67  /* --------------------------------------------- */
68  INITSTATUS(status);
69  ATTATCHSTATUSPTR (status);
70 
71 
72  /* Make sure the arguments are not NULL: */
73  ASSERT (phmdVS, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
74  ASSERT (pgV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
75  ASSERT (lutV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
76  /* ------------------------------------------- */
77 
78  ASSERT (phmdVS->phmd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
79  ASSERT (pgV->pg, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
80  ASSERT (lutV->lut, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
81  /* ------------------------------------------- */
82 
83  /* Make sure there is no size mismatch */
84  ASSERT (pgV->length == lutV->length, status,
85  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
86  ASSERT (pgV->length == phmdVS->length, status,
87  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
88  /* ------------------------------------------- */
89 
90  /* Make sure there are elements to be computed*/
91  ASSERT (phmdVS->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
92  ASSERT (phmdVS->nfSize, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
93 
94  /* at the beggining, the fBinMin line corresponds to the first row */
95  phmdVS->breakLine = 0; /* mark [0,nfSize) (of the circular buffer)
96  pointing to the starting of the fBinMin line */
97 
98  length = phmdVS->length;
99  nfSize = phmdVS->nfSize;
100  fBinMin = phmdVS->fBinMin;
101  phmdVS->deltaF = lutV->lut[0].deltaF; /* frequency resolution */
102 
103  for ( k=0; k<length; ++k ){
104 
105  /* make sure all deltaF are consistent */
106  ASSERT (phmdVS->deltaF == lutV->lut[k].deltaF,
107  status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
108 
109  fBin = fBinMin;
110 
111  for ( j=0; j< nfSize; ++j ){
112  phmdVS->phmd[ j*length+k ].fBin = fBin;
113 
114  TRY( LALHOUGHPeak2PHMD(status->statusPtr,
115  &(phmdVS->phmd[ j*length+k ]),
116  &(lutV->lut[k]), &(pgV->pg[k]) ), status);
117  ++fBin;
118  }
119  }
120 
121 
122  DETATCHSTATUSPTR (status);
123  /* normal exit */
124  RETURN (status);
125 }
126 
127 /**
128  * This function updates the space of <tt>phmd</tt> increasing the frequency <tt>phmdVS->fBinMin</tt> by one.
129  */
130 void LALHOUGHupdateSpacePHMDup (LALStatus *status,
131  PHMDVectorSequence *phmdVS,
132  HOUGHPeakGramVector *pgV,
133  HOUGHptfLUTVector *lutV)
134 {
135  UINT4 k,breakLine;
136  UINT4 nfSize; /* number of different frequencies */
137  UINT4 length; /* number of elements for each frequency */
138  UINT8 fBinMin; /* minimum frequency bin */
139  UINT8 fBin; /* present frequency bin */
140 
141 
142  /* --------------------------------------------- */
143  INITSTATUS(status);
144  ATTATCHSTATUSPTR (status);
145 
146 
147  /* Make sure the arguments are not NULL: */
148  ASSERT (phmdVS, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
149  ASSERT (pgV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
150  ASSERT (lutV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
151  /* ------------------------------------------- */
152 
153  ASSERT (phmdVS->phmd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
154  ASSERT (pgV->pg, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
155  ASSERT (lutV->lut, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
156  /* ------------------------------------------- */
157 
158  /* Make sure there is no size mismatch */
159  ASSERT (pgV->length == lutV->length, status,
160  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
161  ASSERT (pgV->length == phmdVS->length, status,
162  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
163  /* ------------------------------------------- */
164 
165  /* Make sure there are elements to be computed*/
166  ASSERT (phmdVS->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
167  ASSERT (phmdVS->nfSize, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
168  /* ------------------------------------------- */
169 
170 
171  length = phmdVS->length;
172  nfSize = phmdVS->nfSize;
173 
174  breakLine = phmdVS->breakLine; /* old Break Line */
175  fBinMin = phmdVS->fBinMin; /* initial frequency value */
176 
177  /* Make sure initial breakLine is in [0,nfSize) */
178  ASSERT ( breakLine < nfSize, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
179 
180  /* ------------------------------------------- */
181 
182  /* Updating the space of PHMD increasing frequency */
183 
184  fBin = fBinMin + nfSize;
185 
186  for ( k=0; k<length; ++k ){
187  /* make sure all deltaF are consistent */
188  ASSERT (phmdVS->deltaF == lutV->lut[k].deltaF,
189  status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
190 
191  phmdVS->phmd[ breakLine*length+k ].fBin = fBin;
192  TRY( LALHOUGHPeak2PHMD(status->statusPtr,
193  &(phmdVS->phmd[ breakLine*length+k ]),
194  &(lutV->lut[k]), &(pgV->pg[k]) ), status);
195  }
196 
197  /* Shift fBinMin and its mark */
198  ++phmdVS->fBinMin;
199 
200  phmdVS->breakLine = (breakLine +1) % nfSize;
201  /* mark [0,nfSize) (of the circular buffer, modulus nfSize)
202  pointing to the starting of the new fBinMin line */
203 
204  DETATCHSTATUSPTR (status);
205  /* normal exit */
206  RETURN (status);
207 }
208 
209 
210 /**
211  * Function for shifting the cylindrical buffer of PHMDs down by one
212  * frequency bin -- the highest frequency bin is dropped and an
213  * extra frequency bin is added at the lowest frequency
214  */
215 void LALHOUGHupdateSpacePHMDdn (LALStatus *status,
216  PHMDVectorSequence *phmdVS,
217  HOUGHPeakGramVector *pgV,
218  HOUGHptfLUTVector *lutV)
219 {
220  UINT4 k,breakLine;
221  UINT4 nfSize; /* number of different frequencies */
222  UINT4 length; /* number of elements for each frequency */
223 
224  UINT8 fBin; /* present frequency bin */
225 
226  /* --------------------------------------------- */
227  INITSTATUS(status);
228  ATTATCHSTATUSPTR (status);
229 
230 
231  /* Make sure the arguments are not NULL: */
232  ASSERT (phmdVS, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
233  ASSERT (pgV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
234  ASSERT (lutV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
235  /* ------------------------------------------- */
236 
237  ASSERT (phmdVS->phmd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
238  ASSERT (pgV->pg, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
239  ASSERT (lutV->lut, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
240  /* ------------------------------------------- */
241 
242  /* Make sure there is no size mismatch */
243  ASSERT (pgV->length == lutV->length, status,
244  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
245  ASSERT (pgV->length == phmdVS->length, status,
246  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
247  /* ------------------------------------------- */
248 
249  /* Make sure there are elements to be computed*/
250  ASSERT (phmdVS->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
251  ASSERT (phmdVS->nfSize, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
252  /* ------------------------------------------- */
253 
254  length = phmdVS->length;
255  nfSize = phmdVS->nfSize;
256 
257  breakLine = phmdVS->breakLine; /* old Break Line */
258 
259  /* Make sure initial breakLine is in [0,nfSize) */
260  ASSERT ( breakLine < nfSize, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
261 
262  /* ------------------------------------------- */
263 
264  /* Updating the space of PHMD decreasing frequency */
265 
266  /* Shift fBinMin and its mark */
267  fBin = --phmdVS->fBinMin; /* initial frequency value */
268 
269  phmdVS->breakLine = (breakLine + nfSize- 1) % nfSize;
270  /* mark [0,nfSize) (of the circular buffer, modulus nfSize)
271  pointing to the starting of the new fBinMin line */
272 
273  breakLine = phmdVS->breakLine; /* the new Break Line */
274 
275  for ( k=0; k<length; ++k ){
276  /* make sure all deltaF are consistent */
277  ASSERT (phmdVS->deltaF == lutV->lut[k].deltaF,
278  status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
279 
280  phmdVS->phmd[ breakLine*length+k ].fBin = fBin;
281  TRY( LALHOUGHPeak2PHMD(status->statusPtr,
282  &(phmdVS->phmd[ breakLine*length+k ]),
283  &(lutV->lut[k]), &(pgV->pg[k]) ), status);
284  }
285 
286 
287 
288  DETATCHSTATUSPTR (status);
289  /* normal exit */
290  RETURN (status);
291 }
292 
293 
294 /**
295  * Given PHMDVectorSequence *phmdVS, the space of \c phmd, and
296  * UINT8FrequencyIndexVector *freqInd, a structure containing the frequency
297  * indices of the \c phmd at different time stamps that have to be combined
298  * to form a Hough map, the function LALHOUGHConstructHMT() produces the
299  * total Hough map.
300  */
301 void LALHOUGHConstructHMT (LALStatus *status, /**< pointer to LALStatus structure */
302  HOUGHMapTotal *ht, /**< The output hough map */
303  UINT8FrequencyIndexVector *freqInd,/**< time-frequency trajectory */
304  PHMDVectorSequence *phmdVS /**< set of partial hough map derivatives */)
305 {
306 
307 
308  UINT4 k,j;
309  UINT4 breakLine;
310  UINT4 nfSize; /* number of different frequencies */
311  UINT4 length; /* number of elements for each frequency */
312  UINT8 fBinMin; /* present minimum frequency bin */
313  INT8 fBin; /* present frequency bin */
314  UINT2 xSide,ySide;
315 
316  HOUGHMapDeriv hd; /* the Hough map derivative */
317 
318  /* --------------------------------------------- */
319  INITSTATUS(status);
320  ATTATCHSTATUSPTR (status);
321 
322  /* Make sure the arguments are not NULL: */
323  ASSERT (phmdVS, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
324  ASSERT (ht, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
325  ASSERT (freqInd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
326  /* ------------------------------------------- */
327 
328  ASSERT (phmdVS->phmd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
329  ASSERT (freqInd->data, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
330  /* ------------------------------------------- */
331 
332  /* Make sure there is no size mismatch */
333  ASSERT (freqInd->length == phmdVS->length, status,
334  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
335  ASSERT (freqInd->deltaF == phmdVS->deltaF, status,
336  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
337  /* ------------------------------------------- */
338 
339  /* Make sure there are elements */
340  ASSERT (phmdVS->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
341  ASSERT (phmdVS->nfSize, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
342  /* ------------------------------------------- */
343 
344  /* Make sure the ht map contains some pixels */
345  ASSERT (ht->xSide, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
346  ASSERT (ht->ySide, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
347 
348  length = phmdVS->length;
349  nfSize = phmdVS->nfSize;
350 
351  fBinMin = phmdVS->fBinMin; /* initial frequency value od the cilinder*/
352 
353  breakLine = phmdVS->breakLine;
354 
355  /* number of physical pixels */
356  xSide = ht->xSide;
357  ySide = ht->ySide;
358 
359  /* Make sure initial breakLine is in [0,nfSize) */
360  ASSERT ( breakLine < nfSize, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
361 
362  /* ------------------------------------------- */
363 
364  /* Initializing hd map and memory allocation */
365  hd.xSide = xSide;
366  hd.ySide = ySide;
367  hd.map = (HoughDT *)LALMalloc(ySide*(xSide+1)*sizeof(HoughDT));
368  if (hd. map == NULL) {
369  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
370  }
371  /* ------------------------------------------- */
372 
373 
374  TRY( LALHOUGHInitializeHD(status->statusPtr, &hd), status);
375  for ( k=0; k<length; ++k ){
376  /* read the frequency index and make sure is in the proper interval*/
377  fBin =freqInd->data[k] -fBinMin;
378 
379  ASSERT ( fBin < nfSize, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
380  ASSERT ( fBin >= 0, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
381 
382  /* find index */
383  j = (fBin + breakLine) % nfSize;
384 
385  /* Add the corresponding PHMD to HD */
386  TRY( LALHOUGHAddPHMD2HD(status->statusPtr,
387  &hd, &(phmdVS->phmd[j*length+k]) ), status);
388  }
389 
390  TRY( LALHOUGHIntegrHD2HT(status->statusPtr, ht, &hd), status);
391 
392  /* Free memory and exit */
393  LALFree(hd.map);
394 
395  DETATCHSTATUSPTR (status);
396  /* normal exit */
397  RETURN (status);
398 }
399 
400 
401 
402 /**
403  * This function computes the corresponding frequency bin of
404  * a \c phmd <tt>UINT8 *fBinMap</tt> for a given intrinsic
405  * frequency bin of a source <tt>UINT8 *f0Bin</tt>, and information regarding the
406  * time and the residual spin down parameters HOUGHResidualSpinPar *rs.
407  */
408 void LALHOUGHComputeFBinMap (LALStatus *status,
409  UINT8 *fBinMap,
410  UINT8 *f0Bin,
411  HOUGHResidualSpinPar *rs)
412 {
413 
414  UINT4 i;
415  INT4 shiftFBin;
416  REAL8 shiftF;
417 
418  UINT4 spinOrder;
419  REAL8 *spinF;
420  REAL8 timeDiff; /* T(t)-T(t0) */
421  REAL8 timeDiffProd;
422  REAL8 deltaF; /* df=1/TCOH */
423  /* --------------------------------------------- */
424  INITSTATUS(status);
425  ATTATCHSTATUSPTR (status);
426 
427  /* Make sure the arguments are not NULL: */
428  ASSERT (fBinMap, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
429  ASSERT (f0Bin, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
430  ASSERT (rs, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
431  /* ------------------------------------------- */
432 
433  /* Make sure the Input/Output pointers are not the same */
434  ASSERT (fBinMap != f0Bin, status, LALHOUGHH_ESAME, LALHOUGHH_MSGESAME);
435 
436  shiftFBin = 0;
437  shiftF = 0.0;
438 
439  spinOrder = rs->spinRes.length;
440 
441  if(spinOrder){
442  ASSERT (rs->spinRes.data , status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
443  timeDiff = rs->timeDiff;
444  timeDiffProd = timeDiff;
445 
446  deltaF = rs->deltaF;
447  spinF = rs->spinRes.data;
448 
449  for (i=0; i<spinOrder; ++i ){
450  shiftF += spinF[i] * timeDiffProd;
451  timeDiffProd *= timeDiff;
452  }
453  shiftFBin = rint( shiftF/deltaF) ; /* positive or negative */
454  }
455 
456  *fBinMap = *f0Bin + shiftFBin;
457 
458  DETATCHSTATUSPTR (status);
459  /* normal exit */
460  RETURN (status);
461 }
462 
463 
464 
465 
466 
467 /**
468  * Calculates the total hough map for a given trajectory in the
469  * time-frequency plane and a set of partial hough map derivatives allowing
470  * each PHMD to have a different weight factor to account for varying
471  * sensitivity at different sky-locations.
472  */
473 
474 void LALHOUGHConstructHMT_W (LALStatus *status, /**< pointer to LALStatus structure */
475  HOUGHMapTotal *ht, /**< The output hough map */
476  UINT8FrequencyIndexVector *freqInd, /**< time-frequency trajectory */
477  PHMDVectorSequence *phmdVS /**< set of partial hough map derivatives */)
478 {
479 
480 
481  UINT4 k,j;
482  UINT4 breakLine;
483  UINT4 nfSize; /* number of different frequencies */
484  UINT4 length; /* number of elements for each frequency */
485  UINT8 fBinMin; /* present minimum frequency bin */
486  INT8 fBin; /* present frequency bin */
487  UINT2 xSide,ySide;
488 
489  HOUGHMapDeriv hd; /* the Hough map derivative */
490 
491  /* --------------------------------------------- */
492  INITSTATUS(status);
493  ATTATCHSTATUSPTR (status);
494 
495  /* Make sure the arguments are not NULL: */
496  ASSERT (phmdVS, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
497  ASSERT (ht, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
498  ASSERT (freqInd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
499  /* ------------------------------------------- */
500 
501  ASSERT (phmdVS->phmd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
502  ASSERT (freqInd->data, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
503  /* ------------------------------------------- */
504 
505  /* Make sure there is no size mismatch */
506  ASSERT (freqInd->length == phmdVS->length, status,
507  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
508  ASSERT (freqInd->deltaF == phmdVS->deltaF, status,
509  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
510  /* ------------------------------------------- */
511 
512  /* Make sure there are elements */
513  ASSERT (phmdVS->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
514  ASSERT (phmdVS->nfSize, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
515  /* ------------------------------------------- */
516 
517  /* Make sure the ht map contains some pixels */
518  ASSERT (ht->xSide, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
519  ASSERT (ht->ySide, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
520 
521  length = phmdVS->length;
522  nfSize = phmdVS->nfSize;
523 
524  fBinMin = phmdVS->fBinMin; /* initial frequency value od the cilinder*/
525 
526  breakLine = phmdVS->breakLine;
527 
528  /* number of physical pixels */
529  xSide = ht->xSide;
530  ySide = ht->ySide;
531 
532  /* Make sure initial breakLine is in [0,nfSize) */
533  ASSERT ( breakLine < nfSize, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
534 
535  /* ------------------------------------------- */
536 
537  /* Initializing hd map and memory allocation */
538  hd.xSide = xSide;
539  hd.ySide = ySide;
540  hd.map = (HoughDT *)LALMalloc(ySide*(xSide+1)*sizeof(HoughDT));
541  if (hd. map == NULL) {
542  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
543  }
544 
545  /* ------------------------------------------- */
546 
547  TRY( LALHOUGHInitializeHD(status->statusPtr, &hd), status);
548  for ( k=0; k<length; ++k ){
549  /* read the frequency index and make sure is in the proper interval*/
550  fBin =freqInd->data[k] -fBinMin;
551 
552  ASSERT ( fBin < nfSize, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
553  ASSERT ( fBin >= 0, status, LALHOUGHH_EVAL, LALHOUGHH_MSGEVAL);
554 
555  /* find index */
556  j = (fBin + breakLine) % nfSize;
557 
558  /* Add the corresponding PHMD to HD */
559  TRY( LALHOUGHAddPHMD2HD_W(status->statusPtr,
560  &hd, &(phmdVS->phmd[j*length+k]) ), status);
561  }
562 
563  TRY( LALHOUGHIntegrHD2HT(status->statusPtr, ht, &hd), status);
564 
565  /* Free memory and exit */
566  LALFree(hd.map);
567 
568  DETATCHSTATUSPTR (status);
569  /* normal exit */
570  RETURN (status);
571 }
572 
573 
574 
575 /**
576  * Adds weight factors for set of partial hough map derivatives -- the
577  * weights must be calculated outside this function.
578  */
579 
580 void LALHOUGHWeighSpacePHMD (LALStatus *status, /**< pointer to LALStatus structure */
581  PHMDVectorSequence *phmdVS, /**< partial hough map derivatives */
582  REAL8Vector *weightV /**< vector of weights */)
583 {
584 
585  UINT4 k,j;
586  UINT4 nfSize; /* number of different frequencies */
587  UINT4 length; /* number of elements for each frequency */
588  /* --------------------------------------------- */
589 
590  INITSTATUS(status);
591  ATTATCHSTATUSPTR (status);
592 
593 
594  /* Make sure the arguments are not NULL: */
595  ASSERT (phmdVS, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
596  ASSERT (weightV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
597  /* ------------------------------------------- */
598 
599  ASSERT (phmdVS->phmd, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
600  ASSERT (weightV->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
601  /* ------------------------------------------- */
602 
603  /* Make sure there is no size mismatch */
604  ASSERT (weightV->length == phmdVS->length, status,
605  LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
606  /* ------------------------------------------- */
607 
608  /* Make sure there are elements to be computed*/
609  ASSERT (phmdVS->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
610  ASSERT (phmdVS->nfSize, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
611 
612 
613  length = phmdVS->length;
614  nfSize = phmdVS->nfSize;
615 
616  /* weigh the phmds according to weightV */
617  for ( k=0; k<length; ++k ){
618  for ( j=0; j< nfSize; ++j ){
619  phmdVS->phmd[ j*length+k ].weight = (HoughDT)weightV->data[k];
620  }
621  }
622 
623 
624  DETATCHSTATUSPTR (status);
625  /* normal exit */
626  RETURN (status);
627 }
628 
629 
630 
631 /** Initializes weight factors to unity */
632 
633 void LALHOUGHInitializeWeights (LALStatus *status, /**< pointer to LALStatus structure */
634  REAL8Vector *weightV /**< vector of weights */)
635 {
636 
637  UINT4 j, length;
638 
639  /* --------------------------------------------- */
640  INITSTATUS(status);
641  ATTATCHSTATUSPTR (status);
642 
643 
644  /* Make sure the arguments are not NULL: */
645  ASSERT (weightV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
646  ASSERT (weightV->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
647  /* ------------------------------------------- */
648 
649  /* Make sure there are elements to be computed*/
650  ASSERT (weightV->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
651 
652  length = weightV->length;
653 
654  for (j=0; j<length; j++) {
655  weightV->data[j] = 1.0;
656  }
657 
658  DETATCHSTATUSPTR (status);
659  /* normal exit */
660  RETURN (status);
661 }
662 
663 
664 
665 
666 /** Normalizes weight factors so that their sum is N */
667 
668 void LALHOUGHNormalizeWeights (LALStatus *status, /**< pointer to LALStatus structure */
669  REAL8Vector *weightV /**< vector of weights */)
670 {
671 
672  UINT4 j, length;
673  REAL8 sum;
674 
675  /* --------------------------------------------- */
676  INITSTATUS(status);
677  ATTATCHSTATUSPTR (status);
678 
679 
680  /* Make sure the arguments are not NULL: */
681  ASSERT (weightV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
682  ASSERT (weightV->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
683  /* ------------------------------------------- */
684 
685  /* Make sure there are elements to be computed*/
686  ASSERT (weightV->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
687 
688  length = weightV->length;
689 
690  /* calculate sum of weights */
691  sum = 0.0;
692  for (j=0; j<length; j++) {
693  sum += weightV->data[j];
694  }
695 
696  /* normalize weights */
697  for (j=0; j<length; j++) {
698  weightV->data[j] *= length/sum;
699  }
700 
701  DETATCHSTATUSPTR (status);
702  /* normal exit */
703  RETURN (status);
704 }
705 
706 
707 
708 /**
709  * Computes weight factors arising from amplitude modulation -- it multiplies
710  * an existing weight vector
711  */
712 void LALHOUGHComputeAMWeights (LALStatus *status,
713  REAL8Vector *weightV,
714  LIGOTimeGPSVector *timeV,
715  LALDetector *detector,
716  EphemerisData *edat,
717  REAL8 alpha,
718  REAL8 delta)
719 {
720 
721  UINT4 length, j;
722 
723  /* amplitude modulation stuff */
724  REAL4Vector *aVec, *bVec;
725  REAL8 A, B, a, b;
726  AMCoeffs XLAL_INIT_DECL(amc);
727  AMCoeffsParams *amParams;
728  EarthState earth;
729  BarycenterInput baryinput;
730 
731  /* --------------------------------------------- */
732  INITSTATUS(status);
733  ATTATCHSTATUSPTR (status);
734 
735 
736  /* Make sure the arguments are not NULL: */
737  ASSERT (weightV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
738  ASSERT (timeV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
739  ASSERT (detector, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
740  ASSERT (edat, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
741 
742  ASSERT (weightV->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
743  ASSERT (timeV->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
744  /* ------------------------------------------- */
745 
746  /* Make sure there is no size mismatch */
747  ASSERT (weightV->length == timeV->length, status, LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
748  /* ------------------------------------------- */
749 
750  /* Make sure there are elements to be computed*/
751  ASSERT (timeV->length, status, LALHOUGHH_ESIZE, LALHOUGHH_MSGESIZE);
752 
753  length = timeV->length;
754 
755 
756  /* detector location */
757  baryinput.site.location[0] = detector->location[0]/LAL_C_SI;
758  baryinput.site.location[1] = detector->location[1]/LAL_C_SI;
759  baryinput.site.location[2] = detector->location[2]/LAL_C_SI;
760  baryinput.dInv = 0.e0;
761 
762  /* alpha and delta must come from the skypatch */
763  /* for now set it to something arbitrary */
764  /* baryinput.alpha = 0.0; */
765  /* baryinput.delta = 0.0; */
766 
767  baryinput.alpha = alpha;
768  baryinput.delta = delta;
769 
770  /* Allocate space for amParams stucture */
771  /* Here, amParams->das is the Detector and Source info */
772  amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams));
773  if (amParams == NULL) {
774  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
775  }
776 
777  amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
778  if (amParams->das == NULL) {
779  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
780  }
781 
782  amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
783  if (amParams->das->pSource == NULL) {
784  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
785  }
786 
787  /* Fill up AMCoeffsParams structure */
788  amParams->baryinput = &baryinput;
789  amParams->earth = &earth;
790  amParams->edat = edat;
791  amParams->das->pDetector = detector;
792  /* make sure alpha and delta are correct */
793  amParams->das->pSource->equatorialCoords.latitude = baryinput.delta;
794  amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha;
795  amParams->das->pSource->orientation = 0.0;
796  amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
797  amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/
798 
799  /* allocate memory for a[i] and b[i] */
800  /* TRY( LALSCreateVector( status, &(amc.a), length), status); */
801  /* TRY( LALSCreateVector( status, &(amc.b), length), status); */
802 
803  amc.a = NULL;
804  amc.a = (REAL4Vector *)LALMalloc(sizeof(REAL4Vector));
805  if (amc.a == NULL) {
806  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
807  }
808 
809  amc.a->length = length;
810  amc.a->data = (REAL4 *)LALMalloc(length*sizeof(REAL4));
811  if (amc.a->data == NULL) {
812  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
813  }
814 
815  amc.b = NULL;
816  amc.b = (REAL4Vector *)LALMalloc(sizeof(REAL4Vector));
817  if (amc.b == NULL) {
818  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
819  }
820 
821  amc.b->length = length;
822  amc.b->data = (REAL4 *)LALMalloc(length*sizeof(REAL4));
823  if (amc.b->data == NULL) {
824  ABORT( status, LALHOUGHH_EMEM, LALHOUGHH_MSGEMEM);
825  }
826 
827  TRY (LALComputeAM( status->statusPtr, &amc, timeV->data, amParams), status);
828  aVec = amc.a; /* a and b are as defined in JKS */
829  bVec = amc.b;
830  A = amc.A; /* note A is twice average of a[i]^2 */
831  B = amc.B; /* note B is twice average of b[i]^2 */
832 
833  for(j=0; j<length; j++){
834  a = aVec->data[j];
835  b = bVec->data[j];
836  weightV->data[j] *= 2.0*(a*a + b*b)/(A+B);
837  }
838 
839  /* normalize weights */
840  TRY( LALHOUGHNormalizeWeights( status->statusPtr, weightV ), status);
841 
842  /* TRY( LALSDestroyVector( status, &(amc.a)), status); */
843  /* TRY( LALSDestroyVector( status, &(amc.b)), status); */
844  LALFree(amc.a->data);
845  LALFree(amc.b->data);
846  LALFree(amc.a);
847  LALFree(amc.b);
848 
849  LALFree(amParams->das->pSource);
850  LALFree(amParams->das);
851  LALFree(amParams);
852 
853  DETATCHSTATUSPTR (status);
854  /* normal exit */
855  RETURN (status);
856 }
857 
858 
859 
860 
861 /**
862  * Computes weight factors arising from amplitude modulation -- it multiplies
863  * an existing weight vector
864  */
865 void LALHOUGHComputeMultiIFOAMWeights (LALStatus *status,
866  REAL8Vector *weightV,
867  SFTCatalog *catalog,
868  EphemerisData *edat,
869  REAL8 UNUSED alpha,
870  REAL8 UNUSED delta)
871 {
872 
873  /* --------------------------------------------- */
874  INITSTATUS(status);
875  ATTATCHSTATUSPTR (status);
876 
877  ASSERT (weightV, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
878  ASSERT (catalog, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
879  ASSERT (edat, status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
880 
881  ASSERT (weightV->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
882  ASSERT (catalog->data,status, LALHOUGHH_ENULL, LALHOUGHH_MSGENULL);
883 
884  /* Make sure there is no size mismatch */
885  ASSERT (weightV->length == catalog->length, status, LALHOUGHH_ESZMM, LALHOUGHH_MSGESZMM);
886 
887  (void)weightV;
888  (void)catalog;
889  (void)edat;
890 
891  DETATCHSTATUSPTR (status);
892  /* normal exit */
893  RETURN (status);
894 }
895 
896 
897 /**
898  * Original antenna-pattern function by S Berukoff
899  */
900 void LALComputeAM (LALStatus *status,
901  AMCoeffs *coe,
902  LIGOTimeGPS *ts,
903  AMCoeffsParams *params)
904 {
905 
906  REAL4 zeta; /* sine of angle between detector arms */
907  INT4 i; /* temporary loop index */
908  LALDetAMResponse response; /* output of LALComputeDetAMResponse */
909 
910  REAL4 sumA2=0.0;
911  REAL4 sumB2=0.0;
912  REAL4 sumAB=0.0; /* variables to store scalar products */
913  INT4 length=coe->a->length; /* length of input time series */
914 
915  REAL4 cos2psi;
916  REAL4 sin2psi; /* temp variables */
917 
918  INITSTATUS(status);
919  ATTATCHSTATUSPTR(status);
920 
921  /* Must put an ASSERT checking that ts vec and coe vec are same length */
922 
923  /* Compute the angle between detector arms, then the reciprocal */
924  {
925  LALFrDetector det = params->das->pDetector->frDetector;
926  zeta = 1.0/(sin(det.xArmAzimuthRadians - det.yArmAzimuthRadians));
927  if(params->das->pDetector->type == LALDETECTORTYPE_CYLBAR) zeta=1.0;
928  }
929 
930  cos2psi = cos(2.0 * params->polAngle);
931  sin2psi = sin(2.0 * params->polAngle);
932 
933  /* Note the length is the same for the b vector */
934  for(i=0; i<length; ++i)
935  {
936  REAL4 *a = coe->a->data;
937  REAL4 *b = coe->b->data;
938 
939  /* Compute F_plus, F_cross */
940  LALComputeDetAMResponse(status->statusPtr, &response, params->das, &ts[i]);
941 
942  /* Compute a, b from JKS eq 10,11
943  * a = zeta * (F_plus*cos(2\psi)-F_cross*sin(2\psi))
944  * b = zeta * (F_cross*cos(2\psi)+Fplus*sin(2\psi))
945  */
946  a[i] = zeta * (response.plus*cos2psi-response.cross*sin2psi);
947  b[i] = zeta * (response.cross*cos2psi+response.plus*sin2psi);
948 
949  /* Compute scalar products */
950  sumA2 += SQ(a[i]); /* A */
951  sumB2 += SQ(b[i]); /* B */
952  sumAB += (a[i]) * (b[i]); /* C */
953  }
954 
955  {
956  /* Normalization factor */
957  REAL8 L = 2.0/(REAL8)length;
958 
959  /* Assign output values and normalise */
960  coe->A = L*sumA2;
961  coe->B = L*sumB2;
962  coe->C = L*sumAB;
963  coe->D = ( coe->A * coe->B - SQ(coe->C) );
964  /* protection against case when AB=C^2 */
965  if(coe->D == 0) coe->D=1.0e-9;
966  }
967 
968  /* Normal exit */
969 
970  DETATCHSTATUSPTR(status);
971  RETURN(status);
972 
973 } /* LALComputeAM() */
974 
975 /** @} */
SQ
#define SQ(x)
Definition: DriveHough.c:36
zeta
REAL8 zeta
j
int j
k
int k
LALMalloc
#define LALMalloc(n)
LALFree
#define LALFree(p)
delta
static double double delta
ABORT
#define ABORT(statusptr, code, mesg)
TRY
#define TRY(func, statusptr)
ATTATCHSTATUSPTR
#define ATTATCHSTATUSPTR(statusptr)
ASSERT
#define ASSERT(assertion, statusptr, code, mesg)
DETATCHSTATUSPTR
#define DETATCHSTATUSPTR(statusptr)
INITSTATUS
#define INITSTATUS(statusptr)
RETURN
#define RETURN(statusptr)
L
#define L(i, j)
A
UINT2 A
Definition: SFTnaming.c:46
B
UINT2 B
Definition: SFTnaming.c:47
amc
AMCoeffs amc
Definition: SemiAnalyticF.c:111
LALComputeDetAMResponse
void LALComputeDetAMResponse(LALStatus *status, LALDetAMResponse *pResponse, const LALDetAndSource *pDetAndSrc, const LIGOTimeGPS *gps)
LALHOUGHAddPHMD2HD_W
void LALHOUGHAddPHMD2HD_W(LALStatus *status, HOUGHMapDeriv *hd, HOUGHphmd *phmd)
Adds a hough map derivative into a total hough map derivative taking into account the weight of the p...
Definition: HoughMap.c:231
LALHOUGHInitializeHD
void LALHOUGHInitializeHD(LALStatus *status, HOUGHMapDeriv *hd)
This function initializes the Hough map derivative space HOUGHMapDeriv *hd to zero.
Definition: HoughMap.c:31
LALHOUGHAddPHMD2HD
void LALHOUGHAddPHMD2HD(LALStatus *status, HOUGHMapDeriv *hd, HOUGHphmd *phmd)
Given an initial Hough map derivative HOUGHMapDeriv *hd and a representation of a phmd HOUGHphmd *phm...
Definition: HoughMap.c:123
LALHOUGHIntegrHD2HT
void LALHOUGHIntegrHD2HT(LALStatus *status, HOUGHMapTotal *ht, HOUGHMapDeriv *hd)
This function constructs a total Hough map HOUGHMapTotal *ht from its derivative HOUGHMapDeriv *hd by...
Definition: HoughMap.c:353
UINT8
uint64_t UINT8
REAL8
double REAL8
XLAL_INIT_DECL
#define XLAL_INIT_DECL(var,...)
INT8
int64_t INT8
UINT2
uint16_t UINT2
UINT4
uint32_t UINT4
INT4
int32_t INT4
REAL4
float REAL4
LALDETECTORTYPE_CYLBAR
LALDETECTORTYPE_CYLBAR
LALComputeAM
static void LALComputeAM(LALStatus *, AMCoeffs *coe, LIGOTimeGPS *ts, AMCoeffsParams *params)
Original antenna-pattern function by S Berukoff.
Definition: DriveHough.c:900
LALHOUGHH_EVAL
#define LALHOUGHH_EVAL
Definition: LALHough.h:116
LALHOUGHConstructHMT_W
void LALHOUGHConstructHMT_W(LALStatus *status, HOUGHMapTotal *ht, UINT8FrequencyIndexVector *freqInd, PHMDVectorSequence *phmdVS)
Calculates the total hough map for a given trajectory in the time-frequency plane and a set of partia...
Definition: DriveHough.c:474
LALHOUGHH_MSGESZMM
#define LALHOUGHH_MSGESZMM
Definition: LALHough.h:121
LALHOUGHH_MSGESIZE
#define LALHOUGHH_MSGESIZE
Definition: LALHough.h:120
LALHOUGHH_ESZMM
#define LALHOUGHH_ESZMM
Definition: LALHough.h:112
LALHOUGHH_MSGEMEM
#define LALHOUGHH_MSGEMEM
Definition: LALHough.h:126
LALHOUGHH_ESAME
#define LALHOUGHH_ESAME
Definition: LALHough.h:114
LALHOUGHConstructSpacePHMD
void LALHOUGHConstructSpacePHMD(LALStatus *status, PHMDVectorSequence *phmdVS, HOUGHPeakGramVector *pgV, HOUGHptfLUTVector *lutV)
constructs the space of phmd PHMDVectorSequence *phmdVS, given a HOUGHPeakGramVector *pgV and HOUGHpt...
Definition: DriveHough.c:54
LALHOUGHupdateSpacePHMDdn
void LALHOUGHupdateSpacePHMDdn(LALStatus *status, PHMDVectorSequence *phmdVS, HOUGHPeakGramVector *pgV, HOUGHptfLUTVector *lutV)
Function for shifting the cylindrical buffer of PHMDs down by one frequency bin – the highest frequen...
Definition: DriveHough.c:215
LALHOUGHH_MSGESAME
#define LALHOUGHH_MSGESAME
Definition: LALHough.h:123
LALHOUGHNormalizeWeights
void LALHOUGHNormalizeWeights(LALStatus *status, REAL8Vector *weightV)
Normalizes weight factors so that their sum is N.
Definition: DriveHough.c:668
LALHOUGHH_ENULL
#define LALHOUGHH_ENULL
Definition: LALHough.h:110
LALHOUGHH_MSGENULL
#define LALHOUGHH_MSGENULL
Definition: LALHough.h:119
LALHOUGHComputeFBinMap
void LALHOUGHComputeFBinMap(LALStatus *status, UINT8 *fBinMap, UINT8 *f0Bin, HOUGHResidualSpinPar *rs)
This function computes the corresponding frequency bin of a phmd UINT8 *fBinMap for a given intrinsic...
Definition: DriveHough.c:408
LALHOUGHComputeAMWeights
void LALHOUGHComputeAMWeights(LALStatus *status, REAL8Vector *weightV, LIGOTimeGPSVector *timeV, LALDetector *detector, EphemerisData *edat, REAL8 alpha, REAL8 delta)
Computes weight factors arising from amplitude modulation – it multiplies an existing weight vector.
Definition: DriveHough.c:712
LALHOUGHWeighSpacePHMD
void LALHOUGHWeighSpacePHMD(LALStatus *status, PHMDVectorSequence *phmdVS, REAL8Vector *weightV)
Adds weight factors for set of partial hough map derivatives – the weights must be calculated outside...
Definition: DriveHough.c:580
LALHOUGHInitializeWeights
void LALHOUGHInitializeWeights(LALStatus *status, REAL8Vector *weightV)
Initializes weight factors to unity.
Definition: DriveHough.c:633
LALHOUGHH_MSGEVAL
#define LALHOUGHH_MSGEVAL
Definition: LALHough.h:125
LALHOUGHComputeMultiIFOAMWeights
void LALHOUGHComputeMultiIFOAMWeights(LALStatus *status, REAL8Vector *weightV, SFTCatalog *catalog, EphemerisData *edat, REAL8 UNUSED alpha, REAL8 UNUSED delta)
Computes weight factors arising from amplitude modulation – it multiplies an existing weight vector.
Definition: DriveHough.c:865
LALHOUGHupdateSpacePHMDup
void LALHOUGHupdateSpacePHMDup(LALStatus *status, PHMDVectorSequence *phmdVS, HOUGHPeakGramVector *pgV, HOUGHptfLUTVector *lutV)
This function updates the space of phmd increasing the frequency phmdVS->fBinMin by one.
Definition: DriveHough.c:130
LALHOUGHH_ESIZE
#define LALHOUGHH_ESIZE
Definition: LALHough.h:111
LALHOUGHH_EMEM
#define LALHOUGHH_EMEM
Definition: LALHough.h:117
LALHOUGHConstructHMT
void LALHOUGHConstructHMT(LALStatus *status, HOUGHMapTotal *ht, UINT8FrequencyIndexVector *freqInd, PHMDVectorSequence *phmdVS)
Given PHMDVectorSequence *phmdVS, the space of phmd, and UINT8FrequencyIndexVector *freqInd,...
Definition: DriveHough.c:301
HoughDT
REAL8 HoughDT
Hough Map derivative pixel type.
Definition: PHMD.h:121
LALHOUGHPeak2PHMD
void LALHOUGHPeak2PHMD(LALStatus *status, HOUGHphmd *phmd, HOUGHptfLUT *lut, HOUGHPeakGram *pg)
Construction of Partial-Hough-Map-Derivatives (phmd) given a peak-gram and the look-up-table.
Definition: Peak2PHMD.c:61
a
static const INT4 a
COORDINATESYSTEM_EQUATORIAL
COORDINATESYSTEM_EQUATORIAL
deltaF
int deltaF
lalpulsar.git_version.status
string status
Definition: git_version.py:32
make_frame_cache.i
int i
Definition: make_frame_cache.py:77
test_computePSD.edat
edat
Definition: test_computePSD.py:65
ts
ts
test_simulateCW.detector
string detector
Definition: test_simulateCW.py:55
test_ssbtodetector.LAL_C_SI
int LAL_C_SI
Definition: test_ssbtodetector.py:9
alpha
double alpha
AMCoeffs
This structure contains the per-SFT (weighted) antenna-pattern functions , with the SFT-index,...
Definition: LALComputeAM.h:63
AMCoeffs::B
REAL4 B
summed antenna-pattern matrix coefficient:
Definition: LALComputeAM.h:67
AMCoeffs::b
REAL4Vector * b
(weighted) per-SFT antenna-pattern function
Definition: LALComputeAM.h:65
AMCoeffs::A
REAL4 A
summed antenna-pattern matrix coefficient:
Definition: LALComputeAM.h:66
AMCoeffs::C
REAL4 C
summed antenna-pattern matrix coefficient:
Definition: LALComputeAM.h:68
AMCoeffs::a
REAL4Vector * a
(weighted) per-SFT antenna-pattern function
Definition: LALComputeAM.h:64
AMCoeffs::D
REAL4 D
determinant
Definition: LALComputeAM.h:69
AMCoeffsParams
This structure contains the parameters for the routine.
Definition: LALComputeAM.h:75
AMCoeffsParams::das
LALDetAndSource * das
det and source information
Definition: LALComputeAM.h:79
AMCoeffsParams::polAngle
REAL4 polAngle
polarization angle
Definition: LALComputeAM.h:81
AMCoeffsParams::earth
EarthState * earth
from XLALBarycenter()
Definition: LALComputeAM.h:77
AMCoeffsParams::edat
EphemerisData * edat
the ephemerides
Definition: LALComputeAM.h:78
AMCoeffsParams::baryinput
BarycenterInput * baryinput
data from Barycentring routine
Definition: LALComputeAM.h:76
BarycenterInput
Basic input structure to LALBarycenter.c.
Definition: LALBarycenter.h:201
BarycenterInput::alpha
REAL8 alpha
Source right ascension in ICRS J2000 coords (radians).
Definition: LALBarycenter.h:214
BarycenterInput::dInv
REAL8 dInv
1/(distance to source), in 1/sec.
Definition: LALBarycenter.h:216
BarycenterInput::delta
REAL8 delta
Source declination in ICRS J2000 coords (radians)
Definition: LALBarycenter.h:215
BarycenterInput::site
LALDetector site
detector site info.
Definition: LALBarycenter.h:208
EarthState
Basic output structure of LALBarycenterEarth.c.
Definition: LALBarycenter.h:167
EphemerisData
This structure contains all information about the center-of-mass positions of the Earth and Sun,...
Definition: LALBarycenter.h:127
HOUGHMapDeriv
This structure stores the Hough map derivative.
Definition: HoughMap.h:121
HOUGHMapDeriv::ySide
UINT2 ySide
number of physical pixels in the y direction
Definition: HoughMap.h:123
HOUGHMapDeriv::xSide
UINT2 xSide
number of physical pixels in the x direction
Definition: HoughMap.h:122
HOUGHMapDeriv::map
HoughDT * map
the pixel count derivatives; the number of elements to allocate is ySide*(xSide+1)*
Definition: HoughMap.h:124
HOUGHMapTotal
This structure stores the Hough map.
Definition: HoughMap.h:130
HOUGHMapTotal::ySide
UINT2 ySide
number of physical pixels in the y direction
Definition: HoughMap.h:142
HOUGHMapTotal::xSide
UINT2 xSide
number of physical pixels in the x direction
Definition: HoughMap.h:141
HOUGHPeakGramVector
This structure contains a vector of peak-grams (for the different time stamps)
Definition: LALHough.h:167
HOUGHPeakGramVector::length
UINT4 length
number of elements
Definition: LALHough.h:168
HOUGHPeakGramVector::pg
HOUGHPeakGram * pg
the Peakgrams
Definition: LALHough.h:169
HOUGHResidualSpinPar
This structure stores the residual spin-down parameters at a given time.
Definition: LALHough.h:199
HOUGHResidualSpinPar::deltaF
REAL8 deltaF
Frequency resolution; df=1/TCOH.
Definition: LALHough.h:200
HOUGHResidualSpinPar::spinRes
REAL8Vector spinRes
length: Maximum order of spdwn parameter *data: pointer to residual Spin parameter set fk
Definition: LALHough.h:202
HOUGHResidualSpinPar::timeDiff
REAL8 timeDiff
: time difference
Definition: LALHough.h:201
HOUGHphmd::fBin
UINT8 fBin
Frequency bin of this partial map derivative.
Definition: PHMD.h:142
HOUGHphmd::weight
HoughDT weight
First column border, containing the edge effects when clipping on a finite patch.
Definition: PHMD.h:152
HOUGHptfLUT::deltaF
REAL8 deltaF
Frequency resolution df=1/TCOH, where 1/TCOH is the coherent integration time used in teh demodulatio...
Definition: LUT.h:249
HOUGHptfLUTVector
This structure contains a vector of partial look up tables (for the different time stamps)
Definition: LALHough.h:173
HOUGHptfLUTVector::lut
HOUGHptfLUT * lut
the partial Look Up Tables
Definition: LALHough.h:175
HOUGHptfLUTVector::length
UINT4 length
number of elements
Definition: LALHough.h:174
LALDetAndSource::pSource
LALSource * pSource
LALDetAndSource::pDetector
const LALDetector * pDetector
LALDetector::location
REAL8 location[3]
LALFrDetector::xArmAzimuthRadians
REAL4 xArmAzimuthRadians
LALFrDetector::yArmAzimuthRadians
REAL4 yArmAzimuthRadians
LALSource::equatorialCoords
SkyPosition equatorialCoords
LALSource::orientation
REAL8 orientation
LIGOTimeGPSVector
A vector of 'timestamps' of type LIGOTimeGPS.
Definition: SFTfileIO.h:188
LIGOTimeGPSVector::data
LIGOTimeGPS * data
array of timestamps
Definition: SFTfileIO.h:193
LIGOTimeGPSVector::length
UINT4 length
number of timestamps
Definition: SFTfileIO.h:192
PHMDVectorSequence
This structure contains a vector sequence of partial-Hough maps derivatives (for different time stamp...
Definition: LALHough.h:189
PHMDVectorSequence::fBinMin
UINT8 fBinMin
frequency index of smallest intrinsic frequency in circular buffer
Definition: LALHough.h:192
PHMDVectorSequence::breakLine
UINT4 breakLine
Mark [0, nfSize) (of the circular buffer) pointing to the starting of the fBinMin line.
Definition: LALHough.h:194
PHMDVectorSequence::nfSize
UINT4 nfSize
number of different frequencies
Definition: LALHough.h:190
PHMDVectorSequence::deltaF
REAL8 deltaF
frequency resolution
Definition: LALHough.h:193
PHMDVectorSequence::phmd
HOUGHphmd * phmd
the partial Hough map derivatives
Definition: LALHough.h:195
PHMDVectorSequence::length
UINT4 length
number of elements for each frequency
Definition: LALHough.h:191
REAL4Vector::data
REAL4 * data
REAL8Vector::data
REAL8 * data
SFTCatalog
An "SFT-catalogue": a vector of SFTdescriptors, as returned by XLALSFTdataFind()
Definition: SFTfileIO.h:238
SFTCatalog::data
SFTDescriptor * data
array of data-entries describing matched SFTs
Definition: SFTfileIO.h:243
SFTCatalog::length
UINT4 length
number of SFTs in catalog
Definition: SFTfileIO.h:242
SkyPosition::longitude
REAL8 longitude
SkyPosition::latitude
REAL8 latitude
SkyPosition::system
CoordinateSystem system
UINT8FrequencyIndexVector
This structure stores the frequency indexes of the partial-Hough map derivatives at different time st...
Definition: LALHough.h:149
UINT8FrequencyIndexVector::data
UINT8 * data
the frequency indexes
Definition: LALHough.h:152
UINT8FrequencyIndexVector::deltaF
REAL8 deltaF
frequency resolution
Definition: LALHough.h:151
UINT8FrequencyIndexVector::length
UINT4 length
number of elements
Definition: LALHough.h:150