Loading [MathJax]/extensions/TeX/AMSsymbols.js
LAL 7.7.0.1-5e288d3
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
ReadFTSeriesTest.c
Go to the documentation of this file.
1/*
2* Copyright (C) 2007 Cristina Valeria Torres, Jolien Creighton, John Whelan
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 * \file
22 * \ingroup ReadFTSeries_h
23 * \author Torres, C. W.
24 *
25 * \brief Tests the routines in \ref ReadTimeSeries_c and \ref ReadFrequencySeries_c.
26 *
27 * ### Usage ###
28 *
29 * \code
30 * ReadFTSeriesTest
31 * \endcode
32 *
33 * ### Description ###
34 *
35 * For each of the real and complex datatypes (single and double
36 * precision), this program fills a Time- and FrequencySeries, prints
37 * them to disk with the appropriate
38 * \c LALPrint<datatype><tt>FrequencySeries()</tt>
39 * and \c LALPrint<datatype><tt>TimeSeries()</tt>
40 * routines, then reads them back in with the appropriate
41 * \c LALRead<datatype><tt>FrequencySeries()</tt>
42 * and \c LALRead<datatype><tt>TimeSeries()</tt>
43 * routines and checks to make sure the resulting series agree, printing the results to standard error.
44 */
45
46/**\name Error Codes */ /** @{ */
47#define READFTSERIESTESTC_ENOM 0 /**< Nominal exit */
48#define READFTSERIESTESTC_ECHK 1 /**< Error checking failed to catch bad data */
49#define READFTSERIESTESTC_EFUN 2 /**< Subroutine returned error for valid data */
50#define READFTSERIESTESTC_EFLS 3 /**< Subroutine returned unexpected results */
51/** @} */
52
53/** \cond DONT_DOXYGEN */
54#define READFTSERIESTESTC_MSGENOM "Nominal exit"
55#define READFTSERIESTESTC_MSGECHK "Error checking failed to catch bad data"
56#define READFTSERIESTESTC_MSGEFUN "Subroutine returned error for valid data"
57#define READFTSERIESTESTC_MSGEFLS "Subroutine returned unexpected results"
58
59
60#include <lal/Units.h>
61#include <lal/ReadFTSeries.h>
62#include <lal/PrintFTSeries.h>
63#include <math.h>
64#include <lal/LALStdlib.h>
65#include <lal/AVFactories.h>
66#define READFTSERIESTEST_TOL 1e6
67#define READFTSERIESTEST_LEN 20
68
69
70
71int main( void )
72{
73 static LALStatus status;
74
75 REAL4Sequence *sSequenceIn;
76 REAL4Sequence *sSequenceOut;
77 REAL8Sequence *dSequenceIn;
78 REAL8Sequence *dSequenceOut;
79
80 COMPLEX8Sequence *cSequenceIn;
81 COMPLEX8Sequence *cSequenceOut;
82 COMPLEX16Sequence *zSequenceIn;
83 COMPLEX16Sequence *zSequenceOut;
84
85
86 REAL4FrequencySeries sFrequencySeries;
87 REAL8FrequencySeries dFrequencySeries;
88 COMPLEX8FrequencySeries cFrequencySeries;
89 COMPLEX16FrequencySeries zFrequencySeries;
90
91 REAL4FrequencySeries sFrequencySeries2;
92 REAL8FrequencySeries dFrequencySeries2;
93 COMPLEX8FrequencySeries cFrequencySeries2;
94 COMPLEX16FrequencySeries zFrequencySeries2;
95
96 REAL4TimeSeries sTimeSeries;
97 REAL8TimeSeries dTimeSeries;
98 COMPLEX8TimeSeries cTimeSeries;
99 COMPLEX16TimeSeries zTimeSeries;
100
101 REAL4TimeSeries sTimeSeries2;
102 REAL8TimeSeries dTimeSeries2;
103 COMPLEX8TimeSeries cTimeSeries2;
104 COMPLEX16TimeSeries zTimeSeries2;
105
106 REAL4 *sData;
107 REAL8 *dData;
108 COMPLEX8 *cData;
109 COMPLEX16 *zData;
110
111 /* Boolean Vars */
112 BOOLEAN unitComp;
113
114 /* variables for units */
115 RAT4 raise;
116 LALUnit strainToMinus2;
117 LALUnit adcToMinus2;
118 LALUnit adcStrain;
119
120
121 /* This routine should generate a file with data */
122 /* to be read by ReadFTSeries.c*/
123 LIGOTimeGPS t;
124 UINT4 i;
125
126
127 /* Data Test Variable */
128 UINT4 j;
129
130
131 fprintf(stderr,"Testing value of LALUnitTextSize ... ");
132 if ( (int)LALSupportUnitTextSize != (int)LALUnitTextSize )
133 {
134 fprintf(stderr,"UnitTextSize mismatch: [ReadFTSeriesTest:%s]\n",
135 READFTSERIESTESTC_MSGEFLS);
136 return READFTSERIESTESTC_EFLS;
137 }
138 fprintf(stderr,"PASS\n");
139
140 t.gpsSeconds = 0;
141 t.gpsNanoSeconds = 0;
142
143 fprintf(stderr,"Testing Print/Read COMPLEX8FrequencySeries ... ");
144
145 cSequenceIn = NULL;
146 LALCCreateVector(&status, &cSequenceIn, READFTSERIESTEST_LEN);
147 if (status.statusCode != 0)
148 {
149 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
150 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
151 return READFTSERIESTESTC_EFUN;
152 }
153 for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
154 {
155 *(cData) = crectf( i, i+1 );
156 }
157
158 strncpy(cFrequencySeries.name,"Complex frequency series",LALNameLength);
159 cFrequencySeries.sampleUnits = lalHertzUnit;
160 cFrequencySeries.deltaF = 1;
161 cFrequencySeries.epoch = t;
162 cFrequencySeries.f0 = 5;
163
164 cFrequencySeries.data = cSequenceIn;
165
166 LALCPrintFrequencySeries(&cFrequencySeries, "cFSInput.dat");
167 if (status.statusCode != 0)
168 {
169 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
170 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
171 return READFTSERIESTESTC_EFUN;
172 }
173
174 cSequenceOut = NULL;
175 LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
176 if (status.statusCode != 0)
177 {
178 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
179 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
180 return READFTSERIESTESTC_EFUN;
181 }
182
183 cFrequencySeries2.data = cSequenceOut;
184
185 LALCReadFrequencySeries(&status, &cFrequencySeries2, "./cFSInput.dat");
186 if (status.statusCode != 0)
187 {
188 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
189 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
190 return READFTSERIESTESTC_EFUN;
191 }
192
193 if (fabs(cFrequencySeries.deltaF - cFrequencySeries.deltaF)/
194 cFrequencySeries.deltaF > READFTSERIESTEST_TOL)
195 {
196 fprintf(stderr,"DeltaF MisMatch [ReadFTSeriesTest:%s]\n",
197 READFTSERIESTESTC_MSGEFLS);
198 return READFTSERIESTESTC_EFLS;
199 }
200 if (strcmp(cFrequencySeries.name,cFrequencySeries2.name) != 0)
201 {
202 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
203 READFTSERIESTESTC_MSGEFLS);
204 return READFTSERIESTESTC_EFLS;
205 }
206 if ((cFrequencySeries.epoch.gpsSeconds) !=
207 (cFrequencySeries2.epoch.gpsSeconds))
208 {
209 fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
210 READFTSERIESTESTC_MSGEFLS);
211 return READFTSERIESTESTC_EFLS;
212 }
213 if ((cFrequencySeries.epoch.gpsNanoSeconds) !=
214 (cFrequencySeries2.epoch.gpsNanoSeconds))
215 {
216 fprintf(stderr,"Epoch NanosecondMismatch [ReadFTSeriesTest:%s]\n",
217 READFTSERIESTESTC_MSGEFLS);
218 return READFTSERIESTESTC_EFLS;
219 }
220 if ((cFrequencySeries.f0) ?
221 (fabs(cFrequencySeries.f0 - cFrequencySeries2.f0)/cFrequencySeries.f0) :
222 (fabs(cFrequencySeries.f0 - cFrequencySeries2.f0) >
223 READFTSERIESTEST_TOL))
224 {
225 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
226 READFTSERIESTESTC_MSGEFLS);
227 return READFTSERIESTESTC_EFLS;
228 }
229 unitComp = XLALUnitCompare(&cFrequencySeries.sampleUnits,&cFrequencySeries2.sampleUnits);
230
231 if (unitComp != 0)
232 {
233 fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
234 READFTSERIESTESTC_MSGEFLS);
235 return READFTSERIESTESTC_EFLS;
236 }
237
238 for (j = 0; j < cSequenceIn->length;j++)
239 {
240 if ((crealf(cSequenceIn->data[j]) ?
241 fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
242 /crealf(cSequenceIn->data[j]))
243 :fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
244 READFTSERIESTEST_TOL)
245 {
246 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
247 READFTSERIESTESTC_MSGEFLS);
248 return READFTSERIESTESTC_EFLS;
249 }
250 if ((cimagf(cSequenceIn->data[j]) ?
251 fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
252 /cimagf(cSequenceIn->data[j]))
253 :fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
254 READFTSERIESTEST_TOL)
255 {
256 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
257 READFTSERIESTESTC_MSGEFLS);
258 return READFTSERIESTESTC_EFLS;
259 }
260 }
261
262 fprintf(stderr,"PASS\n");
263
264 fprintf(stderr,"Testing Print/Read COMPLEX16FrequencySeries ... ");
265
266 /* Test case 2 */
267
268 t.gpsSeconds = 45678;
269 t.gpsNanoSeconds = 89065834;
270
271 zSequenceIn = NULL;
272 LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
273 if (status.statusCode != 0)
274 {
275 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
276 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
277 return READFTSERIESTESTC_EFUN;
278 }
279
280
281 for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
282 {
283 *(zData) = crect( i/4.0, (i+1)/5.0 );
284 }
285 zFrequencySeries.sampleUnits = lalDimensionlessUnit;
286 strncpy(zFrequencySeries.name,"Complex frequency series",LALNameLength);
287 zFrequencySeries.deltaF = 1.3;
288 zFrequencySeries.epoch = t;
289 zFrequencySeries.f0 = 0;
290 zFrequencySeries.data = zSequenceIn;
291
292 LALZPrintFrequencySeries(&zFrequencySeries, "zFSInput.dat");
293 if (status.statusCode != 0)
294 {
295 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
296 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
297 return READFTSERIESTESTC_EFUN;
298 }
299
300 zSequenceOut = NULL;
301 LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
302 if (status.statusCode != 0)
303 {
304 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
305 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
306 return READFTSERIESTESTC_EFUN;
307 }
308
309 zFrequencySeries2.data = zSequenceOut;
310
311 LALZReadFrequencySeries(&status, &zFrequencySeries2, "./zFSInput.dat");
312 if (status.statusCode != 0)
313 {
314 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
315 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
316 return READFTSERIESTESTC_EFUN;
317 }
318
319 if ((zFrequencySeries.deltaF) != (zFrequencySeries2.deltaF))
320 {
321 fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
322 READFTSERIESTESTC_MSGEFLS);
323 return READFTSERIESTESTC_EFLS;
324 }
325 if (strcmp(zFrequencySeries.name,zFrequencySeries2.name) != 0)
326 {
327 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
328 READFTSERIESTESTC_MSGEFLS);
329 return READFTSERIESTESTC_EFLS;
330 }
331 if ((zFrequencySeries.epoch.gpsSeconds) !=
332 (zFrequencySeries2.epoch.gpsSeconds))
333 {
334 fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
335 READFTSERIESTESTC_MSGEFLS);
336 return READFTSERIESTESTC_EFLS;
337 }
338 if ((zFrequencySeries.epoch.gpsNanoSeconds) !=
339 (zFrequencySeries2.epoch.gpsNanoSeconds))
340 {
341 fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
342 READFTSERIESTESTC_MSGEFLS);
343 return READFTSERIESTESTC_EFLS;
344 }
345 if (zFrequencySeries.f0 ?
346 (fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)/zFrequencySeries.f0)
347 : (fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)) >
348 READFTSERIESTEST_TOL)
349 {
350 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
351 READFTSERIESTESTC_MSGEFLS);
352 return READFTSERIESTESTC_EFLS;
353 }
354 unitComp = XLALUnitCompare(&zFrequencySeries.sampleUnits,&zFrequencySeries2.sampleUnits);
355
356 if (unitComp != 0)
357 {
358 fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
359 READFTSERIESTESTC_MSGEFLS);
360 return READFTSERIESTESTC_EFLS;
361 }
362
363 for (j = 0; j < zSequenceIn->length;j++)
364 {
365 if ((creal(zSequenceIn->data[j]) ?
366 fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
367 /creal(zSequenceIn->data[j])) :
368 fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
369 READFTSERIESTEST_TOL)
370 {
371 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
372 READFTSERIESTESTC_MSGEFLS);
373 return READFTSERIESTESTC_EFLS;
374 }
375 if ((cimag(zSequenceIn->data[j]) ?
376 fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
377 /cimag(zSequenceIn->data[j])) :
378 fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
379 READFTSERIESTEST_TOL)
380 {
381 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
382 READFTSERIESTESTC_MSGEFLS);
383 return READFTSERIESTESTC_EFLS;
384 }
385 }
386
387 fprintf(stderr,"PASS\n");
388
389 fprintf(stderr,"Testing Print/Read REAL8FrequencySeries ... ");
390
391 /* Test case 3 */
392 t.gpsSeconds = 45678;
393 t.gpsNanoSeconds = 89065834;
394
395 dSequenceIn = NULL;
396 LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
397 if (status.statusCode != 0)
398 {
399 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
400 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
401 return READFTSERIESTESTC_EFUN;
402 }
403
404 for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
405 {
406 *(dData) = 0.005;
407 }
408
409 strncpy(dFrequencySeries.name,"Complex frequency series",LALNameLength);
410 /* set units */
411 raise.numerator = -2;
412 raise.denominatorMinusOne = 0;
413 if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
414 {
415 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
416 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
417 return READFTSERIESTESTC_EFUN;
418 }
419
420 if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
421 {
422 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
423 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
424 return READFTSERIESTESTC_EFUN;
425 }
426
427 if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
428 {
429 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
430 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
431 return READFTSERIESTESTC_EFUN;
432 }
433
434 if (XLALUnitMultiply(&dFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
435 {
436 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
437 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
438 return READFTSERIESTESTC_EFUN;
439 }
440
441
442 dFrequencySeries.deltaF = 1.3;
443 dFrequencySeries.epoch = t;
444 dFrequencySeries.f0 = 0;
445 dFrequencySeries.data = dSequenceIn;
446 LALDPrintFrequencySeries(&dFrequencySeries, "dFSInput.dat");
447 if (status.statusCode != 0)
448 {
449 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
450 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
451 return READFTSERIESTESTC_EFUN;
452 }
453
454
455 dSequenceOut = NULL;
456 LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
457 if (status.statusCode != 0)
458 {
459 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
460 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
461 return READFTSERIESTESTC_EFUN;
462 }
463
464
465 dFrequencySeries2.data = dSequenceOut;
466
467 LALDReadFrequencySeries(&status, &dFrequencySeries2, "./dFSInput.dat");
468 if (status.statusCode != 0)
469 {
470 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
471 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
472 return READFTSERIESTESTC_EFUN;
473 }
474
475 if ((dFrequencySeries.deltaF) != (dFrequencySeries.deltaF))
476 {
477 fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
478 READFTSERIESTESTC_MSGEFLS);
479 return READFTSERIESTESTC_EFLS;
480 }
481 if (strcmp(dFrequencySeries.name,dFrequencySeries2.name) != 0)
482 {
483 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
484 READFTSERIESTESTC_MSGEFLS);
485 return READFTSERIESTESTC_EFLS;
486 }
487 if ((dFrequencySeries.epoch.gpsSeconds)
488 != (dFrequencySeries2.epoch.gpsSeconds))
489 {
490 fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
491 READFTSERIESTESTC_MSGEFLS);
492 return READFTSERIESTESTC_EFLS;
493 }
494 if ((dFrequencySeries.epoch.gpsSeconds)
495 != (dFrequencySeries2.epoch.gpsSeconds))
496 {
497 fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
498 READFTSERIESTESTC_MSGEFLS);
499 return READFTSERIESTESTC_EFLS;
500 }
501 if (dFrequencySeries.f0 ?
502 (fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)/dFrequencySeries.f0)
503 : (fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)) >
504 READFTSERIESTEST_TOL)
505 {
506 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
507 READFTSERIESTESTC_MSGEFLS);
508 return READFTSERIESTESTC_EFLS;
509 }
510
511 unitComp = XLALUnitCompare(&dFrequencySeries.sampleUnits,&dFrequencySeries2.sampleUnits);
512
513 if (unitComp != 0)
514 {
515 fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
516 READFTSERIESTESTC_MSGEFLS);
517 return READFTSERIESTESTC_EFLS;
518 }
519
520
521 for (j = 0; j < dSequenceIn->length;j++)
522 {
523 if ((dSequenceIn->data[j] ?
524 fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
525 /dSequenceIn->data[j])
526 :fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
527 READFTSERIESTEST_TOL)
528 {
529 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
530 READFTSERIESTESTC_MSGEFLS);
531 return READFTSERIESTESTC_EFLS;
532 }
533
534 }
535
536
537 fprintf(stderr,"PASS\n");
538
539 fprintf(stderr,"Testing Print/Read REAL4FrequencySeries ... ");
540
541
542 /* Test case 4 */
543 t.gpsSeconds = 45678;
544 t.gpsNanoSeconds = 89065834;
545
546 sSequenceIn = NULL;
547 LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
548 if (status.statusCode != 0)
549 {
550 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
551 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
552 return READFTSERIESTESTC_EFUN;
553 }
554
555 for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
556 {
557 *(sData) = 0.005;
558 }
559
560 strncpy(sFrequencySeries.name,"Complex frequency series",LALNameLength);
561 /* set units */
562 raise.numerator = -2;
563 raise.denominatorMinusOne = 0;
564 if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
565 {
566 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
567 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
568 return READFTSERIESTESTC_EFUN;
569 }
570
571 if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
572 {
573 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
574 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
575 return READFTSERIESTESTC_EFUN;
576 }
577
578 if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
579 {
580 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
581 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
582 return READFTSERIESTESTC_EFUN;
583 }
584
585 if (XLALUnitMultiply(&sFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
586 {
587 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
588 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
589 return READFTSERIESTESTC_EFUN;
590 }
591
592
593 sFrequencySeries.deltaF = 1.3;
594 sFrequencySeries.epoch = t;
595 sFrequencySeries.f0 = 5;
596 sFrequencySeries.data = sSequenceIn;
597
598 sSequenceOut = NULL;
599 LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
600 if (status.statusCode != 0)
601 {
602 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
603 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
604 return READFTSERIESTESTC_EFUN;
605 }
606
607 sFrequencySeries2.data = sSequenceOut;
608 LALSPrintFrequencySeries(&sFrequencySeries, "sFSInput.dat");
609 if (status.statusCode != 0)
610 {
611 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
612 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
613 return READFTSERIESTESTC_EFUN;
614 }
615
616 LALSReadFrequencySeries(&status, &sFrequencySeries2, "./sFSInput.dat");
617 if (status.statusCode != 0)
618 {
619 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
620 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
621 return READFTSERIESTESTC_EFUN;
622 }
623
624 if (fabs(sFrequencySeries.deltaF - sFrequencySeries2.deltaF)
625 /sFrequencySeries.deltaF > READFTSERIESTEST_TOL)
626 {
627 fprintf(stderr,"Deltaf Mismatch [ReadFTSeriesTest:%s]\n",
628 READFTSERIESTESTC_MSGEFLS);
629 return READFTSERIESTESTC_EFLS;
630 }
631
632 if (strcmp(sFrequencySeries.name,sFrequencySeries2.name)!=0)
633 {
634 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
635 READFTSERIESTESTC_MSGEFLS);
636 return READFTSERIESTESTC_EFLS;
637 }
638
639 if ((sFrequencySeries.epoch.gpsSeconds) !=
640 (sFrequencySeries2.epoch.gpsSeconds))
641 {
642 fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
643 READFTSERIESTESTC_MSGEFLS);
644 return READFTSERIESTESTC_EFLS;
645 }
646 if ((sFrequencySeries.epoch.gpsNanoSeconds) !=
647 (sFrequencySeries2.epoch.gpsNanoSeconds))
648 {
649 fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
650 READFTSERIESTESTC_MSGEFLS);
651 return READFTSERIESTESTC_EFLS;
652 }
653 if (sFrequencySeries.f0 ?
654 (fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)/sFrequencySeries.f0)
655 : (fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)) >
656 READFTSERIESTEST_TOL)
657 {
658 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
659 READFTSERIESTESTC_MSGEFLS);
660 return READFTSERIESTESTC_EFLS;
661 }
662
663 unitComp = XLALUnitCompare(&sFrequencySeries.sampleUnits,&sFrequencySeries2.sampleUnits);
664
665 if (unitComp != 0)
666 {
667 fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
668 READFTSERIESTESTC_MSGEFLS);
669 return READFTSERIESTESTC_EFLS;
670 }
671
672 for (j = 0; j < sSequenceIn->length;j++)
673 {
674 if ((sSequenceIn->data[j] ?
675 fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
676 /sSequenceIn->data[j])
677 :fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
678 READFTSERIESTEST_TOL)
679 {
680 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
681 READFTSERIESTESTC_MSGEFLS);
682 return READFTSERIESTESTC_EFLS;
683 }
684 }
685
686
687 LALCDestroyVector(&status, &cSequenceIn);
688 if (status.statusCode != 0)
689 {
690 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
691 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
692 return READFTSERIESTESTC_EFUN;
693 }
694
695 LALCDestroyVector(&status, &cSequenceOut);
696 if (status.statusCode != 0)
697 {
698 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
699 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
700 return READFTSERIESTESTC_EFUN;
701 }
702
703 LALZDestroyVector(&status, &zSequenceIn);
704 if (status.statusCode != 0)
705 {
706 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
707 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
708 return READFTSERIESTESTC_EFUN;
709 }
710 LALZDestroyVector(&status, &zSequenceOut);
711 if (status.statusCode != 0)
712 {
713 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
714 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
715 return READFTSERIESTESTC_EFUN;
716 }
717
718 LALDDestroyVector(&status, &dSequenceIn);
719 if (status.statusCode != 0)
720 {
721 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
722 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
723 return READFTSERIESTESTC_EFUN;
724 }
725
726 LALDDestroyVector(&status, &dSequenceOut);
727 if (status.statusCode != 0)
728 {
729 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
730 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
731 return READFTSERIESTESTC_EFUN;
732 }
733
734 LALSDestroyVector(&status, &sSequenceIn);
735 if (status.statusCode != 0)
736 {
737 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
738 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
739 return READFTSERIESTESTC_EFUN;
740 }
741
742 LALSDestroyVector(&status, &sSequenceOut);
743 if (status.statusCode != 0)
744 {
745 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
746 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
747 return READFTSERIESTESTC_EFUN;
748 }
749
750 fprintf(stderr,"PASS\n");
751
752
753 fprintf(stderr,"Testing Print/Read REAL4TimeSeries ... ");
754
755 /* Here is where testing for ReadTimeSeries is done */
756 /* S Case ReadTimeSeries */
757
758 raise.numerator = -2;
759 raise.denominatorMinusOne = 0;
760 if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
761 {
762 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
763 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
764 return READFTSERIESTESTC_EFUN;
765 }
766
767 if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
768 {
769 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
770 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
771 return READFTSERIESTESTC_EFUN;
772 }
773
774 if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
775 {
776 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
777 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
778 return READFTSERIESTESTC_EFUN;
779 }
780
781 if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
782 {
783 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
784 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
785 return READFTSERIESTESTC_EFUN;
786 }
787
788
789 t.gpsSeconds = 45678;
790 t.gpsNanoSeconds = 89065834;
791
792 sSequenceIn = NULL;
793 LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
794 if (status.statusCode != 0)
795 {
796 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
797 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
798 return READFTSERIESTESTC_EFUN;
799 }
800
801
802 for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
803 {
804 *(sData) = 0.005;
805 }
806 strncpy(sTimeSeries.name,"Real4 Time series",LALNameLength);
807 sTimeSeries.deltaT = 1.3;
808 sTimeSeries.epoch = t;
809 sTimeSeries.data = sSequenceIn;
810 sTimeSeries.f0 = 5;
811 LALSPrintTimeSeries(&sTimeSeries, "sTSInput.dat");
812 if (status.statusCode != 0)
813 {
814 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
815 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
816 return READFTSERIESTESTC_EFUN;
817 }
818
819 sSequenceOut = NULL;
820 LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
821 if (status.statusCode != 0)
822 {
823 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
824 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
825 return READFTSERIESTESTC_EFUN;
826 }
827
828 sTimeSeries2.data = sSequenceOut;
829
830 LALSReadTimeSeries(&status, &sTimeSeries2, "./sTSInput.dat");
831 if (status.statusCode != 0)
832 {
833 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
834 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
835 return READFTSERIESTESTC_EFUN;
836 }
837
838 if (fabs(sTimeSeries.deltaT-sTimeSeries2.deltaT) /
839 sTimeSeries.deltaT > READFTSERIESTEST_TOL)
840 {
841 fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
842 READFTSERIESTESTC_MSGEFLS);
843 return READFTSERIESTESTC_EFLS;
844 }
845
846 if (strcmp(sFrequencySeries.name,sFrequencySeries2.name) != 0)
847 {
848 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
849 READFTSERIESTESTC_MSGEFLS);
850 return READFTSERIESTESTC_EFLS;
851 }
852
853 if ((sTimeSeries.epoch.gpsSeconds) != (sTimeSeries2.epoch.gpsSeconds))
854 {
855 fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
856 READFTSERIESTESTC_MSGEFLS);
857 return READFTSERIESTESTC_EFLS;
858 }
859 if ((sTimeSeries.epoch.gpsNanoSeconds) != (sTimeSeries2.epoch.gpsNanoSeconds))
860 {
861 fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
862 READFTSERIESTESTC_MSGEFLS);
863 return READFTSERIESTESTC_EFLS;
864 }
865 /* printf("%f ... %f f0 value\n",sTimeSeries.f0,sTimeSeries2.f0);*/
866 if (sTimeSeries.f0 ?
867 (fabs(sTimeSeries.f0 - sTimeSeries2.f0)/sTimeSeries.f0)
868 : (fabs(sTimeSeries.f0 - sTimeSeries2.f0)) >
869 READFTSERIESTEST_TOL)
870 {
871 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
872 READFTSERIESTESTC_MSGEFLS);
873 return READFTSERIESTESTC_EFLS;
874 }
875
876 unitComp = XLALUnitCompare(&sTimeSeries.sampleUnits,&sTimeSeries2.sampleUnits);
877
878 if (unitComp != 0)
879 {
880 fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
881 READFTSERIESTESTC_MSGEFLS);
882 return READFTSERIESTESTC_EFLS;
883 }
884 for (j = 0; j < sSequenceIn->length;j++)
885 {
886 if ((sSequenceIn->data[j] ?
887 fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
888 /sSequenceIn->data[j])
889 :fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
890 READFTSERIESTEST_TOL)
891 {
892 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
893 READFTSERIESTESTC_MSGEFLS);
894 return READFTSERIESTESTC_EFLS;
895 }
896 }
897
898 fprintf(stderr,"PASS\n");
899
900 fprintf(stderr,"Testing Print/Read COMPLEX16TimeSeries ... ");
901
902 /* Z case ReadTimeSeries*/
903
904 raise.numerator = -2;
905 raise.denominatorMinusOne = 0;
906 if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
907 {
908 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
909 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
910 return READFTSERIESTESTC_EFUN;
911 }
912
913 if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
914 {
915 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
916 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
917 return READFTSERIESTESTC_EFUN;
918 }
919
920 if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
921 {
922 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
923 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
924 return READFTSERIESTESTC_EFUN;
925 }
926
927 if (XLALUnitMultiply(&zTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
928 {
929 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
930 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
931 return READFTSERIESTESTC_EFUN;
932 }
933
934 t.gpsSeconds = 45678;
935 t.gpsNanoSeconds = 89065834;
936
937 zSequenceIn = NULL;
938 LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
939 if (status.statusCode != 0)
940 {
941 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
942 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
943 return READFTSERIESTESTC_EFUN;
944 }
945
946
947 for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
948 {
949 *(zData) = crect( 0.005, 1 );
950 }
951 strncpy(zTimeSeries.name,"Complex16 Time series",LALNameLength);
952 zTimeSeries.deltaT = 1.3;
953 zTimeSeries.epoch = t;
954 zTimeSeries.data = zSequenceIn;
955 zTimeSeries.f0 = 0;
956 LALZPrintTimeSeries(&zTimeSeries, "zTSInput.dat");
957 if (status.statusCode != 0)
958 {
959 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
960 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
961 return READFTSERIESTESTC_EFUN;
962 }
963
964 zSequenceOut = NULL;
965 LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
966 if (status.statusCode != 0)
967 {
968 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
969 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
970 return READFTSERIESTESTC_EFUN;
971 }
972
973 zTimeSeries2.data = zSequenceOut;
974
975 LALZReadTimeSeries(&status, &zTimeSeries2, "./zTSInput.dat");
976 if (status.statusCode != 0)
977 {
978 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
979 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
980 return READFTSERIESTESTC_EFUN;
981 }
982
983 if (fabs(zTimeSeries.deltaT) - (zTimeSeries2.deltaT)/zTimeSeries.deltaT >
984 READFTSERIESTEST_TOL)
985 {
986 fprintf(stderr,"Mismatch DeltaT [ReadFTSeriesTest:%s]\n",
987 READFTSERIESTESTC_MSGEFLS);
988 return READFTSERIESTESTC_EFLS;
989 }
990
991
992 if (strcmp(zTimeSeries.name,zTimeSeries2.name) != 0)
993 {
994 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
995 READFTSERIESTESTC_MSGEFLS);
996 return READFTSERIESTESTC_EFLS;
997 }
998
999 if ((zTimeSeries.epoch.gpsSeconds) != (zTimeSeries2.epoch.gpsSeconds))
1000 {
1001 fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
1002 READFTSERIESTESTC_MSGEFLS);
1003 return READFTSERIESTESTC_EFLS;
1004 }
1005 if ( (zTimeSeries.epoch.gpsNanoSeconds)
1006 != (zTimeSeries2.epoch.gpsNanoSeconds) )
1007 {
1008 fprintf(stderr,"Epoch Nanosecond Mismatch [ReadFTSeriesTest:%s]\n",
1009 READFTSERIESTESTC_MSGEFLS);
1010 return READFTSERIESTESTC_EFLS;
1011 }
1012
1013 if (zTimeSeries.f0 ?
1014 (fabs(zTimeSeries.f0 - zTimeSeries2.f0)/zTimeSeries.f0)
1015 : (fabs(zTimeSeries.f0 - zTimeSeries2.f0)) >
1016 READFTSERIESTEST_TOL)
1017 {
1018 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
1019 READFTSERIESTESTC_MSGEFLS);
1020 return READFTSERIESTESTC_EFLS;
1021 }
1022
1023 unitComp = XLALUnitCompare(&zTimeSeries.sampleUnits,&zTimeSeries2.sampleUnits);
1024
1025 if (unitComp != 0)
1026 {
1027 fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
1028 READFTSERIESTESTC_MSGEFLS);
1029 return READFTSERIESTESTC_EFUN;
1030 }
1031
1032 for (j = 0; j < zSequenceIn->length;j++)
1033 {
1034 if ((creal(zSequenceIn->data[j]) ?
1035 fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
1036 /creal(zSequenceIn->data[j]))
1037 :fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
1038 READFTSERIESTEST_TOL)
1039 {
1040 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
1041 READFTSERIESTESTC_MSGEFLS);
1042 return READFTSERIESTESTC_EFLS;
1043 }
1044 if ((cimag(zSequenceIn->data[j]) ?
1045 fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
1046 /cimag(zSequenceIn->data[j]))
1047 :fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
1048 READFTSERIESTEST_TOL)
1049 {
1050 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
1051 READFTSERIESTESTC_MSGEFLS);
1052 return READFTSERIESTESTC_EFLS;
1053 }
1054 }
1055
1056 fprintf(stderr,"PASS\n");
1057
1058 fprintf(stderr,"Testing Print/Read REAL8TimeSeries ... ");
1059
1060 /* D case ReadTimeSeries*/
1061
1062 raise.numerator = -2;
1063 raise.denominatorMinusOne = 0;
1064 if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
1065 {
1066 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1067 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1068 return READFTSERIESTESTC_EFUN;
1069 }
1070 if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
1071 {
1072 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1073 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1074 return READFTSERIESTESTC_EFUN;
1075 }
1076
1077 if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
1078 {
1079 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1080 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1081 return READFTSERIESTESTC_EFUN;
1082 }
1083
1084 if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
1085 {
1086 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1087 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1088 return READFTSERIESTESTC_EFUN;
1089 }
1090
1091 strncpy(dTimeSeries.name,"REAL8 Time series",LALNameLength);
1092 dTimeSeries.sampleUnits = lalHertzUnit;
1093 t.gpsSeconds = 4578;
1094 t.gpsNanoSeconds = 890634;
1095
1096 dSequenceIn = NULL;
1097 LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
1098 if (status.statusCode != 0)
1099 {
1100 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1101 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1102 return READFTSERIESTESTC_EFUN;
1103 }
1104
1105
1106 for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
1107 {
1108 *(dData) = 0.005;
1109 }
1110
1111 dTimeSeries.deltaT = 1.3;
1112 dTimeSeries.epoch = t;
1113 dTimeSeries.data = dSequenceIn;
1114 dTimeSeries.f0 = 0;
1115 LALDPrintTimeSeries(&dTimeSeries, "dTSInput.dat");
1116 if (status.statusCode != 0)
1117 {
1118 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1119 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1120 return READFTSERIESTESTC_EFUN;
1121 }
1122
1123 dSequenceOut = NULL;
1124 LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
1125 if (status.statusCode != 0)
1126 {
1127 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1128 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1129 return READFTSERIESTESTC_EFUN;
1130 }
1131
1132 dTimeSeries2.data = dSequenceOut;
1133 LALDReadTimeSeries(&status, &dTimeSeries2, "./dTSInput.dat");
1134 if (status.statusCode != 0)
1135 {
1136 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1137 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1138 return READFTSERIESTESTC_EFUN;
1139 }
1140
1141 if (fabs(dTimeSeries.deltaT) - (dTimeSeries2.deltaT)/dTimeSeries.deltaT
1142 > READFTSERIESTEST_TOL)
1143 {
1144 fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
1145 status.statusDescription );
1146 return READFTSERIESTESTC_EFLS;
1147 }
1148 if (strcmp(dTimeSeries.name,dTimeSeries2.name) != 0)
1149 {
1150 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
1151 status.statusDescription );
1152 return READFTSERIESTESTC_EFLS;
1153 }
1154
1155 if ((dTimeSeries.epoch.gpsSeconds) != (dTimeSeries2.epoch.gpsSeconds))
1156 {
1157 fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
1158 READFTSERIESTESTC_MSGEFLS);
1159 return READFTSERIESTESTC_EFLS;
1160 }
1161
1162 if ((dTimeSeries.epoch.gpsNanoSeconds)
1163 != (dTimeSeries2.epoch.gpsNanoSeconds))
1164 {
1165 fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
1166 READFTSERIESTESTC_MSGEFLS);
1167 return READFTSERIESTESTC_EFLS;
1168 }
1169
1170 if (dTimeSeries.f0 ?
1171 (fabs(dTimeSeries.f0 - dTimeSeries2.f0)/dTimeSeries.f0)
1172 : (fabs(dTimeSeries.f0 - dTimeSeries2.f0)) >
1173 READFTSERIESTEST_TOL)
1174 {
1175 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
1176 READFTSERIESTESTC_MSGEFLS);
1177 return READFTSERIESTESTC_EFLS;
1178 }
1179
1180 unitComp = XLALUnitCompare(&dTimeSeries.sampleUnits,&dTimeSeries2.sampleUnits);
1181
1182 if (unitComp != 0)
1183 {
1184 fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
1185 READFTSERIESTESTC_MSGEFLS);
1186 return READFTSERIESTESTC_EFLS;
1187 }
1188
1189 for (j = 0; j < dSequenceIn->length;j++)
1190 {
1191 if ((dSequenceIn->data[j] ?
1192 fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
1193 /dSequenceIn->data[j])
1194 :fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
1195 READFTSERIESTEST_TOL)
1196 {
1197 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
1198 READFTSERIESTESTC_MSGEFLS);
1199 return READFTSERIESTESTC_EFLS;
1200 }
1201 }
1202
1203 fprintf(stderr,"PASS\n");
1204
1205 fprintf(stderr,"Testing Print/Read COMPLEX8TimeSeries ... ");
1206
1207 /* C case ReadTimeSeries*/
1208
1209 raise.numerator = -2;
1210 raise.denominatorMinusOne = 0;
1211 if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
1212 {
1213 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1214 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1215 return READFTSERIESTESTC_EFUN;
1216 }
1217
1218 if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
1219 {
1220 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1221 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1222 return READFTSERIESTESTC_EFUN;
1223 }
1224
1225 if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
1226 {
1227 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1228 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1229 return READFTSERIESTESTC_EFUN;
1230 }
1231
1232 if (XLALUnitMultiply(&cTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
1233 {
1234 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1235 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1236 return READFTSERIESTESTC_EFUN;
1237 }
1238
1239 t.gpsSeconds = 45678;
1240 t.gpsNanoSeconds = 89065834;
1241
1242 cSequenceIn = NULL;
1243 LALCCreateVector( &status, &cSequenceIn, READFTSERIESTEST_LEN);
1244 if (status.statusCode != 0)
1245 {
1246 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1247 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1248 return READFTSERIESTESTC_EFUN;
1249 }
1250
1251 for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
1252 {
1253 *(cData) = crectf( 0.005, 1 );
1254 }
1255 strncpy(cTimeSeries.name,"Complex8 Time series",LALNameLength);
1256 cTimeSeries.deltaT = 1.3;
1257 cTimeSeries.epoch = t;
1258 cTimeSeries.data = cSequenceIn;
1259 cTimeSeries.f0 = 0;
1260 cSequenceOut = NULL;
1261 LALCPrintTimeSeries(&cTimeSeries, "cTSInput.dat");
1262 if (status.statusCode != 0)
1263 {
1264 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1265 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1266 return READFTSERIESTESTC_EFUN;
1267 }
1268 LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
1269 if (status.statusCode != 0)
1270 {
1271 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1272 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1273 return READFTSERIESTESTC_EFUN;
1274 }
1275
1276 cTimeSeries2.data = cSequenceOut;
1277
1278 LALCReadTimeSeries(&status, &cTimeSeries2, "./cTSInput.dat");
1279 if (status.statusCode != 0)
1280 {
1281 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1282 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1283 return READFTSERIESTESTC_EFUN;
1284 }
1285
1286 if (fabs(cTimeSeries.deltaT - cTimeSeries2.deltaT)/cTimeSeries.deltaT
1287 > READFTSERIESTEST_TOL)
1288 {
1289 fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
1290 READFTSERIESTESTC_MSGEFLS);
1291 return READFTSERIESTESTC_EFLS;
1292 }
1293
1294 if (strcmp(cTimeSeries.name,cTimeSeries2.name) != 0)
1295 {
1296 fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
1297 READFTSERIESTESTC_MSGEFLS);
1298 return READFTSERIESTESTC_EFLS;
1299 }
1300 if ((cTimeSeries.epoch.gpsSeconds) != (cTimeSeries2.epoch.gpsSeconds))
1301 {
1302 fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
1303 READFTSERIESTESTC_MSGEFLS);
1304 return READFTSERIESTESTC_EFLS;
1305 }
1306 if ((cTimeSeries.epoch.gpsNanoSeconds)!=(cTimeSeries2.epoch.gpsNanoSeconds))
1307 {
1308 fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
1309 READFTSERIESTESTC_MSGEFLS);
1310 return READFTSERIESTESTC_EFLS;
1311 }
1312 if (cTimeSeries.f0 ?
1313 (fabs(cTimeSeries.f0 - cTimeSeries2.f0)/cTimeSeries.f0)
1314 : (fabs(cTimeSeries.f0 - cTimeSeries2.f0)) >
1315 READFTSERIESTEST_TOL)
1316 {
1317 fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
1318 READFTSERIESTESTC_MSGEFLS);
1319 return READFTSERIESTESTC_EFLS;
1320 }
1321
1322 unitComp = XLALUnitCompare(&cTimeSeries.sampleUnits,&cTimeSeries2.sampleUnits);
1323
1324 if (unitComp != 0)
1325 {
1326 fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
1327 READFTSERIESTESTC_MSGEFLS);
1328 return READFTSERIESTESTC_EFLS;
1329 }
1330
1331 for (j = 0; j < cSequenceIn->length;j++)
1332 {
1333 if ((crealf(cSequenceIn->data[j]) ?
1334 fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
1335 /crealf(cSequenceIn->data[j]))
1336 :fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
1337 READFTSERIESTEST_TOL)
1338 {
1339 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
1340 READFTSERIESTESTC_MSGEFLS);
1341 return READFTSERIESTESTC_EFLS;
1342 }
1343 if ((cimagf(cSequenceIn->data[j]) ?
1344 fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
1345 /cimagf(cSequenceIn->data[j]))
1346 :fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
1347 READFTSERIESTEST_TOL)
1348 {
1349 fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
1350 READFTSERIESTESTC_MSGEFLS);
1351 return READFTSERIESTESTC_EFLS;
1352 }
1353 }
1354
1355 fprintf(stderr,"PASS\n");
1356
1357 /* *******************Deallocate all memory****************** */
1358 LALCDestroyVector(&status, &cSequenceIn);
1359 if (status.statusCode != 0)
1360 {
1361 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1362 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1363 return READFTSERIESTESTC_EFUN;
1364 }
1365
1366 LALCDestroyVector(&status, &cSequenceOut);
1367 if (status.statusCode != 0)
1368 {
1369 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1370 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1371 return READFTSERIESTESTC_EFUN;
1372 }
1373
1374 LALZDestroyVector(&status, &zSequenceIn);
1375 if (status.statusCode != 0)
1376 {
1377 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1378 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1379 return READFTSERIESTESTC_EFUN;
1380 }
1381
1382 LALZDestroyVector(&status, &zSequenceOut);
1383 if (status.statusCode != 0)
1384 {
1385 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1386 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1387 return READFTSERIESTESTC_EFUN;
1388 }
1389
1390 LALDDestroyVector(&status, &dSequenceIn);
1391 if (status.statusCode != 0)
1392 {
1393 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1394 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1395 return READFTSERIESTESTC_EFUN;
1396 }
1397
1398 LALDDestroyVector(&status, &dSequenceOut);
1399 if (status.statusCode != 0)
1400 {
1401 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1402 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1403 return READFTSERIESTESTC_EFUN;
1404 }
1405
1406 LALSDestroyVector(&status, &sSequenceIn);
1407 if (status.statusCode != 0)
1408 {
1409 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1410 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1411 return READFTSERIESTESTC_EFUN;
1412 }
1413
1414 LALSDestroyVector(&status, &sSequenceOut);
1415 if (status.statusCode != 0)
1416 {
1417 fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
1418 status.statusDescription, READFTSERIESTESTC_MSGEFUN);
1419 return READFTSERIESTESTC_EFUN;
1420 }
1421
1422 LALCheckMemoryLeaks();
1423
1424 fprintf(stderr,"ReadFTSeries passed all tests.\n");
1425
1426 return READFTSERIESTESTC_ENOM;
1427
1428}
1429/** \endcond */
LALCheckMemoryLeaks
void LALCheckMemoryLeaks(void)
Definition: LALMalloc.c:784
READFTSERIESTESTC_ENOM
#define READFTSERIESTESTC_ENOM
Nominal exit.
Definition: ReadFTSeriesTest.c:47
READFTSERIESTESTC_EFLS
#define READFTSERIESTESTC_EFLS
Subroutine returned unexpected results.
Definition: ReadFTSeriesTest.c:50
READFTSERIESTESTC_EFUN
#define READFTSERIESTESTC_EFUN
Subroutine returned error for valid data.
Definition: ReadFTSeriesTest.c:49
fprintf
#define fprintf
Definition: StreamSeriesOutput.c:210
main
int main(int argc, char *argv[])
Definition: cache.c:25
crect
#define crect(re, im)
Construct a COMPLEX16 from real and imaginary parts.
Definition: LALAtomicDatatypes.h:123
BOOLEAN
unsigned char BOOLEAN
Boolean logical type, see Headers LAL(Atomic)Datatypes.h for more details.
Definition: LALAtomicDatatypes.h:39
COMPLEX16
double complex COMPLEX16
Double-precision floating-point complex number (16 bytes total)
Definition: LALAtomicDatatypes.h:120
REAL8
double REAL8
Double precision real floating-point number (8 bytes).
Definition: LALAtomicDatatypes.h:103
crectf
#define crectf(re, im)
Construct a COMPLEX8 from real and imaginary parts.
Definition: LALAtomicDatatypes.h:122
UINT4
uint32_t UINT4
Four-byte unsigned integer.
Definition: LALAtomicDatatypes.h:59
COMPLEX8
float complex COMPLEX8
Single-precision floating-point complex number (8 bytes total)
Definition: LALAtomicDatatypes.h:119
REAL4
float REAL4
Single precision real floating-point number (4 bytes).
Definition: LALAtomicDatatypes.h:102
LALNameLength
@ LALNameLength
Definition: LALDatatypes.h:508
LALCPrintFrequencySeries
void LALCPrintFrequencySeries(COMPLEX8FrequencySeries *series, const CHAR *filename)
LALSPrintFrequencySeries
void LALSPrintFrequencySeries(REAL4FrequencySeries *series, const CHAR *filename)
LALZPrintFrequencySeries
void LALZPrintFrequencySeries(COMPLEX16FrequencySeries *series, const CHAR *filename)
LALDPrintFrequencySeries
void LALDPrintFrequencySeries(REAL8FrequencySeries *series, const CHAR *filename)
LALZPrintTimeSeries
void LALZPrintTimeSeries(COMPLEX16TimeSeries *series, const CHAR *filename)
LALDPrintTimeSeries
void LALDPrintTimeSeries(REAL8TimeSeries *series, const CHAR *filename)
LALCPrintTimeSeries
void LALCPrintTimeSeries(COMPLEX8TimeSeries *series, const CHAR *filename)
LALSPrintTimeSeries
void LALSPrintTimeSeries(REAL4TimeSeries *series, const CHAR *filename)
LALDReadFrequencySeries
void LALDReadFrequencySeries(LALStatus *status, REAL8FrequencySeries *series, const CHAR *filename)
LALSReadFrequencySeries
void LALSReadFrequencySeries(LALStatus *status, REAL4FrequencySeries *series, const CHAR *filename)
LALCReadFrequencySeries
void LALCReadFrequencySeries(LALStatus *status, COMPLEX8FrequencySeries *series, const CHAR *filename)
LALZReadFrequencySeries
void LALZReadFrequencySeries(LALStatus *status, COMPLEX16FrequencySeries *series, const CHAR *filename)
LALSReadTimeSeries
void LALSReadTimeSeries(LALStatus *status, REAL4TimeSeries *series, const CHAR *filename)
LALZReadTimeSeries
void LALZReadTimeSeries(LALStatus *status, COMPLEX16TimeSeries *series, const CHAR *filename)
LALDReadTimeSeries
void LALDReadTimeSeries(LALStatus *status, REAL8TimeSeries *series, const CHAR *filename)
LALCReadTimeSeries
void LALCReadTimeSeries(LALStatus *status, COMPLEX8TimeSeries *series, const CHAR *filename)
XLALUnitCompare
int XLALUnitCompare(const LALUnit *unit1, const LALUnit *unit2)
Returns 0 if the the normal form of the two unit structures are the same or > 0 if they are different...
Definition: UnitCompare.c:90
LALUnitTextSize
@ LALUnitTextSize
Definition: Units.h:174
lalStrainUnit
const LALUnit lalStrainUnit
Strain [1].
Definition: UnitDefs.c:165
lalADCCountUnit
const LALUnit lalADCCountUnit
ADC count [count].
Definition: UnitDefs.c:166
lalHertzUnit
const LALUnit lalHertzUnit
Hertz [Hz].
Definition: UnitDefs.c:171
lalDimensionlessUnit
const LALUnit lalDimensionlessUnit
dimensionless units
Definition: UnitDefs.c:156
XLALUnitMultiply
LALUnit * XLALUnitMultiply(LALUnit *output, const LALUnit *unit1, const LALUnit *unit2)
This function multiplies together the LALUnit structures *(input->unitOne) and *(input->unitTwo),...
Definition: UnitMultiply.c:64
XLALUnitRaiseRAT4
LALUnit * XLALUnitRaiseRAT4(LALUnit *output, const LALUnit *input, const RAT4 *power)
Raises a LALUnit structure to a rational power given by the RAT4 structure power.
Definition: UnitRaise.c:56
LALCCreateVector
void LALCCreateVector(LALStatus *, COMPLEX8Vector **, UINT4)
LALZDestroyVector
void LALZDestroyVector(LALStatus *, COMPLEX16Vector **)
LALDCreateVector
void LALDCreateVector(LALStatus *, REAL8Vector **, UINT4)
LALCDestroyVector
void LALCDestroyVector(LALStatus *, COMPLEX8Vector **)
LALDDestroyVector
void LALDDestroyVector(LALStatus *, REAL8Vector **)
LALSDestroyVector
void LALSDestroyVector(LALStatus *, REAL4Vector **)
LALZCreateVector
void LALZCreateVector(LALStatus *, COMPLEX16Vector **, UINT4)
LALSCreateVector
void LALSCreateVector(LALStatus *, REAL4Vector **, UINT4)
lal.git_version.status
string status
Definition: git_version.py:32
COMPLEX16FrequencySeries
See DATATYPE-FrequencySeries types for documentation.
Definition: LALDatatypes.h:909
COMPLEX16FrequencySeries::name
CHAR name[LALNameLength]
Definition: LALDatatypes.h:910
COMPLEX16FrequencySeries::data
COMPLEX16Sequence * data
Definition: LALDatatypes.h:915
COMPLEX16TimeSeries
Time series of COMPLEX16 data, see DATATYPE-TimeSeries types for more details.
Definition: LALDatatypes.h:600
COMPLEX16TimeSeries::f0
REAL8 f0
The heterodyning frequency, in Hertz (zero if not heterodyned).
Definition: LALDatatypes.h:604
COMPLEX16TimeSeries::data
COMPLEX16Sequence * data
The sequence of sampled data.
Definition: LALDatatypes.h:606
COMPLEX16TimeSeries::sampleUnits
LALUnit sampleUnits
The physical units of the quantity being sampled.
Definition: LALDatatypes.h:605
COMPLEX16TimeSeries::name
CHAR name[LALNameLength]
The name of the time series.
Definition: LALDatatypes.h:601
COMPLEX16TimeSeries::epoch
LIGOTimeGPS epoch
The start time of the time series.
Definition: LALDatatypes.h:602
COMPLEX16TimeSeries::deltaT
REAL8 deltaT
The time step between samples of the time series in seconds.
Definition: LALDatatypes.h:603
COMPLEX16Vector
Vector of type COMPLEX16, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:172
COMPLEX16Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:176
COMPLEX16Vector::data
COMPLEX16 * data
Pointer to the data array.
Definition: LALDatatypes.h:177
COMPLEX8FrequencySeries
See DATATYPE-FrequencySeries types for documentation.
Definition: LALDatatypes.h:899
COMPLEX8FrequencySeries::name
CHAR name[LALNameLength]
Definition: LALDatatypes.h:900
COMPLEX8FrequencySeries::data
COMPLEX8Sequence * data
Definition: LALDatatypes.h:905
COMPLEX8TimeSeries
Time series of COMPLEX8 data, see DATATYPE-TimeSeries types for more details.
Definition: LALDatatypes.h:590
COMPLEX8TimeSeries::name
CHAR name[LALNameLength]
The name of the time series.
Definition: LALDatatypes.h:591
COMPLEX8TimeSeries::sampleUnits
LALUnit sampleUnits
The physical units of the quantity being sampled.
Definition: LALDatatypes.h:595
COMPLEX8TimeSeries::f0
REAL8 f0
The heterodyning frequency, in Hertz (zero if not heterodyned).
Definition: LALDatatypes.h:594
COMPLEX8TimeSeries::deltaT
REAL8 deltaT
The time step between samples of the time series in seconds.
Definition: LALDatatypes.h:593
COMPLEX8TimeSeries::epoch
LIGOTimeGPS epoch
The start time of the time series.
Definition: LALDatatypes.h:592
COMPLEX8TimeSeries::data
COMPLEX8Sequence * data
The sequence of sampled data.
Definition: LALDatatypes.h:596
COMPLEX8Vector
Vector of type COMPLEX8, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:163
COMPLEX8Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:167
COMPLEX8Vector::data
COMPLEX8 * data
Pointer to the data array.
Definition: LALDatatypes.h:168
LALStatus
LAL status structure, see The LALStatus structure for more details.
Definition: LALDatatypes.h:947
LALUnit
This structure stores units in the mksA system (plus Kelvin, Strain, and ADC Count).
Definition: LALDatatypes.h:498
LIGOTimeGPS
Epoch relative to GPS epoch, see LIGOTimeGPS type for more details.
Definition: LALDatatypes.h:458
LIGOTimeGPS::gpsSeconds
INT4 gpsSeconds
Seconds since 0h UTC 6 Jan 1980.
Definition: LALDatatypes.h:459
LIGOTimeGPS::gpsNanoSeconds
INT4 gpsNanoSeconds
Residual nanoseconds.
Definition: LALDatatypes.h:460
RAT4
A four-byte rational number, used as a parameter structure for XLALUnitRaiseRAT4().
Definition: Units.h:144
RAT4::numerator
INT2 numerator
The numerator.
Definition: Units.h:145
RAT4::denominatorMinusOne
UINT2 denominatorMinusOne
One less than the denominator.
Definition: Units.h:146
REAL4FrequencySeries
See DATATYPE-FrequencySeries types for documentation.
Definition: LALDatatypes.h:879
REAL4FrequencySeries::data
REAL4Sequence * data
Definition: LALDatatypes.h:885
REAL4FrequencySeries::name
CHAR name[LALNameLength]
Definition: LALDatatypes.h:880
REAL4TimeSeries
Time series of REAL4 data, see DATATYPE-TimeSeries types for more details.
Definition: LALDatatypes.h:570
REAL4TimeSeries::name
CHAR name[LALNameLength]
The name of the time series.
Definition: LALDatatypes.h:571
REAL4TimeSeries::data
REAL4Sequence * data
The sequence of sampled data.
Definition: LALDatatypes.h:576
REAL4TimeSeries::sampleUnits
LALUnit sampleUnits
The physical units of the quantity being sampled.
Definition: LALDatatypes.h:575
REAL4TimeSeries::deltaT
REAL8 deltaT
The time step between samples of the time series in seconds.
Definition: LALDatatypes.h:573
REAL4TimeSeries::epoch
LIGOTimeGPS epoch
The start time of the time series.
Definition: LALDatatypes.h:572
REAL4TimeSeries::f0
REAL8 f0
The heterodyning frequency, in Hertz (zero if not heterodyned).
Definition: LALDatatypes.h:574
REAL4Vector
Vector of type REAL4, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:145
REAL4Vector::data
REAL4 * data
Pointer to the data array.
Definition: LALDatatypes.h:150
REAL4Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:149
REAL8FrequencySeries
See DATATYPE-FrequencySeries types for documentation.
Definition: LALDatatypes.h:889
REAL8FrequencySeries::data
REAL8Sequence * data
Definition: LALDatatypes.h:895
REAL8FrequencySeries::name
CHAR name[LALNameLength]
Definition: LALDatatypes.h:890
REAL8TimeSeries
Time series of REAL8 data, see DATATYPE-TimeSeries types for more details.
Definition: LALDatatypes.h:580
REAL8TimeSeries::data
REAL8Sequence * data
The sequence of sampled data.
Definition: LALDatatypes.h:586
REAL8TimeSeries::sampleUnits
LALUnit sampleUnits
The physical units of the quantity being sampled.
Definition: LALDatatypes.h:585
REAL8TimeSeries::f0
REAL8 f0
The heterodyning frequency, in Hertz (zero if not heterodyned).
Definition: LALDatatypes.h:584
REAL8TimeSeries::deltaT
REAL8 deltaT
The time step between samples of the time series in seconds.
Definition: LALDatatypes.h:583
REAL8TimeSeries::epoch
LIGOTimeGPS epoch
The start time of the time series.
Definition: LALDatatypes.h:582
REAL8TimeSeries::name
CHAR name[LALNameLength]
The name of the time series.
Definition: LALDatatypes.h:581
REAL8Vector
Vector of type REAL8, see DATATYPE-Vector types for more details.
Definition: LALDatatypes.h:154
REAL8Vector::data
REAL8 * data
Pointer to the data array.
Definition: LALDatatypes.h:159
REAL8Vector::length
UINT4 length
Number of elements in array.
Definition: LALDatatypes.h:158