int main( void )
{
static LALStatus status;
REAL4Sequence *sSequenceIn;
REAL4Sequence *sSequenceOut;
REAL8Sequence *dSequenceIn;
REAL8Sequence *dSequenceOut;
COMPLEX8Sequence *cSequenceIn;
COMPLEX8Sequence *cSequenceOut;
COMPLEX16Sequence *zSequenceIn;
COMPLEX16Sequence *zSequenceOut;
REAL4FrequencySeries sFrequencySeries;
REAL8FrequencySeries dFrequencySeries;
COMPLEX8FrequencySeries cFrequencySeries;
COMPLEX16FrequencySeries zFrequencySeries;
REAL4FrequencySeries sFrequencySeries2;
REAL8FrequencySeries dFrequencySeries2;
COMPLEX8FrequencySeries cFrequencySeries2;
COMPLEX16FrequencySeries zFrequencySeries2;
REAL4TimeSeries sTimeSeries;
REAL8TimeSeries dTimeSeries;
COMPLEX8TimeSeries cTimeSeries;
COMPLEX16TimeSeries zTimeSeries;
REAL4TimeSeries sTimeSeries2;
REAL8TimeSeries dTimeSeries2;
COMPLEX8TimeSeries cTimeSeries2;
COMPLEX16TimeSeries zTimeSeries2;
REAL4 *sData;
REAL8 *dData;
COMPLEX8 *cData;
COMPLEX16 *zData;
/* Boolean Vars */
BOOLEAN unitComp;
/* variables for units */
RAT4 raise;
LALUnit strainToMinus2;
LALUnit adcToMinus2;
LALUnit adcStrain;
/* This routine should generate a file with data */
/* to be read by ReadFTSeries.c*/
LIGOTimeGPS t;
UINT4 i;
/* Data Test Variable */
UINT4 j;
fprintf(stderr,"Testing value of LALUnitTextSize ... ");
if ( (int)LALSupportUnitTextSize != (int)LALUnitTextSize )
{
fprintf(stderr,"UnitTextSize mismatch: [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
fprintf(stderr,"PASS\n");
t.gpsSeconds = 0;
t.gpsNanoSeconds = 0;
fprintf(stderr,"Testing Print/Read COMPLEX8FrequencySeries ... ");
cSequenceIn = NULL;
LALCCreateVector(&status, &cSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
{
*(cData) = crectf( i, i+1 );
}
strncpy(cFrequencySeries.name,"Complex frequency series",LALNameLength);
cFrequencySeries.sampleUnits = lalHertzUnit;
cFrequencySeries.deltaF = 1;
cFrequencySeries.epoch = t;
cFrequencySeries.f0 = 5;
cFrequencySeries.data = cSequenceIn;
LALCPrintFrequencySeries(&cFrequencySeries, "cFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cSequenceOut = NULL;
LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cFrequencySeries2.data = cSequenceOut;
LALCReadFrequencySeries(&status, &cFrequencySeries2, "./cFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(cFrequencySeries.deltaF - cFrequencySeries.deltaF)/
cFrequencySeries.deltaF > READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaF MisMatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(cFrequencySeries.name,cFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.epoch.gpsSeconds) !=
(cFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.epoch.gpsNanoSeconds) !=
(cFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanosecondMismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.f0) ?
(fabs(cFrequencySeries.f0 - cFrequencySeries2.f0)/cFrequencySeries.f0) :
(fabs(cFrequencySeries.f0 - cFrequencySeries2.f0) >
READFTSERIESTEST_TOL))
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&cFrequencySeries.sampleUnits,&cFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < cSequenceIn->length;j++)
{
if ((crealf(cSequenceIn->data[j]) ?
fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
/crealf(cSequenceIn->data[j]))
:fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimagf(cSequenceIn->data[j]) ?
fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
/cimagf(cSequenceIn->data[j]))
:fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX16FrequencySeries ... ");
/* Test case 2 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
zSequenceIn = NULL;
LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
{
*(zData) = crect( i/4.0, (i+1)/5.0 );
}
zFrequencySeries.sampleUnits = lalDimensionlessUnit;
strncpy(zFrequencySeries.name,"Complex frequency series",LALNameLength);
zFrequencySeries.deltaF = 1.3;
zFrequencySeries.epoch = t;
zFrequencySeries.f0 = 0;
zFrequencySeries.data = zSequenceIn;
LALZPrintFrequencySeries(&zFrequencySeries, "zFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zSequenceOut = NULL;
LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zFrequencySeries2.data = zSequenceOut;
LALZReadFrequencySeries(&status, &zFrequencySeries2, "./zFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if ((zFrequencySeries.deltaF) != (zFrequencySeries2.deltaF))
{
fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(zFrequencySeries.name,zFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zFrequencySeries.epoch.gpsSeconds) !=
(zFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zFrequencySeries.epoch.gpsNanoSeconds) !=
(zFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (zFrequencySeries.f0 ?
(fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)/zFrequencySeries.f0)
: (fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&zFrequencySeries.sampleUnits,&zFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < zSequenceIn->length;j++)
{
if ((creal(zSequenceIn->data[j]) ?
fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
/creal(zSequenceIn->data[j])) :
fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimag(zSequenceIn->data[j]) ?
fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
/cimag(zSequenceIn->data[j])) :
fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL8FrequencySeries ... ");
/* Test case 3 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
dSequenceIn = NULL;
LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
{
*(dData) = 0.005;
}
strncpy(dFrequencySeries.name,"Complex frequency series",LALNameLength);
/* set units */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&dFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dFrequencySeries.deltaF = 1.3;
dFrequencySeries.epoch = t;
dFrequencySeries.f0 = 0;
dFrequencySeries.data = dSequenceIn;
LALDPrintFrequencySeries(&dFrequencySeries, "dFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dSequenceOut = NULL;
LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dFrequencySeries2.data = dSequenceOut;
LALDReadFrequencySeries(&status, &dFrequencySeries2, "./dFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if ((dFrequencySeries.deltaF) != (dFrequencySeries.deltaF))
{
fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(dFrequencySeries.name,dFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dFrequencySeries.epoch.gpsSeconds)
!= (dFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dFrequencySeries.epoch.gpsSeconds)
!= (dFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (dFrequencySeries.f0 ?
(fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)/dFrequencySeries.f0)
: (fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&dFrequencySeries.sampleUnits,&dFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < dSequenceIn->length;j++)
{
if ((dSequenceIn->data[j] ?
fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
/dSequenceIn->data[j])
:fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL4FrequencySeries ... ");
/* Test case 4 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
sSequenceIn = NULL;
LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
{
*(sData) = 0.005;
}
strncpy(sFrequencySeries.name,"Complex frequency series",LALNameLength);
/* set units */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sFrequencySeries.deltaF = 1.3;
sFrequencySeries.epoch = t;
sFrequencySeries.f0 = 5;
sFrequencySeries.data = sSequenceIn;
sSequenceOut = NULL;
LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sFrequencySeries2.data = sSequenceOut;
LALSPrintFrequencySeries(&sFrequencySeries, "sFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSReadFrequencySeries(&status, &sFrequencySeries2, "./sFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(sFrequencySeries.deltaF - sFrequencySeries2.deltaF)
/sFrequencySeries.deltaF > READFTSERIESTEST_TOL)
{
fprintf(stderr,"Deltaf Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(sFrequencySeries.name,sFrequencySeries2.name)!=0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sFrequencySeries.epoch.gpsSeconds) !=
(sFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sFrequencySeries.epoch.gpsNanoSeconds) !=
(sFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (sFrequencySeries.f0 ?
(fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)/sFrequencySeries.f0)
: (fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&sFrequencySeries.sampleUnits,&sFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < sSequenceIn->length;j++)
{
if ((sSequenceIn->data[j] ?
fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
/sSequenceIn->data[j])
:fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
LALCDestroyVector(&status, &cSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCDestroyVector(&status, &cSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL4TimeSeries ... ");
/* Here is where testing for ReadTimeSeries is done */
/* S Case ReadTimeSeries */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
sSequenceIn = NULL;
LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
{
*(sData) = 0.005;
}
strncpy(sTimeSeries.name,"Real4 Time series",LALNameLength);
sTimeSeries.deltaT = 1.3;
sTimeSeries.epoch = t;
sTimeSeries.data = sSequenceIn;
sTimeSeries.f0 = 5;
LALSPrintTimeSeries(&sTimeSeries, "sTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sSequenceOut = NULL;
LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sTimeSeries2.data = sSequenceOut;
LALSReadTimeSeries(&status, &sTimeSeries2, "./sTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(sTimeSeries.deltaT-sTimeSeries2.deltaT) /
sTimeSeries.deltaT > READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(sFrequencySeries.name,sFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sTimeSeries.epoch.gpsSeconds) != (sTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sTimeSeries.epoch.gpsNanoSeconds) != (sTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
/* printf("%f ... %f f0 value\n",sTimeSeries.f0,sTimeSeries2.f0);*/
if (sTimeSeries.f0 ?
(fabs(sTimeSeries.f0 - sTimeSeries2.f0)/sTimeSeries.f0)
: (fabs(sTimeSeries.f0 - sTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&sTimeSeries.sampleUnits,&sTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < sSequenceIn->length;j++)
{
if ((sSequenceIn->data[j] ?
fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
/sSequenceIn->data[j])
:fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX16TimeSeries ... ");
/* Z case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&zTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
zSequenceIn = NULL;
LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
{
*(zData) = crect( 0.005, 1 );
}
strncpy(zTimeSeries.name,"Complex16 Time series",LALNameLength);
zTimeSeries.deltaT = 1.3;
zTimeSeries.epoch = t;
zTimeSeries.data = zSequenceIn;
zTimeSeries.f0 = 0;
LALZPrintTimeSeries(&zTimeSeries, "zTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zSequenceOut = NULL;
LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zTimeSeries2.data = zSequenceOut;
LALZReadTimeSeries(&status, &zTimeSeries2, "./zTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(zTimeSeries.deltaT) - (zTimeSeries2.deltaT)/zTimeSeries.deltaT >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Mismatch DeltaT [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(zTimeSeries.name,zTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zTimeSeries.epoch.gpsSeconds) != (zTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ( (zTimeSeries.epoch.gpsNanoSeconds)
!= (zTimeSeries2.epoch.gpsNanoSeconds) )
{
fprintf(stderr,"Epoch Nanosecond Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (zTimeSeries.f0 ?
(fabs(zTimeSeries.f0 - zTimeSeries2.f0)/zTimeSeries.f0)
: (fabs(zTimeSeries.f0 - zTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&zTimeSeries.sampleUnits,&zTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFUN;
}
for (j = 0; j < zSequenceIn->length;j++)
{
if ((creal(zSequenceIn->data[j]) ?
fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
/creal(zSequenceIn->data[j]))
:fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimag(zSequenceIn->data[j]) ?
fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
/cimag(zSequenceIn->data[j]))
:fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL8TimeSeries ... ");
/* D case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
strncpy(dTimeSeries.name,"REAL8 Time series",LALNameLength);
dTimeSeries.sampleUnits = lalHertzUnit;
t.gpsSeconds = 4578;
t.gpsNanoSeconds = 890634;
dSequenceIn = NULL;
LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
{
*(dData) = 0.005;
}
dTimeSeries.deltaT = 1.3;
dTimeSeries.epoch = t;
dTimeSeries.data = dSequenceIn;
dTimeSeries.f0 = 0;
LALDPrintTimeSeries(&dTimeSeries, "dTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dSequenceOut = NULL;
LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dTimeSeries2.data = dSequenceOut;
LALDReadTimeSeries(&status, &dTimeSeries2, "./dTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(dTimeSeries.deltaT) - (dTimeSeries2.deltaT)/dTimeSeries.deltaT
> READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
status.statusDescription );
return READFTSERIESTESTC_EFLS;
}
if (strcmp(dTimeSeries.name,dTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
status.statusDescription );
return READFTSERIESTESTC_EFLS;
}
if ((dTimeSeries.epoch.gpsSeconds) != (dTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dTimeSeries.epoch.gpsNanoSeconds)
!= (dTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (dTimeSeries.f0 ?
(fabs(dTimeSeries.f0 - dTimeSeries2.f0)/dTimeSeries.f0)
: (fabs(dTimeSeries.f0 - dTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&dTimeSeries.sampleUnits,&dTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < dSequenceIn->length;j++)
{
if ((dSequenceIn->data[j] ?
fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
/dSequenceIn->data[j])
:fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX8TimeSeries ... ");
/* C case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&cTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
cSequenceIn = NULL;
LALCCreateVector( &status, &cSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
{
*(cData) = crectf( 0.005, 1 );
}
strncpy(cTimeSeries.name,"Complex8 Time series",LALNameLength);
cTimeSeries.deltaT = 1.3;
cTimeSeries.epoch = t;
cTimeSeries.data = cSequenceIn;
cTimeSeries.f0 = 0;
cSequenceOut = NULL;
LALCPrintTimeSeries(&cTimeSeries, "cTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cTimeSeries2.data = cSequenceOut;
LALCReadTimeSeries(&status, &cTimeSeries2, "./cTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(cTimeSeries.deltaT - cTimeSeries2.deltaT)/cTimeSeries.deltaT
> READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(cTimeSeries.name,cTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cTimeSeries.epoch.gpsSeconds) != (cTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cTimeSeries.epoch.gpsNanoSeconds)!=(cTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (cTimeSeries.f0 ?
(fabs(cTimeSeries.f0 - cTimeSeries2.f0)/cTimeSeries.f0)
: (fabs(cTimeSeries.f0 - cTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&cTimeSeries.sampleUnits,&cTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < cSequenceIn->length;j++)
{
if ((crealf(cSequenceIn->data[j]) ?
fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
/crealf(cSequenceIn->data[j]))
:fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimagf(cSequenceIn->data[j]) ?
fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
/cimagf(cSequenceIn->data[j]))
:fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
/* *******************Deallocate all memory****************** */
LALCDestroyVector(&status, &cSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCDestroyVector(&status, &cSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCheckMemoryLeaks();
fprintf(stderr,"ReadFTSeries passed all tests.\n");
return READFTSERIESTESTC_ENOM;
}
int main( int argc, char *argv[] )
{
const UINT4 n = 65536;
const REAL4 dt = 1.0 / 16384.0;
static LALStatus status;
static REAL4TimeSeries x;
static COMPLEX8FrequencySeries X;
static REAL4TimeSeries y;
static REAL4FrequencySeries Y;
static COMPLEX8TimeSeries z;
static COMPLEX8FrequencySeries Z;
RealFFTPlan *fwdRealPlan = NULL;
RealFFTPlan *revRealPlan = NULL;
ComplexFFTPlan *fwdComplexPlan = NULL;
ComplexFFTPlan *revComplexPlan = NULL;
RandomParams *randpar = NULL;
AverageSpectrumParams avgSpecParams;
UINT4 srate[] = { 4096, 9000 };
UINT4 npts[] = { 262144, 1048576 };
REAL4 var[] = { 5, 16 };
UINT4 j, sr, np, vr;
/*CHAR fname[2048];*/
ParseOptions( argc, argv );
LALSCreateVector( &status, &x.data, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &X.data, n / 2 + 1 );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &z.data, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCCreateVector( &status, &Z.data, n );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateForwardRealFFTPlan( &status, &fwdRealPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateReverseRealFFTPlan( &status, &revRealPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateForwardComplexFFTPlan( &status, &fwdComplexPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateReverseComplexFFTPlan( &status, &revComplexPlan, n, 0 );
TestStatus( &status, CODES( 0 ), 1 );
randpar = XLALCreateRandomParams( 100 );
/*
*
* Try the real transform.
*
*/
x.f0 = 0;
x.deltaT = dt;
x.sampleUnits = lalMeterUnit;
snprintf( x.name, sizeof( x.name ), "x" );
XLALNormalDeviates( x.data, randpar );
for ( j = 0; j < n; ++j ) /* add a 60 Hz line */
{
REAL4 t = j * dt;
x.data->data[j] += 0.1 * cos( LAL_TWOPI * 60.0 * t );
}
LALSPrintTimeSeries( &x, "x.out" );
snprintf( X.name, sizeof( X.name ), "X" );
LALTimeFreqRealFFT( &status, &X, &x, fwdRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCPrintFrequencySeries( &X, "X.out" );
LALFreqTimeRealFFT( &status, &x, &X, revRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALSPrintTimeSeries( &x, "xx.out" );
/*
*
* Try the average power spectum.
*
*/
avgSpecParams.method = useMean;
for ( np = 0; np < XLAL_NUM_ELEM(npts) ; ++np )
{
/* length of time series for 7 segments, overlapped by 1/2 segment */
UINT4 tsLength = npts[np] * 7 - 6 * npts[np] / 2;
LALCreateVector( &status, &y.data, tsLength );
TestStatus( &status, CODES( 0 ), 1 );
LALCreateVector( &status, &Y.data, npts[np] / 2 + 1 );
TestStatus( &status, CODES( 0 ), 1 );
avgSpecParams.overlap = npts[np] / 2;
/* create the window */
avgSpecParams.window = XLALCreateHannREAL4Window(npts[np]);
avgSpecParams.plan = NULL;
LALCreateForwardRealFFTPlan( &status, &avgSpecParams.plan, npts[np], 0 );
TestStatus( &status, CODES( 0 ), 1 );
for ( sr = 0; sr < XLAL_NUM_ELEM(srate) ; ++sr )
{
/* set the sample rate of the time series */
y.deltaT = 1.0 / (REAL8) srate[sr];
for ( vr = 0; vr < XLAL_NUM_ELEM(var) ; ++vr )
{
REAL4 eps = 1e-6; /* very conservative fp precision */
REAL4 Sfk = 2.0 * var[vr] * var[vr] * y.deltaT;
REAL4 sfk = 0;
REAL4 lbn;
REAL4 sig;
REAL4 ssq;
REAL4 tol;
/* create the data */
XLALNormalDeviates( y.data, randpar );
ssq = 0;
for ( j = 0; j < y.data->length; ++j )
{
y.data->data[j] *= var[vr];
ssq += y.data->data[j] * y.data->data[j];
}
/* compute tolerance for comparison */
lbn = log( y.data->length ) / log( 2 );
sig = sqrt( 2.5 * lbn * eps * eps * ssq / y.data->length );
tol = 5 * sig;
/* compute the psd and find the average */
LALREAL4AverageSpectrum( &status, &Y, &y, &avgSpecParams );
TestStatus( &status, CODES( 0 ), 1 );
LALSMoment( &status, &sfk, Y.data, 1 );
TestStatus( &status, CODES( 0 ), 1 );
/* check the result */
if ( fabs(Sfk-sfk) > tol )
{
fprintf( stderr, "FAIL: PSD estimate appears incorrect\n");
fprintf( stderr, "expected %e, got %e ", Sfk, sfk );
fprintf( stderr, "(difference = %e, tolerance = %e)\n",
fabs(Sfk-sfk), tol );
exit(2);
}
}
}
/* destroy structures that need to be resized */
LALDestroyRealFFTPlan( &status, &avgSpecParams.plan );
TestStatus( &status, CODES( 0 ), 1 );
XLALDestroyREAL4Window( avgSpecParams.window );
LALDestroyVector( &status, &y.data );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyVector( &status, &Y.data );
TestStatus( &status, CODES( 0 ), 1 );
}
/*
*
* Try the complex transform.
*
*/
z.f0 = 0;
z.deltaT = dt;
z.sampleUnits = lalVoltUnit;
snprintf( z.name, sizeof( z.name ), "z" );
{ /* dirty hack */
REAL4Vector tmp;
tmp.length = 2 * z.data->length;
tmp.data = (REAL4 *)z.data->data;
XLALNormalDeviates( &tmp, randpar );
}
for ( j = 0; j < n; ++j ) /* add a 50 Hz line and a 500 Hz ringdown */
{
REAL4 t = j * dt;
z.data->data[j] += 0.2 * cos( LAL_TWOPI * 50.0 * t );
z.data->data[j] += I * exp( -t ) * sin( LAL_TWOPI * 500.0 * t );
}
LALCPrintTimeSeries( &z, "z.out" );
TestStatus( &status, CODES( 0 ), 1 );
snprintf( Z.name, sizeof( Z.name ), "Z" );
LALTimeFreqComplexFFT( &status, &Z, &z, fwdComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCPrintFrequencySeries( &Z, "Z.out" );
LALFreqTimeComplexFFT( &status, &z, &Z, revComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCPrintTimeSeries( &z, "zz.out" );
XLALDestroyRandomParams( randpar );
LALDestroyRealFFTPlan( &status, &fwdRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyRealFFTPlan( &status, &revRealPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyComplexFFTPlan( &status, &fwdComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALDestroyComplexFFTPlan( &status, &revComplexPlan );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &Z.data );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &z.data );
TestStatus( &status, CODES( 0 ), 1 );
LALCDestroyVector( &status, &X.data );
TestStatus( &status, CODES( 0 ), 1 );
LALSDestroyVector( &status, &x.data );
TestStatus( &status, CODES( 0 ), 1 );
LALCheckMemoryLeaks();
return 0;
}
/* Actually, we don't need it -- JTW
struct tagRealFFTPlan
{
INT4 sign;
UINT4 size;
void* junk;
};
*/
int
main( int argc, char *argv[] )
{
static LALStatus status;
UINT4 i;
REAL8 f;
const REAL4 testInputDataData[SZEROPADANDFFTTESTC_LENGTH]
= {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
COMPLEX8 expectedOutputDataData[SZEROPADANDFFTTESTC_LENGTH]
= {crectf(+3.600000000000000e+01, 0.0),
crectf(-1.094039137097177e+01, -2.279368601990178e+01),
crectf(+3.693524635113721e-01, +9.326003289238411e+00),
crectf(-8.090169943749448e-01, -7.918722831227928e+00),
crectf(+3.502214272222959e-01, +5.268737078678177e+00),
crectf(+5.329070518200751e-15, -5.196152422706625e+00),
crectf(+3.090169943749475e-01, +4.306254604896173e+00),
crectf(+2.208174802380956e-01, -4.325962305777781e+00)};
REAL4TimeSeries goodInput;
COMPLEX8FrequencySeries goodOutput;
int result;
LALUnit expectedUnit;
CHAR unitString[LALUnitTextSize];
SZeroPadAndFFTParameters goodParams;
goodParams.window = NULL;
goodParams.fftPlan = NULL;
goodParams.length = SZEROPADANDFFTTESTC_FULLLENGTH;
/* build window */
goodParams.window = XLALCreateRectangularREAL4Window(SZEROPADANDFFTTESTC_LENGTH);
#ifndef LAL_NDEBUG
SZeroPadAndFFTParameters badParams = goodParams;
#endif
/* Fill in expected output */
for (i=0; i<SZEROPADANDFFTTESTC_LENGTH; ++i)
{
expectedOutputDataData[i] *= SZEROPADANDFFTTESTC_DELTAT;
}
ParseOptions( argc, argv );
/* TEST INVALID DATA HERE ------------------------------------------- */
/* define valid parameters */
goodInput.f0 = 0.0;
goodInput.deltaT = SZEROPADANDFFTTESTC_DELTAT;
goodInput.epoch.gpsSeconds = SZEROPADANDFFTTESTC_EPOCHSEC;
goodInput.epoch.gpsNanoSeconds = SZEROPADANDFFTTESTC_EPOCHNS;
goodInput.data = NULL;
goodOutput.data = NULL;
#ifndef LAL_NDEBUG
REAL4TimeSeries badInput = goodInput;
COMPLEX8FrequencySeries badOutput = goodOutput;
#endif
/* construct plan */
LALCreateForwardRealFFTPlan(&status, &(goodParams.fftPlan),
SZEROPADANDFFTTESTC_FULLLENGTH,
SZEROPADANDFFTTESTC_FALSE);
if ( ( code = CheckStatus( &status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS ) ) )
{
return code;
}
/* allocate input and output vectors */
LALSCreateVector(&status, &(goodInput.data), SZEROPADANDFFTTESTC_LENGTH);
if ( ( code = CheckStatus( &status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS ) ) )
{
return code;
}
LALCCreateVector(&status, &(goodOutput.data), SZEROPADANDFFTTESTC_LENGTH);
if ( ( code = CheckStatus( &status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS ) ) )
{
return code;
}
#ifndef LAL_NDEBUG
if ( ! lalNoDebug )
{
/* test behavior for null pointer to output series */
LALSZeroPadAndFFT(&status, NULL, &goodInput, &goodParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to output series results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to input series */
LALSZeroPadAndFFT(&status, &goodOutput, NULL, &goodParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to input series results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to parameter structure */
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, NULL);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to parameter structure results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to FFT plan */
badParams.fftPlan = NULL;
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &badParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to FFT plan results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
badParams.fftPlan = goodParams.fftPlan;
/* test behavior for null pointer to data member of output series */
LALSZeroPadAndFFT(&status, &badOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to data member of output series results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to data member of input series */
LALSZeroPadAndFFT(&status, &goodOutput, &badInput, &goodParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to data member of input series results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* test behavior for null pointer to data member of data member of output series */
LALCCreateVector(&status, &(badOutput.data), SZEROPADANDFFTTESTC_LENGTH);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
COMPLEX8 *cPtr;
cPtr = badOutput.data->data;
badOutput.data->data = NULL;
LALSZeroPadAndFFT(&status, &badOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to data member of data member of output series results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
badOutput.data->data = cPtr;
LALCDestroyVector(&status, &(badOutput.data));
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
/* test behavior for null pointer to data member of data member of output series */
LALSCreateVector(&status, &(badInput.data), SZEROPADANDFFTTESTC_LENGTH);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
REAL4 *sPtr;
sPtr = badInput.data->data;
badInput.data->data = NULL;
LALSZeroPadAndFFT(&status, &goodOutput, &badInput, &goodParams);
if ( ( code = CheckStatus( &status, STOCHASTICCROSSCORRELATIONH_ENULLPTR,
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK ) ) )
{
return code;
}
printf(" PASS: null pointer to data member of data member of input series results in error:\n \"%s\"\n", STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
badInput.data->data = sPtr;
LALSDestroyVector(&status, &(badInput.data));
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
/* test behavior for zero length */
goodInput.data->length = goodOutput.data->length = 0;
/* plan->size = -1; */
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status, STOCHASTICCROSSCORRELATIONH_EZEROLEN,
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: zero length results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN);
/* reassign valid length */
goodInput.data->length = goodOutput.data->length
= SZEROPADANDFFTTESTC_LENGTH;
/* plan->size = SZEROPADANDFFTTESTC_FULLLENGTH; */
/* test behavior for negative time spacing */
goodInput.deltaT = -SZEROPADANDFFTTESTC_DELTAT;
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status,
STOCHASTICCROSSCORRELATIONH_ENONPOSDELTAT,
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAT,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: negative time spacing results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAT);
/* test behavior for zero time spacing */
goodInput.deltaT = 0;
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status,
STOCHASTICCROSSCORRELATIONH_ENONPOSDELTAT,
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAT,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: zero time spacing results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAT);
/* reassign valid time spacing */
goodInput.deltaT = SZEROPADANDFFTTESTC_DELTAT;
} /* if ( ! lalNoDebug ) */
#endif /* NDEBUG */
/* test behavior for negative heterodyning frequency */
goodInput.f0 = -100.0;
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status,
STOCHASTICCROSSCORRELATIONH_ENONZEROHETERO,
STOCHASTICCROSSCORRELATIONH_MSGENONZEROHETERO,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: negative heterodyning frequency results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONZEROHETERO);
/* test behavior for positive heterodyning frequency */
goodInput.f0 = 100.0;
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status,
STOCHASTICCROSSCORRELATIONH_ENONZEROHETERO,
STOCHASTICCROSSCORRELATIONH_MSGENONZEROHETERO,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: positive heterodyning frequency results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGENONZEROHETERO);
goodInput.f0 = 0.0;
/* test behavior for length mismatch between input series and output series */
goodOutput.data->length = SZEROPADANDFFTTESTC_LENGTH + 1;
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status,
STOCHASTICCROSSCORRELATIONH_EMMLEN,
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN,
SZEROPADANDFFTTESTC_ECHK,
SZEROPADANDFFTTESTC_MSGECHK) ) )
{
return code;
}
printf(" PASS: length mismatch between input series and output series results in error:\n \"%s\"\n",
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
goodOutput.data->length = SZEROPADANDFFTTESTC_LENGTH;
/* TEST VALID DATA HERE --------------------------------------------- */
/* fill input time-series parameters */
strncpy(goodInput.name,"Dummy test data",LALNameLength);
goodInput.sampleUnits = lalDimensionlessUnit;
goodInput.sampleUnits.unitNumerator[LALUnitIndexADCCount] = 1;
/* fill input time-series data */
for (i=0; i<SZEROPADANDFFTTESTC_LENGTH; ++i)
{
goodInput.data->data[i] = testInputDataData[i];
}
/* zero-pad and FFT */
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus( &status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
/* check output f0 */
if (optVerbose)
{
printf("f0=%g, should be 0\n", goodOutput.f0);
}
if (goodOutput.f0)
{
printf(" FAIL: Valid data test\n");
if (optVerbose)
{
printf("Exiting with error: %s\n", SZEROPADANDFFTTESTC_MSGEFLS);
}
return SZEROPADANDFFTTESTC_EFLS;
}
/* check output deltaF */
if (optVerbose)
{
printf("deltaF=%g, should be %g\n", goodOutput.deltaF,
SZEROPADANDFFTTESTC_DELTAF);
}
if ( fabs(goodOutput.deltaF-SZEROPADANDFFTTESTC_DELTAF)
/ SZEROPADANDFFTTESTC_DELTAF > SZEROPADANDFFTTESTC_TOL )
{
printf(" FAIL: Valid data test\n");
if (optVerbose)
{
printf("Exiting with error: %s\n", SZEROPADANDFFTTESTC_MSGEFLS);
}
return SZEROPADANDFFTTESTC_EFLS;
}
/* check output epoch */
if (optVerbose)
{
printf("epoch=%d seconds, %d nanoseconds; should be %d seconds, %d nanoseconds\n",
goodOutput.epoch.gpsSeconds, goodOutput.epoch.gpsNanoSeconds,
SZEROPADANDFFTTESTC_EPOCHSEC, SZEROPADANDFFTTESTC_EPOCHNS);
}
if ( goodOutput.epoch.gpsSeconds != SZEROPADANDFFTTESTC_EPOCHSEC
|| goodOutput.epoch.gpsNanoSeconds != SZEROPADANDFFTTESTC_EPOCHNS )
{
printf(" FAIL: Valid data test\n");
if (optVerbose)
{
printf("Exiting with error: %s\n", SZEROPADANDFFTTESTC_MSGEFLS);
}
return SZEROPADANDFFTTESTC_EFLS;
}
/* check output units */
expectedUnit = lalDimensionlessUnit;
expectedUnit.unitNumerator[LALUnitIndexADCCount] = 1;
expectedUnit.unitNumerator[LALUnitIndexSecond] = 1;
result = XLALUnitCompare(&expectedUnit, &(goodOutput.sampleUnits));
if (optVerbose)
{
if ( XLALUnitAsString( unitString, LALUnitTextSize, &(goodOutput.sampleUnits)) == NULL ) {
return SZEROPADANDFFTTESTC_EFLS;
}
printf( "Units are \"%s\", ", unitString );
if ( XLALUnitAsString( unitString, LALUnitTextSize, &expectedUnit) == NULL ) {
return SZEROPADANDFFTTESTC_EFLS;
}
printf( "should be \"%s\"\n", unitString );
}
if (result != 0)
{
printf(" FAIL: Valid data test #1\n");
if (optVerbose)
{
printf("Exiting with error: %s\n",
SZEROPADANDFFTTESTC_MSGEFLS);
}
return SZEROPADANDFFTTESTC_EFLS;
}
/* check output values */
if (optVerbose)
{
printf("hBarTilde(0)=%g + %g i, should be %g\n",
crealf(goodOutput.data->data[0]), cimagf(goodOutput.data->data[0]),
crealf(expectedOutputDataData[0]));
}
if ( fabsf(crealf(goodOutput.data->data[0]) - crealf(expectedOutputDataData[0]))
/* / expectedOutputDataData[0].re */> SZEROPADANDFFTTESTC_TOL
|| fabsf(cimagf(goodOutput.data->data[0])) > SZEROPADANDFFTTESTC_TOL )
{
printf(" FAIL: Valid data test\n");
if (optVerbose)
{
printf("Exiting with error: %s\n", SZEROPADANDFFTTESTC_MSGEFLS);
}
return SZEROPADANDFFTTESTC_EFLS;
}
for (i=1; i<SZEROPADANDFFTTESTC_LENGTH; ++i)
{
f = i * SZEROPADANDFFTTESTC_DELTAF;
if (optVerbose)
{
printf("hBarTilde(%f Hz)=%g + %g i, should be %g + %g i\n",
f, crealf(goodOutput.data->data[i]), cimagf(goodOutput.data->data[i]),
crealf(expectedOutputDataData[i]), cimagf(expectedOutputDataData[i]));
}
if (fabsf(crealf(goodOutput.data->data[i]) - crealf(expectedOutputDataData[i]))
/* / expectedOutputDataData[0].re */> SZEROPADANDFFTTESTC_TOL
|| fabsf(cimagf(goodOutput.data->data[i]) - cimagf(expectedOutputDataData[i]))
/* / expectedOutputDataData[0].re */> SZEROPADANDFFTTESTC_TOL)
{
printf(" FAIL: Valid data test\n");
if (optVerbose)
{
printf("Exiting with error: %s\n", SZEROPADANDFFTTESTC_MSGEFLS);
}
return SZEROPADANDFFTTESTC_EFLS;
}
}
/* write results to output file
LALSPrintTimeSeries(&input, "zeropadgoodInput.dat");
LALCPrintFrequencySeries(&output, "zeropadgoodOutput.dat");*/
/* clean up valid data */
LALSDestroyVector(&status, &goodInput.data);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
LALCDestroyVector(&status, &goodOutput.data);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
LALDestroyRealFFTPlan(&status, &(goodParams.fftPlan));
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
XLALDestroyREAL4Window(goodParams.window);
LALCheckMemoryLeaks();
printf("PASS: all tests\n");
/**************** Process User-Entered Data, If Any **************/
/* ::TODO:: Fix this with length and window type to be specified */
if (optInputFile[0] && optOutputFile[0]){
/* construct plan*/
LALCreateForwardRealFFTPlan(&status, &(goodParams.fftPlan), 2*optLength - 1,
optMeasurePlan);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
goodInput.data = NULL;
goodOutput.data = NULL;
LALSCreateVector(&status, &goodInput.data, optLength);
if ( ( code = CheckStatus( &status, 0 , "",
SZEROPADANDFFTTESTC_EUSE,
SZEROPADANDFFTTESTC_MSGEUSE) ) )
{
return code;
}
LALCCreateVector(&status, &goodOutput.data, optLength);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
/* Read input file */
LALSReadTimeSeries(&status, &goodInput, optInputFile);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
/* calculate zero-pad and FFT */
LALSZeroPadAndFFT(&status, &goodOutput, &goodInput, &goodParams);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
LALCPrintFrequencySeries(&goodOutput, optOutputFile);
printf("===== FFT of Zero-Padded User-Specified Data Written to File %s =====\n", optOutputFile);
/* clean up valid data */
LALSDestroyVector(&status, &goodInput.data);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
LALCDestroyVector(&status, &goodOutput.data);
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
LALDestroyRealFFTPlan(&status, &(goodParams.fftPlan));
if ( ( code = CheckStatus(&status, 0 , "",
SZEROPADANDFFTTESTC_EFLS,
SZEROPADANDFFTTESTC_MSGEFLS) ) )
{
return code;
}
LALCheckMemoryLeaks();
}
return SZEROPADANDFFTTESTC_ENOM;
}
int main( int argc, char *argv[] )
{
UINT4 i, j, k;
const REAL4 tiny = 1e-6;
CHAR ifoCode[][3] = { "H1", "L1" };
INT4 calTime[] = { 729331981, 729332039, 729332040, 729332041, 729332099,
800000000 };
CHAR cacheTime[][21] = { "729273600-734367600", "729273600-734367600" };
COMPLEX8 H1AlphaBeta[] = { {0.9883124570783, 0}, {0.9883124570783, 0},
{1.123396433694, 0}, {1.123396433694, 0}, {1.123396433694, 0}, {0, 0} };
COMPLEX8 L1AlphaBeta[] = { {0, 0}, {0, 0}, {0.6041572088741, 0},
{0.6041572088741, 0}, {0.6041572088741, 0}, {0, 0} };
static LALStatus status;
const CHAR calCacheName[LALNameLength];
LALCache *calCache = NULL;
UINT4 numPoints = 262144;
UINT4 sampleRate = 4096;
CHAR outFile[LALNameLength];
LIGOTimeGPS duration = {0,0};
COMPLEX8FrequencySeries response;
const LALUnit strainPerCount = {0,{0,0,0,0,0,1,-1},{0,0,0,0,0,0,0}};
ParseOptions (argc, argv);
/* clear the response function and create storage for the frequency series */
memset( &response, 0, sizeof(COMPLEX8FrequencySeries) );
LALCCreateVector( &status, &(response.data), numPoints / 2 + 1 );
TESTSTATUS( &status );
/* set the parameters of the response function to generate */
response.deltaF = (REAL8) sampleRate / (REAL8) numPoints;
response.sampleUnits = strainPerCount;
/* loop over the three interferometers */
for ( j = 0; j < sizeof(ifoCode) / sizeof(*ifoCode); ++j )
{
snprintf( response.name, LALNameLength * sizeof(CHAR),
CHANNEL, ifoCode[j] );
for ( i = 0; i < sizeof(calTime) / sizeof(*calTime); ++i )
{
/* set the time of the calibration and the frame cahche file to use */
snprintf( calCacheName, LALNameLength * sizeof(CHAR), CAL_CATALOG,
ifoCode[j], cacheTime[i % 2] );
response.epoch.gpsSeconds = calTime[i];
if ( verbose )
{
fprintf( stdout, "Calibration for GPS time %d from %s\n",
response.epoch.gpsSeconds, calCacheName );
fflush( stdout );
}
/* create the response function */
LALExtractFrameResponse( &status, &response, calCacheName, ifoCode[j],
&duration );
if ( status.statusCode == -1 && status.statusPtr )
{
if ( status.statusPtr->statusCode == FRAMESTREAMH_EDONE &&
calTime[i] == 800000000 )
{
/* no calibration for this time */
if ( verbose )
{
fprintf( stderr, "OK: No calibration for 800000000\n" );
LALPrintError( "OK: %s\n", status.statusPtr->statusDescription );
}
CLEARSTATUS( status );
}
else if ( status.statusPtr->statusCode == CALIBRATIONH_EZERO &&
! strncmp( ifoCode[j], "L1", 2 * sizeof(CHAR) ) &&
(calTime[i] == 729331981 || calTime[i] == 729332039) )
{
/* alpha is zero at this time */
if ( verbose )
{
fprintf( stderr, "OK: Cal is zero for L1 at 729332039\n" );
LALPrintError( "OK: %s\n", status.statusPtr->statusDescription );
}
CLEARSTATUS( status );
}
else
{
/* some other error */
TESTSTATUS( &status );
}
}
else
{
TESTSTATUS( &status );
/* FIXME check that the values match the expected ones */
/* H1AlphaBeta[i] and L1AlphaBeta[i] give the correct values */
/* for this i, so we need to check that the returned values */
/* match the expected ones up to tiny. Need to if on j to get */
/* the correct ifo */
/* test that the response does not contain NaN or Inf */
for ( k = 0; k < response.data->length; ++k )
{
if ( (! finite( response.data->data[k].re )) ||
(! finite( response.data->data[k].im )) )
{
fprintf( stderr, "ERROR: non-finite value found in response "
"at k = %d (%e,%e)\n",
k, response.data->data[k].re, response.data->data[k].im );
exit( 1 );
}
}
/* print out the response function */
if ( verbose )
{
fprintf( stdout, "Calibration updated\n" );
fflush( stdout );
}
if ( output )
{
snprintf( outFile, LALNameLength * sizeof(CHAR),
"Response-%s-%d.txt", ifoCode[j], response.epoch.gpsSeconds );
LALCPrintFrequencySeries( &response, outFile );
}
}
}
}
/* free memory */
LALCDestroyVector( &status, &(response.data) );
TESTSTATUS( &status );
LALCheckMemoryLeaks();
return 0;
}
