LAL  7.5.0.1-89842e6
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 
71 int 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
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