Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALPulsar 7.1.1.1-8a6b96f
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
ConstructPLUTTest.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: TestConstructPLUT.c
23 *
24 * Authors: Sintes, A.M.,
25 *
26 *
27 * History: Created by Sintes June 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.
39 * \file
40 * \ingroup LUT_h
41 * \brief Tests the construction of the Look up Table (\c LUT)
42 *
43 * ### Usage ###
44 *
45 * \code
46 * TestConstructPLUT [-d debuglevel] [-o outfile] [-f f0] [-p alpha delta] [-s patchSizeX patchSizeY]
47 * \endcode
48 *
49 * ### Description ###
50 *
51 * \%TO BE CHANGED
52 *
53 * This program generates a patch grid, calculates the parameters needed for
54 * building the \c LUT, builds the \c LUT and outputs a partial Hough map
55 * derivative into a file. The sky patch is set at the south pole,
56 * no spin-down parameters are assumed for the demodulation and
57 * every third peak in the spectrum is selected.
58 *
59 * By default, running this program with no arguments simply tests the subroutines,
60 * producing an output file called <tt>OutHough.asc</tt>. All default parameters are set from
61 * <tt>\#define</tt>d constants.
62 *
63 * The <b>-d</b> option sets the debug level to the specified value
64 * \c debuglevel. The <b>-o</b> flag tells the program to print the partial Hough map
65 * derivative to the specified data file \c outfile. The
66 * <b>-f</b> option sets the intrinsic frequency \c f0 at which build the <tt>LUT</tt>.
67 * The <b>-p</b> option sets the velocity orientation of the detector
68 * \c alpha, \c delta (in radians).
69 *
70 * ### Uses ###
71 *
72 * \code
73 * LALHOUGHCalcParamPLUT()
74 * LALHOUGHConstructPLUT()
75 * LALPrintError()
76 * LALMalloc()
77 * LALFree()
78 * LALCheckMemoryLeaks()
79 * \endcode
80 *
81 */
82
83
84#include <lal/LUT.h>
85
86/* Error codes and messages */
87
88/**\name Error Codes */ /** @{ */
89#define TESTCONSTRUCTPLUTC_ENORM 0
90#define TESTCONSTRUCTPLUTC_ESUB 1
91#define TESTCONSTRUCTPLUTC_EARG 2
92#define TESTCONSTRUCTPLUTC_EBAD 3
93#define TESTCONSTRUCTPLUTC_EFILE 4
94
95#define TESTCONSTRUCTPLUTC_MSGENORM "Normal exit"
96#define TESTCONSTRUCTPLUTC_MSGESUB "Subroutine failed"
97#define TESTCONSTRUCTPLUTC_MSGEARG "Error parsing arguments"
98#define TESTCONSTRUCTPLUTC_MSGEBAD "Bad argument values"
99#define TESTCONSTRUCTPLUTC_MSGEFILE "Could not create output file"
100/** @} */
101
102
103/** \cond DONT_DOXYGEN */
104
105/* Default parameters. */
106
107
108#define F0 500.0 /* frequency to build the LUT. */
109#define TCOH 100000.0 /* time baseline of coherent integration. */
110#define DF (1./TCOH) /* frequency resolution. */
111#define ALPHA 0.0
112#define DELTA 0.0
113#define MWR 1 /*.minWidthRatio */
114#define FILEOUT "OutHough.asc" /* file output */
115
116/* Usage format string. */
117
118#define USAGE "Usage: %s [-d debuglevel] [-o outfile] [-f f0] [-p alpha delta][-s patchSizeX patchSizeY]\n"
119
120/*********************************************************************/
121/* Macros for printing errors & testing subroutines (from Creighton) */
122/*********************************************************************/
123
124#define ERROR( code, msg, statement ) \
125do { \
126 if ( lalDebugLevel & LALERROR ) \
127 XLALPrintError( "Error[0] %d: program %s, file %s, line %d, %s\n" \
128 " %s %s\n", (code), *argv, __FILE__, \
129 __LINE__, "$Id$", statement ? statement : \
130 "", (msg) ); \
131} while (0)
132
133#define INFO( statement ) \
134do { \
135 if ( lalDebugLevel & LALINFO ) \
136 XLALPrintError( "Info[0]: program %s, file %s, line %d, %s\n" \
137 " %s\n", *argv, __FILE__, __LINE__, \
138 "$Id$", (statement) ); \
139} while (0)
140
141#define SUB( func, statusptr ) \
142do { \
143 if ( (func), (statusptr)->statusCode ) { \
144 ERROR( TESTCONSTRUCTPLUTC_ESUB, TESTCONSTRUCTPLUTC_MSGESUB, \
145 "Function call \"" #func "\" failed:" ); \
146 return TESTCONSTRUCTPLUTC_ESUB; \
147 } \
148} while (0)
149/******************************************************************/
150
151#define PIXELFACTOR 2
152
153/* the Hough Map derivative pixel type */
154typedef CHAR HoughDT;
155
156
157/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
158/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
159int main( int argc, char *argv[] )
160{
161
162 static LALStatus status; /* LALStatus pointer */
163 static HOUGHptfLUT lut; /* the Look Up Table */
164 static HOUGHPatchGrid patch; /* Patch description */
165 static HOUGHParamPLUT parLut; /* parameters needed to build lut */
166 static HOUGHResolutionPar parRes;
167 static HOUGHSizePar parSize;
168 static HOUGHDemodPar parDem; /* demodulation parameters */
169 /* ------------------------------------------------------- */
170
171 INT8 f0Bin; /* freq. bin to construct LUT */
172 UINT2 xSide, ySide;
173 UINT2 maxNBins, maxNBorders;
174
175 /* the Hough derivative map. The patch containing at most
176 SIDEX*SIDEY pixels */
177 /* HoughDT PHMD[SIDEY][SIDEX+1]; */
178
179 HoughDT *PHMD;
180
181 HoughDT *pointer;
182
183 CHAR *fname = NULL; /* The output filename */
184 FILE *fp = NULL; /* Output file */
185
186 INT4 arg; /* Argument counter */
187 INT4 i, j, k, binPoint; /* Index counter, etc */
188 REAL8 f0, alpha, delta, veloMod;
189 REAL8 patchSizeX, patchSizeY;
190
191 /************************************************************/
192 /* Set up the default parameters. */
193 /************************************************************/
194
195 f0 = F0;
196 f0Bin = F0 * TCOH;
197
198 parRes.f0Bin = f0Bin;
199 parRes.deltaF = DF;
200 parRes.patchSkySizeX = patchSizeX = 1.0 / ( TCOH * F0 * VEPI );
201 parRes.patchSkySizeY = patchSizeY = 1.0 / ( TCOH * F0 * VEPI );
202 parRes.pixelFactor = PIXELFACTOR;
203 parRes.pixErr = PIXERR;
204 parRes.linErr = LINERR;
205 parRes.vTotC = VTOT;
206
207 parDem.deltaF = DF;
208 parDem.skyPatch.alpha = 0.0;
209 parDem.skyPatch.delta = -LAL_PI_2;
210
211 alpha = ALPHA;
212 delta = DELTA;
213 veloMod = VTOT;
214
215
216 /********************************************************/
217 /* Parse argument list. i stores the current position. */
218 /********************************************************/
219 arg = 1;
220 while ( arg < argc ) {
221 /* Parse debuglevel option. */
222 if ( !strcmp( argv[arg], "-d" ) ) {
223 if ( argc > arg + 1 ) {
224 arg++;
225 } else {
227 XLALPrintError( USAGE, *argv );
229 }
230 }
231 /* Parse output file option. */
232 else if ( !strcmp( argv[arg], "-o" ) ) {
233 if ( argc > arg + 1 ) {
234 arg++;
235 fname = argv[arg++];
236 } else {
238 XLALPrintError( USAGE, *argv );
240 }
241 }
242 /* Parse frequency option. */
243 else if ( !strcmp( argv[arg], "-f" ) ) {
244 if ( argc > arg + 1 ) {
245 arg++;
246 f0 = atof( argv[arg++] );
247 f0Bin = f0 * TCOH;
248 parRes.f0Bin = f0Bin;
249 } else {
251 XLALPrintError( USAGE, *argv );
253 }
254 }
255 /* Parse velocity position options. */
256 else if ( !strcmp( argv[arg], "-p" ) ) {
257 if ( argc > arg + 2 ) {
258 arg++;
259 alpha = atof( argv[arg++] );
260 delta = atof( argv[arg++] );
261 } else {
263 XLALPrintError( USAGE, *argv );
265 }
266 }
267 /* Parse patch size option. */
268 else if ( !strcmp( argv[arg], "-s" ) ) {
269 if ( argc > arg + 2 ) {
270 arg++;
271 parRes.patchSkySizeX = patchSizeX = atof( argv[arg++] );
272 parRes.patchSkySizeY = patchSizeY = atof( argv[arg++] );
273 } else {
275 XLALPrintError( USAGE, *argv );
277 }
278 }
279 /* Unrecognized option. */
280 else {
282 XLALPrintError( USAGE, *argv );
284 }
285 } /* End of argument parsing loop. */
286 /******************************************************************/
287
288 if ( f0 < 0 ) {
290 XLALPrintError( USAGE, *argv );
292 }
293
294 /******************************************************************/
295 /* create patch grid */
296 /******************************************************************/
297
298 SUB( LALHOUGHComputeSizePar( &status, &parSize, &parRes ), &status );
299
300 xSide = parSize.xSide;
301 ySide = parSize.ySide;
302 maxNBins = parSize.maxNBins;
303 maxNBorders = parSize.maxNBorders;
304
305 /* allocate memory based on xSide and ySide */
306 patch.xSide = xSide;
307 patch.ySide = ySide;
308
309 patch.xCoor = NULL;
310 patch.yCoor = NULL;
311 patch.xCoor = ( REAL8 * )LALMalloc( xSide * sizeof( REAL8 ) );
312 patch.yCoor = ( REAL8 * )LALMalloc( ySide * sizeof( REAL8 ) );
313
314 SUB( LALHOUGHFillPatchGrid( &status, &patch, &parSize ), &status );
315
316 /******************************************************************/
317 /* memory allocation and settings */
318 /******************************************************************/
319
320 lut.maxNBins = maxNBins;
321 lut.maxNBorders = maxNBorders;
322 lut.border =
323 ( HOUGHBorder * )LALMalloc( maxNBorders * sizeof( HOUGHBorder ) );
324 lut.bin =
325 ( HOUGHBin2Border * )LALMalloc( maxNBins * sizeof( HOUGHBin2Border ) );
326
327 PHMD = ( HoughDT * )LALMalloc( ( xSide + 1 ) * ySide * sizeof( HoughDT ) );
328
329 for ( i = 0; i < maxNBorders; ++i ) {
330 lut.border[i].ySide = ySide;
331 lut.border[i].xPixel = ( COORType * )LALMalloc( ySide * sizeof( COORType ) );
332 }
333
334
335 /******************************************************************/
336 /* Case: no spins, patch at south pole */
337 /******************************************************************/
338
339 parDem.veloC.x = veloMod * cos( delta ) * cos( alpha );
340 parDem.veloC.y = veloMod * cos( delta ) * sin( alpha );
341 parDem.veloC.z = veloMod * sin( delta );
342
343 parDem.positC.x = 0.0;
344 parDem.positC.y = 0.0;
345 parDem.positC.z = 0.0;
346 parDem.timeDiff = 0.0;
347 parDem.spin.length = 0;
348 parDem.spin.data = NULL;
349
350 /******************************************************************/
351 /* calculate parameters needed for buiding the LUT */
352 /******************************************************************/
353 SUB( LALHOUGHCalcParamPLUT( &status, &parLut, &parSize, &parDem ), &status );
354
355 /******************************************************************/
356 /* build the LUT */
357 /******************************************************************/
358 SUB( LALHOUGHConstructPLUT( &status, &lut, &patch, &parLut ), &status );
359
360 /******************************************************************/
361 /* construct PHMD[i][j] accordingly */
362 /*******************************************************/
363
364 /* initializing output space */
365 pointer = &( PHMD[0] );
366 for ( k = 0; k < ( xSide + 1 ) * ySide; ++k ) {
367 *pointer = 0;
368 ++pointer;
369 }
370
371 binPoint = lut.iniBin + lut.nBin;
372
373 /* just as a test examples */
374
375 for ( k = lut.iniBin; k < binPoint ; k += 2 ) {
376 /* this should be for plotting each two bins!
377 so one can see all border with +1 or -1 */
378
379 /* for( k= -2; k < 3 ; k+=2 ){ */
380 /* now just 3 peaks selected -2,0,+2 */
381
382
383 INT2 lb1, rb1, lb2, rb2; /* The border index. If zero means that */
384 /* it does not intersect the patch, or nothing to clip */
385 INT2 max1, min1, max2, min2;
386 INT2 xindex;
387
388 /* conversion of "peak index" (separation to the f0 frequency)
389 into the bin in the LUT */
390
391 i = k;
392 if ( k < 0 ) {
393 i = binPoint - 1 - k;
394 }
395
396 /*reading the bin information */
397
398 lb1 = lut.bin[i].leftB1;
399 rb1 = lut.bin[i].rightB1;
400 lb2 = lut.bin[i].leftB2;
401 rb2 = lut.bin[i].rightB2;
402
403 max1 = lut.bin[i].piece1max;
404 min1 = lut.bin[i].piece1min;
405 max2 = lut.bin[i].piece2max;
406 min2 = lut.bin[i].piece2min;
407
408 /* drawing the annuli borders */
409 if ( lb1 ) {
410 for ( j = lut.border[lb1].yLower;
411 j <= lut.border[lb1].yUpper; j++ ) {
412 xindex = lut.border[lb1].xPixel[j];
413 PHMD[j * ( xSide + 1 ) + xindex] += 1;
414 }
415 }
416 if ( lb2 ) {
417 for ( j = lut.border[lb2].yLower;
418 j <= lut.border[lb2].yUpper; j++ ) {
419 xindex = lut.border[lb2].xPixel[j];
420 PHMD[j * ( xSide + 1 ) + xindex] += 1;
421 }
422 }
423 if ( rb1 ) {
424 for ( j = lut.border[rb1].yLower;
425 j <= lut.border[rb1].yUpper; j++ ) {
426 xindex = lut.border[rb1].xPixel[j];
427 PHMD[j * ( xSide + 1 ) + xindex] -= 1;
428 }
429 }
430 if ( rb2 ) {
431 for ( j = lut.border[rb2].yLower;
432 j <= lut.border[rb2].yUpper; j++ ) {
433 xindex = lut.border[rb2].xPixel[j];
434 PHMD[j * ( xSide + 1 ) + xindex] -= 1;
435 }
436 }
437
438 /* correcting border effects */
439
440 /* note: if max1<min1, nothing should be done! */
441 for ( j = min1; j <= max1; ++j ) {
442 PHMD[j * ( xSide + 1 )] += 1;
443 }
444
445 for ( j = min2; j <= max2; ++j ) {
446 PHMD[j * ( xSide + 1 )] += 1;
447 }
448
449 }
450
451
452 /*******************************************************/
453 /* printing the results into a particular file */
454 /* if the -o option was given, or into FILEOUT */
455 /*******************************************************/
456
457 if ( fname ) {
458 fp = fopen( fname, "w" );
459 } else {
460 fp = fopen( FILEOUT, "w" );
461 }
462
463 if ( !fp ) {
466 }
467
468
469 for ( j = ySide - 1; j >= 0; --j ) {
470 for ( i = 0; i < xSide; ++i ) {
471 fprintf( fp, " %d", PHMD[j * ( xSide + 1 ) + i] );
472 fflush( fp );
473 }
474 fprintf( fp, " \n" );
475 fflush( fp );
476 }
477
478 fclose( fp );
479
480 /******************************************************************/
481 /* Free memory and exit */
482 /******************************************************************/
483
484 for ( i = 0; i < maxNBorders; ++i ) {
485 LALFree( lut.border[i].xPixel );
486 }
487
488 LALFree( lut.border );
489 LALFree( lut.bin );
490
491 LALFree( PHMD );
492
493 LALFree( patch.xCoor );
494 LALFree( patch.yCoor );
495
497
500}
501
502/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< */
503
504/** \endcond */
#define TESTCONSTRUCTPLUTC_EBAD
#define TESTCONSTRUCTPLUTC_MSGEFILE
#define TESTCONSTRUCTPLUTC_ENORM
#define TESTCONSTRUCTPLUTC_MSGEARG
#define TESTCONSTRUCTPLUTC_EFILE
#define TESTCONSTRUCTPLUTC_EARG
#define TESTCONSTRUCTPLUTC_MSGEBAD
#define TESTCONSTRUCTPLUTC_MSGENORM
#define SUB(func, statusptr)
#define ERROR(code, msg, statement)
#define INFO(statement)
#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)
#define LAL_PI_2
double REAL8
int16_t INT2
int64_t INT8
uint16_t UINT2
char CHAR
int32_t INT4
#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
REAL8 HoughDT
Hough Map derivative pixel type.
Definition: PHMD.h:121
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
INT2 rightB2
Border index to be used (stop-border ‘ ’)
Definition: LUT.h:238
INT2 leftB1
Border index to be used (start-border ‘ ’)
Definition: LUT.h:235
INT2 piece1min
If piece1min piece1max no corrections should be added.
Definition: LUT.h:240
INT2 piece2max
Interval limits of the (second piece) correction to the first column.
Definition: LUT.h:241
INT2 rightB1
Border index to be used (stop-border ‘ ’)
Definition: LUT.h:236
INT2 piece1max
Interval limits of the (first piece) correction to the first column.
Definition: LUT.h:239
INT2 leftB2
Border index to be used (start-border ‘ ’)
Definition: LUT.h:237
INT2 piece2min
If piece2min piece2max no corrections should be added.
Definition: LUT.h:242
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
INT4 yLower
lower y pixel affected by this border and yUpper<yLower or yUpper<0 are possible
Definition: LUT.h:223
UINT2 ySide
length of xPixel
Definition: LUT.h:225
INT4 yUpper
upper y pixel affected by this border
Definition: LUT.h:222
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
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
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 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
INT4 nBin
Exact number of bins affecting the patch.
Definition: LUT.h:254
HOUGHBorder * border
The annulus borders.
Definition: LUT.h:258
INT4 iniBin
First bin affecting the patch with respect to f0.
Definition: LUT.h:253
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
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