Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALPulsar 7.1.1.1-b246709
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
DriveHoughTest.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2007 Badri Krishnan, Jolien Creighton, Alicia Sintes Olives
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 *
22 * File Name: TestDriveHough.c
23 *
24 * Authors: Sintes, A.M., Krishnan, B.
25 *
26 *
27 * History: Created by Sintes August 7, 2001
28 * Modified by Badri Krishnan Feb 2003
29 *
30 *-----------------------------------------------------------------------
31 */
32
33/*
34 * 1. An author and Id block
35 */
36
37/**
38 * \author Sintes, A. M., Krishnan, B.
39 * \file
40 * \ingroup LALHough_h
41 * \brief Tests the construction
42 *
43 * ### Program TestDriveHough.c ###
44 *
45 *
46 * ### Usage ###
47 *
48 * \code
49 * TestDriveHough [-d debuglevel] [-o outfile] [-f f0] [-p alpha delta]
50 * \endcode
51 *
52 * ### Description ###
53 *
54 * \%TO BE CHANGED
55 *
56 * This program generates a patch grid, a vector of \c luts by changing the
57 * alpha component of the velocity orientation of the detector by a fixed amount
58 * in each of them, and a vector of
59 * peak-grams (all of them containing the same information). Similar to the previous
60 * test codes the patch is set at the south pole.
61 *
62 * Then the program builds the set
63 * of \c phmd, updates the cylinder and computes a Hough map at a given
64 * frequency using only one horizontal line set of \c phmd, and outputs the
65 * result into a file.
66 *
67 * By default, running this program with no arguments simply tests the subroutines,
68 * producing an output file called <tt>OutHough.asc</tt>. All default parameters are set from
69 * <tt>\#define</tt>d constants.
70 *
71 * The <b>-d</b> option sets the debug level to the specified value
72 * \c debuglevel. The <b>-o</b> flag tells the program to print the partial Hough map
73 * derivative to the specified data file \c outfile. The
74 * <b>-f</b> option sets the intrinsic frequency \c f0 at which build the <tt>lut</tt>.
75 * The <b>-p</b> option sets the velocity orientation of the detector
76 * \c alpha, \c delta (in radians) for the first \c lut (time-stamp).
77 *
78 * ### Uses ###
79 *
80 * \code
81 * LALHOUGHCalcParamPLUT()
82 * LALHOUGHConstructPLUT()
83 * LALHOUGHConstructSpacePHMD()
84 * LALHOUGHupdateSpacePHMDup()
85 * LALHOUGHInitializeHT()
86 * LALHOUGHConstructHMT()
87 * LALPrintError()
88 * LALMalloc()
89 * LALFree()
90 * LALCheckMemoryLeaks()
91 * \endcode
92 *
93 */
94
95
96#include <lal/LALHough.h>
97
98/* Error codes and messages */
99
100/**\name Error Codes */ /** @{ */
101#define TESTDRIVEHOUGHC_ENORM 0
102#define TESTDRIVEHOUGHC_ESUB 1
103#define TESTDRIVEHOUGHC_EARG 2
104#define TESTDRIVEHOUGHC_EBAD 3
105#define TESTDRIVEHOUGHC_EFILE 4
106
107#define TESTDRIVEHOUGHC_MSGENORM "Normal exit"
108#define TESTDRIVEHOUGHC_MSGESUB "Subroutine failed"
109#define TESTDRIVEHOUGHC_MSGEARG "Error parsing arguments"
110#define TESTDRIVEHOUGHC_MSGEBAD "Bad argument values"
111#define TESTDRIVEHOUGHC_MSGEFILE "Could not create output file"
112/** @} */
113
114/** \cond DONT_DOXYGEN */
115
116/* Default parameters. */
117
118
119#define F0 500.0 /* frequency to build the LUT. */
120#define TCOH 100000.0 /* time baseline of coherent integration. */
121#define DF (1./TCOH) /* frequency resolution. */
122#define ALPHA 0.0
123#define DELTA 0.0
124#define MWR 1 /*.minWidthRatio */
125#define FILEOUT "OutHough.asc" /* file output */
126#define MOBSCOH 10
127#define NFSIZE 5
128#define STEPALPHA 0.005
129#define PIXELFACTOR 2
130/* Usage format string. */
131
132#define USAGE "Usage: %s [-d debuglevel] [-o outfile] [-f f0] [-p alpha delta] [-s patchSizeX patchSizeY]\n"
133
134/*********************************************************************/
135/* Macros for printing errors & testing subroutines (from Creighton) */
136/*********************************************************************/
137
138#define ERROR( code, msg, statement ) \
139do { \
140 if ( lalDebugLevel & LALERROR ) \
141 XLALPrintError( "Error[0] %d: program %s, file %s, line %d, %s\n" \
142 " %s %s\n", (code), *argv, __FILE__, \
143 __LINE__, "$Id$", statement ? statement : \
144 "", (msg) ); \
145} while (0)
146
147#define INFO( statement ) \
148do { \
149 if ( lalDebugLevel & LALINFO ) \
150 XLALPrintError( "Info[0]: program %s, file %s, line %d, %s\n" \
151 " %s\n", *argv, __FILE__, __LINE__, \
152 "$Id$", (statement) ); \
153} while (0)
154
155#define SUB( func, statusptr ) \
156do { \
157 if ( (func), (statusptr)->statusCode ) { \
158 ERROR( TESTDRIVEHOUGHC_ESUB, TESTDRIVEHOUGHC_MSGESUB, \
159 "Function call \"" #func "\" failed:" ); \
160 return TESTDRIVEHOUGHC_ESUB; \
161 } \
162} while (0)
163/******************************************************************/
164
165/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
166/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
167int main( int argc, char *argv[] )
168{
169
170 static LALStatus status; /* LALStatus pointer */
171 static HOUGHptfLUTVector lutV; /* the Look Up Table vector*/
172 static HOUGHPeakGramVector pgV;
173 static PHMDVectorSequence phmdVS; /* the partial Hough map derivatives */
174 static UINT8FrequencyIndexVector freqInd;
175
176 static HOUGHResolutionPar parRes;
177 static HOUGHPatchGrid patch; /* Patch description */
178
179 static HOUGHParamPLUT parLut; /* parameters needed to build lut */
180 static HOUGHDemodPar parDem; /* demodulation parameters */
181 static HOUGHSizePar parSize;
182 static HOUGHMapTotal ht; /* the total Hough map */
183 /* ------------------------------------------------------- */
184
185 UINT2 maxNBins, maxNBorders;
186
187 INT8 f0Bin; /* freq. bin to construct LUT */
188 INT8 fBin;
189
190 UINT2 xSide, ySide;
191
192 CHAR *fname = NULL; /* The output filename */
193 FILE *fp = NULL; /* Output file */
194
195 INT4 arg; /* Argument counter */
196 UINT4 i, j; /* Index counter, etc */
197 INT4 k;
198 REAL8 f0, alpha, delta, veloMod;
199 REAL8 patchSizeX, patchSizeY;
200
201 /************************************************************/
202 /* Set up the default parameters. */
203 /* **********************************************************/
204
205
206 lutV.length = MOBSCOH;
207 pgV.length = MOBSCOH;
208 phmdVS.length = MOBSCOH;
209 freqInd.length = MOBSCOH;
210 phmdVS.nfSize = NFSIZE;
211
212 freqInd.deltaF = DF;
213 phmdVS.deltaF = DF;
214
215 lutV.lut = NULL;
216 pgV.pg = NULL;
217 phmdVS.phmd = NULL;
218 freqInd.data = NULL;
219 ht.map = NULL;
220
221 f0 = F0;
222 f0Bin = F0 * TCOH;
223
224 parRes.f0Bin = f0Bin;
225 parRes.deltaF = DF;
226 parRes.patchSkySizeX = patchSizeX = 1.0 / ( TCOH * F0 * VEPI );
227 parRes.patchSkySizeY = patchSizeY = 1.0 / ( TCOH * F0 * VEPI );
228 parRes.pixelFactor = PIXELFACTOR;
229 parRes.pixErr = PIXERR;
230 parRes.linErr = LINERR;
231 parRes.vTotC = VTOT;
232
233
234 alpha = ALPHA;
235 delta = DELTA;
236 veloMod = VTOT;
237
238
239 /********************************************************/
240 /* Parse argument list. i stores the current position. */
241 /********************************************************/
242 arg = 1;
243 while ( arg < argc ) {
244 /* Parse debuglevel option. */
245 if ( !strcmp( argv[arg], "-d" ) ) {
246 if ( argc > arg + 1 ) {
247 arg++;
248 } else {
250 XLALPrintError( USAGE, *argv );
252 }
253 }
254 /* Parse output file option. */
255 else if ( !strcmp( argv[arg], "-o" ) ) {
256 if ( argc > arg + 1 ) {
257 arg++;
258 fname = argv[arg++];
259 } else {
261 XLALPrintError( USAGE, *argv );
263 }
264 }
265 /* Parse frequency option. */
266 else if ( !strcmp( argv[arg], "-f" ) ) {
267 if ( argc > arg + 1 ) {
268 arg++;
269 f0 = atof( argv[arg++] );
270 f0Bin = f0 * TCOH;
271 parRes.f0Bin = f0Bin;
272 } else {
274 XLALPrintError( USAGE, *argv );
276 }
277 }
278 /* Parse velocity position options. */
279 else if ( !strcmp( argv[arg], "-p" ) ) {
280 if ( argc > arg + 2 ) {
281 arg++;
282 alpha = atof( argv[arg++] );
283 delta = atof( argv[arg++] );
284 } else {
286 XLALPrintError( USAGE, *argv );
288 }
289 }
290 /* Parse patch size option. */
291 else if ( !strcmp( argv[arg], "-s" ) ) {
292 if ( argc > arg + 2 ) {
293 arg++;
294 parRes.patchSkySizeX = patchSizeX = atof( argv[arg++] );
295 parRes.patchSkySizeY = patchSizeY = atof( argv[arg++] );
296 } else {
298 XLALPrintError( USAGE, *argv );
300 }
301 }
302 /* Unrecognized option. */
303 else {
305 XLALPrintError( USAGE, *argv );
307 }
308 } /* End of argument parsing loop. */
309 /******************************************************************/
310
311 if ( f0 < 0 ) {
313 XLALPrintError( USAGE, *argv );
315 }
316
317
318 /******************************************************************/
319 /* create patch grid */
320 /******************************************************************/
321
322 SUB( LALHOUGHComputeSizePar( &status, &parSize, &parRes ), &status );
323
324 xSide = parSize.xSide;
325 ySide = parSize.ySide;
326 maxNBins = parSize.maxNBins;
327 maxNBorders = parSize.maxNBorders;
328
329 /* allocate memory based on xSide and ySide */
330 patch.xSide = xSide;
331 patch.ySide = ySide;
332
333 patch.xCoor = NULL;
334 patch.yCoor = NULL;
335 patch.xCoor = ( REAL8 * )LALMalloc( xSide * sizeof( REAL8 ) );
336 patch.yCoor = ( REAL8 * )LALMalloc( ySide * sizeof( REAL8 ) );
337
338 SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
339
340 /******************************************************************/
341 /* memory allocation and settings */
342 /******************************************************************/
343
344 lutV.lut = ( HOUGHptfLUT * )LALMalloc( MOBSCOH * sizeof( HOUGHptfLUT ) );
345 pgV.pg = ( HOUGHPeakGram * )LALMalloc( MOBSCOH * sizeof( HOUGHPeakGram ) );
346 phmdVS.phmd = ( HOUGHphmd * )LALMalloc( MOBSCOH * NFSIZE * sizeof( HOUGHphmd ) );
347 freqInd.data = ( UINT8 * )LALMalloc( MOBSCOH * sizeof( UINT8 ) );
348
349 for ( j = 0; j < lutV.length; ++j ) {
350 lutV.lut[j].maxNBins = maxNBins;
351 lutV.lut[j].maxNBorders = maxNBorders;
352 lutV.lut[j].border =
353 ( HOUGHBorder * )LALMalloc( maxNBorders * sizeof( HOUGHBorder ) );
354 lutV.lut[j].bin =
355 ( HOUGHBin2Border * )LALMalloc( maxNBins * sizeof( HOUGHBin2Border ) );
356 }
357
358 for ( j = 0; j < phmdVS.length * phmdVS.nfSize; ++j ) {
359 phmdVS.phmd[j].maxNBorders = maxNBorders;
360 phmdVS.phmd[j].leftBorderP =
361 ( HOUGHBorder ** )LALMalloc( maxNBorders * sizeof( HOUGHBorder * ) );
362 phmdVS.phmd[j].rightBorderP =
363 ( HOUGHBorder ** )LALMalloc( maxNBorders * sizeof( HOUGHBorder * ) );
364 }
365
366
367 ht.xSide = xSide;
368 ht.ySide = ySide;
369 ht.map = NULL;
370 ht.map = ( HoughTT * )LALMalloc( xSide * ySide * sizeof( HoughTT ) );
371
372 for ( j = 0; j < phmdVS.length * phmdVS.nfSize; ++j ) {
373 phmdVS.phmd[j].ySide = ySide;
374 phmdVS.phmd[j].firstColumn = NULL;
375 phmdVS.phmd[j].firstColumn = ( UCHAR * )LALMalloc( ySide * sizeof( UCHAR ) );
376 }
377
378 for ( j = 0; j < lutV.length ; ++j ) {
379 for ( i = 0; i < maxNBorders; ++i ) {
380 lutV.lut[j].border[i].ySide = ySide;
381 lutV.lut[j].border[i].xPixel =
382 ( COORType * )LALMalloc( ySide * sizeof( COORType ) );
383 }
384 }
385
386
387 /******************************************************************/
388 /* Case: no spins, patch at south pole */
389 /************************************************************/
390 parDem.deltaF = DF;
391 parDem.skyPatch.alpha = 0.0;
392 parDem.skyPatch.delta = -LAL_PI_2;
393
394 parDem.positC.x = 0.0;
395 parDem.positC.y = 0.0;
396 parDem.positC.z = 0.0;
397
398 parDem.timeDiff = 0.0;
399 parDem.spin.length = 0;
400 parDem.spin.data = NULL;
401
402 /*************************************************/
403 for ( j = 0; j < MOBSCOH; ++j ) { /* create all the LUTs */
404 parDem.veloC.x = veloMod * cos( delta ) * cos( alpha );
405 parDem.veloC.y = veloMod * cos( delta ) * sin( alpha );
406 parDem.veloC.z = veloMod * sin( delta );
407
408 alpha += STEPALPHA; /* shift alpha several degrees */
409
410 /* calculate parameters needed for buiding the LUT */
411 SUB( LALHOUGHCalcParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
412
413 /* build the LUT */
414 SUB( LALHOUGHConstructPLUT( &status, &( lutV.lut[j] ), &patch, &parLut ),
415 &status );
416 }
417
418
419 /******************************************************************/
420 /* create Peakgrams for testing */
421 /******************************************************************/
422
423 fBin = f0Bin + 21; /* a Frequency-bin shifted from the LUT */
424
425 for ( j = 0; j < MOBSCOH; ++j ) { /* create all the peakgrams */
426 pgV.pg[j].deltaF = DF;
427 pgV.pg[j].fBinIni = ( fBin ) - maxNBins;
428 pgV.pg[j].fBinFin = ( fBin ) + 5 * maxNBins;
429 pgV.pg[j].length = maxNBins; /* could be much smaller */
430 pgV.pg[j].peak = NULL;
431 pgV.pg[j].peak = ( INT4 * )LALMalloc( ( pgV.pg[j].length ) * sizeof( INT4 ) );
432
433 for ( i = 0; i < pgV.pg[j].length; ++i ) {
434 pgV.pg[j].peak[i] = 3 * i; /* test */
435 }
436 }
437
438
439 /******************************************************************/
440 /* build the set of PHMD */
441 /******************************************************************/
442
443 phmdVS.fBinMin = fBin;
444 SUB( LALHOUGHConstructSpacePHMD( &status, &phmdVS, &pgV, &lutV ), &status );
445
446 /* shift the structure one frequency bin */
447 SUB( LALHOUGHupdateSpacePHMDup( &status, &phmdVS, &pgV, &lutV ), &status );
448
449
450 /******************************************************************/
451 /* initializing the Hough map space */
452 /******************************************************************/
453
454 SUB( LALHOUGHInitializeHT( &status, &ht, &patch ), &status );
455
456
457 /******************************************************************/
458 /* construction of a total Hough map */
459 /******************************************************************/
460
461 for ( j = 0; j < MOBSCOH; ++j ) {
462 freqInd.data[j] = fBin + 2;
463 }
464
465 SUB( LALHOUGHConstructHMT( &status, &ht, &freqInd, &phmdVS ), &status );
466
467 /******************************************************************/
468 /* printing the results into a particular file */
469 /* if the -o option was given, or into FILEOUT */
470 /******************************************************************/
471
472 if ( fname ) {
473 fp = fopen( fname, "w" );
474 } else {
475 fp = fopen( FILEOUT, "w" );
476 }
477
478 if ( !fp ) {
481 }
482
483
484 for ( k = ySide - 1; k >= 0; --k ) {
485 for ( i = 0; i < xSide; ++i ) {
486 fprintf( fp, " %f", ht.map[k * xSide + i] );
487 fflush( fp );
488 }
489 fprintf( fp, " \n" );
490 fflush( fp );
491 }
492
493 fclose( fp );
494
495
496 /******************************************************************/
497 /* Free memory and exit */
498 /******************************************************************/
499 for ( j = 0; j < MOBSCOH; ++j ) {
500 LALFree( pgV.pg[j].peak ); /* All of them */
501 }
502
503
504 for ( j = 0; j < lutV.length ; ++j ) {
505 for ( i = 0; i < maxNBorders; ++i ) {
506 LALFree( lutV.lut[j].border[i].xPixel );
507 }
508 LALFree( lutV.lut[j].border );
509 LALFree( lutV.lut[j].bin );
510 }
511
512 for ( j = 0; j < phmdVS.length * phmdVS.nfSize; ++j ) {
513 LALFree( phmdVS.phmd[j].leftBorderP );
514 LALFree( phmdVS.phmd[j].rightBorderP );
515 LALFree( phmdVS.phmd[j].firstColumn );
516 }
517
518 LALFree( lutV.lut );
519 LALFree( pgV.pg );
520 LALFree( phmdVS.phmd );
521 LALFree( freqInd.data );
522
523 LALFree( ht.map );
524
525 LALFree( patch.xCoor );
526 LALFree( patch.yCoor );
527
529
532}
533
534/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
535
536/** \endcond */
#define SUB(func, statusptr)
#define ERROR(code, msg, statement)
#define INFO(statement)
#define NFSIZE
#define TESTDRIVEHOUGHC_ENORM
#define TESTDRIVEHOUGHC_MSGEBAD
#define TESTDRIVEHOUGHC_EFILE
#define TESTDRIVEHOUGHC_MSGEFILE
#define TESTDRIVEHOUGHC_EARG
#define TESTDRIVEHOUGHC_MSGEARG
#define TESTDRIVEHOUGHC_MSGENORM
#define TESTDRIVEHOUGHC_EBAD
#define DELTA
#define ALPHA
int j
int k
void LALCheckMemoryLeaks(void)
#define LALMalloc(n)
#define LALFree(p)
static double double delta
#define fprintf
int main(int argc, char **argv)
REAL8 HoughTT
Total Hough Map pixel type.
Definition: HoughMap.h:113
void LALHOUGHInitializeHT(LALStatus *status, HOUGHMapTotal *ht, HOUGHPatchGrid *patch)
This function initializes the total Hough map HOUGHMapTotal *ht to zero and checks consistency betwee...
Definition: HoughMap.c:74
#define LAL_PI_2
unsigned char UCHAR
uint64_t UINT8
double REAL8
int64_t INT8
uint16_t UINT2
char CHAR
uint32_t UINT4
int32_t INT4
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
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
void LALHOUGHConstructHMT(LALStatus *status, HOUGHMapTotal *ht, UINT8FrequencyIndexVector *freqInd, PHMDVectorSequence *phmdVS)
Given PHMDVectorSequence *phmdVS, the space of phmd, and UINT8FrequencyIndexVector *freqInd,...
Definition: DriveHough.c:301
#define VTOT
Total detector velocity/c TO BE CHANGED DEPENDING ON DETECTOR.
Definition: LUT.h:207
#define PIXERR
Maximum `‘error’' (as a fraction of the width of the thinnest annulus) which allows to consider two b...
Definition: LUT.h:195
#define LINERR
Maximum `‘error’' (as a fraction of the width of the thinnest annulus) which allows to represent a ci...
Definition: LUT.h:188
void LALHOUGHFillPatchGrid(LALStatus *status, HOUGHPatchGrid *out, HOUGHSizePar *par)
Definition: PatchGrid.c:331
#define VEPI
Earth v_epicycle/c TO BE CHANGED DEPENDING ON DETECTOR.
Definition: LUT.h:202
void LALHOUGHConstructPLUT(LALStatus *status, HOUGHptfLUT *lut, HOUGHPatchGrid *patch, HOUGHParamPLUT *par)
void LALHOUGHCalcParamPLUT(LALStatus *status, HOUGHParamPLUT *out, HOUGHSizePar *sizePar, HOUGHDemodPar *par)
Definition: ParamPLUT.c:71
void LALHOUGHComputeSizePar(LALStatus *status, HOUGHSizePar *out, HOUGHResolutionPar *in)
Definition: PatchGrid.c:92
INT2 COORType
To be changed to {INT2 COORType} if the number of pixels in the x-direction exceeds 255.
Definition: LUT.h:218
int XLALPrintError(const char *fmt,...) _LAL_GCC_PRINTF_FORMAT_(1
#define F0
#define FILEOUT
#define PIXELFACTOR
double alpha
This structure stores the border indexes corresponding to one frequency bin plus the corrections to b...
Definition: LUT.h:234
This structure stores the border of a circle clipped on the projected plane.
Definition: LUT.h:221
COORType * xPixel
x pixel index to be marked
Definition: LUT.h:226
UINT2 ySide
length of xPixel
Definition: LUT.h:225
Demodulation parameters needed for the Hough transform; all coordinates are assumed to be with respec...
Definition: LUT.h:353
REAL8Cart3Coor positC
(x,y,z): Position of the detector
Definition: LUT.h:357
REAL8 deltaF
Frequency resolution: df=1/TCOH
Definition: LUT.h:354
REAL8 timeDiff
: time difference
Definition: LUT.h:358
REAL8Cart3Coor veloC
(x,y,z): Relative detector velocity
Definition: LUT.h:356
REAL8Vector spin
Spin down information.
Definition: LUT.h:359
REAL8UnitPolarCoor skyPatch
(alpha, delta): position of the center of the patch
Definition: LUT.h:355
This structure stores the Hough map.
Definition: HoughMap.h:130
UINT2 ySide
number of physical pixels in the y direction
Definition: HoughMap.h:142
UINT2 xSide
number of physical pixels in the x direction
Definition: HoughMap.h:141
HoughTT * map
the pixel counts; the number of elements to allocate is ySide*xSide
Definition: HoughMap.h:143
Parameters needed to construct the partial look up table.
Definition: LUT.h:333
This structure stores patch-frequency grid information.
Definition: LUT.h:264
UINT2 ySide
Real number of pixels in the y-direction (in the projected plane).
Definition: LUT.h:275
REAL8 * xCoor
Coordinates of the pixel centers.
Definition: LUT.h:271
UINT2 xSide
Real number of pixels in the x direction (in the projected plane); it should be less than or equal to...
Definition: LUT.h:270
REAL8 * yCoor
Coordinates of the pixel centers.
Definition: LUT.h:278
This structure stores the `‘peak-gram’'.
Definition: PHMD.h:129
REAL8 deltaF
Frequency resolution: df=1/TCOH
Definition: PHMD.h:131
UINT4 length
Number of peaks present in the peak-gram.
Definition: PHMD.h:134
UINT8 fBinFin
Frequency index of the last element of the spectrum covered by this peak-gram.
Definition: PHMD.h:133
UINT8 fBinIni
Frequency index of the first element of the spectrum covered by this peak-gram; it can be seen as an ...
Definition: PHMD.h:132
INT4 * peak
The peak indices relative to fBinIni, i.e., the zero peak corresponds to fBinIni.
Definition: PHMD.h:135
This structure contains a vector of peak-grams (for the different time stamps)
Definition: LALHough.h:167
UINT4 length
number of elements
Definition: LALHough.h:168
HOUGHPeakGram * pg
the Peakgrams
Definition: LALHough.h:169
parameters needed for gridding the patch
Definition: LUT.h:282
REAL8 deltaF
Frequency resolution: df=1/TCOH
Definition: LUT.h:284
REAL8 pixErr
for validity of LUT as PIXERR
Definition: LUT.h:288
INT8 f0Bin
Frequency bin at which construct the grid.
Definition: LUT.h:283
REAL8 patchSkySizeY
Patch size in radians along y-axis.
Definition: LUT.h:286
REAL8 patchSkySizeX
Patch size in radians along x-axis.
Definition: LUT.h:285
REAL8 pixelFactor
number of pixel that fit in the thinnest annulus
Definition: LUT.h:287
REAL8 vTotC
estimate value of v-total/C as VTOT
Definition: LUT.h:290
REAL8 linErr
as LINERR circle ->line
Definition: LUT.h:289
required for constructing patch
Definition: LUT.h:294
UINT2 maxNBorders
maximum number of borders affecting the patch; for memory allocation
Definition: LUT.h:302
UINT2 maxNBins
maximum number of bins affecting the patch; for memory allocation
Definition: LUT.h:301
UINT2 ySide
number of pixels in the y direction
Definition: LUT.h:300
UINT2 xSide
number of pixels in the x direction (projected plane)
Definition: LUT.h:299
This structure stores a partial Hough map derivative.
Definition: PHMD.h:141
UCHAR * firstColumn
Number of elements of firstColumn.
Definition: PHMD.h:151
UINT2 ySide
number of elements of firstColumn
Definition: PHMD.h:150
HOUGHBorder ** rightBorderP
Pointers to borders.
Definition: PHMD.h:149
UINT2 maxNBorders
Maximun number of borders of each type (for memory allocation purposes), i.e. length of *leftBorderP ...
Definition: PHMD.h:145
HOUGHBorder ** leftBorderP
Pointers to borders.
Definition: PHMD.h:148
This structure stores the patch-time-frequency look up table.
Definition: LUT.h:246
UINT2 maxNBins
Maximum number of bins affecting the patch (for memory allocation purposes)
Definition: LUT.h:256
HOUGHBorder * border
The annulus borders.
Definition: LUT.h:258
HOUGHBin2Border * bin
Bin to border correspondence.
Definition: LUT.h:259
UINT2 maxNBorders
Maximum number of borders affecting the patch (for memory allocation purposes)
Definition: LUT.h:257
This structure contains a vector of partial look up tables (for the different time stamps)
Definition: LALHough.h:173
HOUGHptfLUT * lut
the partial Look Up Tables
Definition: LALHough.h:175
UINT4 length
number of elements
Definition: LALHough.h:174
This structure contains a vector sequence of partial-Hough maps derivatives (for different time stamp...
Definition: LALHough.h:189
UINT8 fBinMin
frequency index of smallest intrinsic frequency in circular buffer
Definition: LALHough.h:192
UINT4 nfSize
number of different frequencies
Definition: LALHough.h:190
REAL8 deltaF
frequency resolution
Definition: LALHough.h:193
HOUGHphmd * phmd
the partial Hough map derivatives
Definition: LALHough.h:195
UINT4 length
number of elements for each frequency
Definition: LALHough.h:191
REAL8 y
Definition: LUT.h:310
REAL8 x
Definition: LUT.h:309
REAL8 z
Definition: LUT.h:311
REAL8 alpha
any value
Definition: LUT.h:328
REAL8 delta
In the interval [ ].
Definition: LUT.h:329
REAL8 * data
This structure stores the frequency indexes of the partial-Hough map derivatives at different time st...
Definition: LALHough.h:149
UINT8 * data
the frequency indexes
Definition: LALHough.h:152
REAL8 deltaF
frequency resolution
Definition: LALHough.h:151
UINT4 length
number of elements
Definition: LALHough.h:150