void do_all_tests(Skipper const& s = Skipper()) {
auto A = qi::copy(qi::char_("$_") | qi::alpha);
auto B = qi::copy(qi::char_("z"));
// using skipper:
SHOULD_WORK(A >> B , "$z", s);
SHOULD_FAIL(A >> B , "$.", s);
SHOULD_FAIL(A >> B , "$" , s);
SHOULD_WORK(A > B , "$z", s);
SHOULD_FAIL(A > B , "$.", s);
SHOULD_FAIL(A > B , "$" , s);
// positive assertion (does not consume B)
SHOULD_WORK(A >> &B, "$z", s);
SHOULD_FAIL(A >> &B, "$.", s);
SHOULD_FAIL(A >> &B, "$" , s);
SHOULD_WORK(A > &B, "$z", s);
SHOULD_FAIL(A > &B, "$.", s);
SHOULD_FAIL(A > &B, "$" , s);
// negative assertion:
SHOULD_FAIL(A >> !B, "$z", s);
SHOULD_WORK(A >> !B, "$.", s);
SHOULD_WORK(A >> !B, "$" , s);
SHOULD_FAIL(A > !B, "$z", s);
SHOULD_WORK(A > !B, "$.", s);
SHOULD_WORK(A > !B, "$" , s);
}
int SaveTiffEx
(
const char *pFileName,
const MinImg *pImg,
const ExtImgProps *pProps,
int page
)
{
#ifndef WITH_TIFF
return NOT_IMPLEMENTED;
#else
if (!pImg || !pFileName || page < 0)
return BAD_ARGS;
if (!pImg->pScan0)
return BAD_ARGS;
TIFFSetErrorHandler(NULL);
TIFFSetWarningHandler(NULL);
int nPages = GetTiffPages(pFileName);
if (nPages == FILE_ERROR)
nPages = 0;
if (page > nPages || page < 0)
return BAD_ARGS;
scoped_cpp_array<TiffData> tiff_pages(new TiffData[nPages]);
if (page < nPages)
{
scoped_tiff_handle pTIF(TIFFOpen(pFileName, "r"));
if (!pTIF)
return FILE_ERROR;
for (int k = 0; k < nPages; k++)
{
TiffData &data = tiff_pages[k];
TIFFSetDirectory(pTIF, k);
int &nc = data.samples_per_pixel;
int typ = PLANARCONFIG_CONTIG;
_TIFFGetField(pTIF, TIFFTAG_SAMPLESPERPIXEL, &nc, 1);
if (nc > 1)
_TIFFGetField(pTIF, TIFFTAG_PLANARCONFIG, &typ, PLANARCONFIG_CONTIG);
if (typ != PLANARCONFIG_CONTIG)
return NOT_IMPLEMENTED;
int &bpc = data.bytes_per_sample;
_TIFFGetField(pTIF, TIFFTAG_IMAGEWIDTH, &data.width, 0);
_TIFFGetField(pTIF, TIFFTAG_IMAGELENGTH, &data.height, 0);
_TIFFGetField(pTIF, TIFFTAG_BITSPERSAMPLE, &bpc, 0);
if (bpc != 1 && bpc & 7)
return NOT_IMPLEMENTED;
bpc = bpc >> 3;
int &metr = data.photometric;
_TIFFGetField(pTIF, TIFFTAG_PHOTOMETRIC, &metr, PHOTOMETRIC_MINISWHITE);
if (metr == PHOTOMETRIC_MINISWHITE && bpc > 0)
return NOT_IMPLEMENTED;
_TIFFGetField(pTIF, TIFFTAG_SAMPLEFORMAT, &data.sample_format, SAMPLEFORMAT_UINT);
_TIFFGetField(pTIF, TIFFTAG_XRESOLUTION, &data.xresolution, 0.0f);
_TIFFGetField(pTIF, TIFFTAG_YRESOLUTION, &data.yresolution, 0.0f);
_TIFFGetField(pTIF, TIFFTAG_RESOLUTIONUNIT, &data.resolution_unit, RESUNIT_INCH);
_TIFFGetField(pTIF, TIFFTAG_COMPRESSION, &data.compression_type, COMPRESSION_NONE);
_TIFFGetField(pTIF, TIFFTAG_JPEGQUALITY, &data.jpeg_quality, 100);
const tsize_t scanLen = TIFFScanlineSize(pTIF);
data.scan_lines = new uint8_t[data.height * scanLen];
data.scanLen = scanLen;
for (int y = 0; y < data.height; y++)
{
void * pScanLine = data.scan_lines + y * scanLen;
SHOULD_WORK(TIFFReadScanline(pTIF, pScanLine, y));
}
}
}
static int AddPageToTiffExImpl
(
TIFF * pTIF,
const MinImg *pImg,
const ExtImgProps *pProps
)
{
int bpp = std::max(1, (int)pImg->channelDepth * 8);
if (pProps != NULL)
{
switch (pProps->comp)
{
case IFC_RLE:
case IFC_GROUP3:
case IFC_GROUP4:
bpp = 1;
break;
case IFC_JPEG:
bpp = std::max(8, bpp);
break;
default:
break;
}
}
TIFFSetField(pTIF, TIFFTAG_IMAGELENGTH, pImg->height);
TIFFSetField(pTIF, TIFFTAG_IMAGEWIDTH, pImg->width);
TIFFSetField(pTIF, TIFFTAG_BITSPERSAMPLE, bpp);
TIFFSetField(pTIF, TIFFTAG_SAMPLESPERPIXEL, pImg->channels);
TIFFSetField(pTIF, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
// FIXME: should be clarified for non-standard as soon as possible!
if (pImg->channels == 3)
TIFFSetField(pTIF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
else
TIFFSetField(pTIF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
switch (pImg->format)
{
case FMT_UINT:
TIFFSetField(pTIF, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
break;
case FMT_INT:
TIFFSetField(pTIF, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_INT);
break;
case FMT_REAL:
TIFFSetField(pTIF, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
break;
default:
return BAD_ARGS;
}
if (pProps)
{
TIFFSetField(pTIF, TIFFTAG_XRESOLUTION, pProps->xDPI);
TIFFSetField(pTIF, TIFFTAG_YRESOLUTION, pProps->yDPI);
TIFFSetField(pTIF, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
switch(pProps->comp)
{
case IFC_LZW: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_LZW); break;
case IFC_DEFLATE: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE); break;
case IFC_PACKBITS: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS); break;
case IFC_JPEG: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_JPEG); break;
case IFC_RLE: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_CCITTRLE); break;
case IFC_GROUP3: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3); break;
case IFC_GROUP4: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4); break;
default: TIFFSetField(pTIF, TIFFTAG_COMPRESSION, COMPRESSION_NONE); break;
}
if (pProps->comp == IFC_JPEG && pProps->qty >= 0 && pProps->qty <= 100)
TIFFSetField(pTIF, TIFFTAG_JPEGQUALITY, pProps->qty);
}
if (bpp == 1 && pImg->channelDepth > 0)
{
if (pImg->channelDepth > 1 || pImg->channels > 1 || pImg->format != FMT_UINT)
return NOT_IMPLEMENTED;
const uint8_t level = 128;
size_t size = (pImg->width + 7) / 8;
scoped_cpp_array<uint8_t> pBuf(new uint8_t[size]);
for (int y = 0; y < pImg->height; y++)
{
PackLine(pBuf, pImg->pScan0 + pImg->stride * y, level, pImg->width, false);
SHOULD_WORK(TIFFWriteScanline(pTIF, pBuf, y, 0));
}
}
else if (bpp == 8 && pImg->channelDepth == 0)
{
if (pImg->channels > 1 || pImg->format != FMT_UINT)
return NOT_IMPLEMENTED;
const int size = pImg->width;
scoped_cpp_array<uint8_t> pBuf(new uint8_t[size]);
for (int y = 0; y < pImg->height; y++)
{
UnpackLine(pBuf, pImg->pScan0 + pImg->stride * y, pImg->width, false);
SHOULD_WORK(TIFFWriteScanline(pTIF, pBuf, y, 0));
}
}
else
{
for (int y = 0; y < pImg->height; y++)
{
SHOULD_WORK(TIFFWriteScanline(pTIF, pImg->pScan0 + pImg->stride * y, y, 0));
}
}
return NO_ERRORS;
}
int LoadTiff
(
const MinImg *pImg,
const char *pFileName,
int page
)
{
#ifndef WITH_TIFF
return NOT_IMPLEMENTED;
#else
if (!pImg || !pFileName || page < 0)
return BAD_ARGS;
if (!pImg->pScan0)
return BAD_ARGS;
TIFFSetErrorHandler(NULL);
TIFFSetWarningHandler(NULL);
scoped_tiff_handle pTIF(TIFFOpen(pFileName, "r"));
if (!pTIF)
return FILE_ERROR;
const int nPages = TIFFNumberOfDirectories(pTIF);
if (page >= nPages)
return BAD_ARGS;
TIFFSetDirectory(pTIF, page);
int nc = 0, typ = PLANARCONFIG_CONTIG;
_TIFFGetField(pTIF, TIFFTAG_SAMPLESPERPIXEL, &nc, 1);
if (nc > 1)
_TIFFGetField(pTIF, TIFFTAG_PLANARCONFIG, &typ, PLANARCONFIG_CONTIG);
if (typ != PLANARCONFIG_CONTIG)
return NOT_IMPLEMENTED;
int wd = 0, ht = 0, bpc = 0;
_TIFFGetField(pTIF, TIFFTAG_IMAGEWIDTH, &wd, 0);
_TIFFGetField(pTIF, TIFFTAG_IMAGELENGTH, &ht, 0);
_TIFFGetField(pTIF, TIFFTAG_BITSPERSAMPLE, &bpc, 0);
if (bpc != 1 && bpc & 7)
return NOT_IMPLEMENTED;
bpc = bpc >> 3;
if (pImg->channels != nc)
return BAD_ARGS;
if (bpc == 0 && pImg->channelDepth > 1)
return BAD_ARGS;
if (bpc > 0 && pImg->channelDepth != bpc)
return BAD_ARGS;
if (pImg->height < ht || pImg->width < wd)
return BAD_ARGS;
int metr = 0;
_TIFFGetField(pTIF, TIFFTAG_PHOTOMETRIC, &metr, PHOTOMETRIC_MINISWHITE);
if (metr == PHOTOMETRIC_MINISWHITE && bpc > 0)
return NOT_IMPLEMENTED;
int dtyp = SAMPLEFORMAT_UINT;
_TIFFGetField(pTIF, TIFFTAG_SAMPLEFORMAT, &dtyp, SAMPLEFORMAT_UINT);
switch (dtyp)
{
case SAMPLEFORMAT_UINT:
if (pImg->format != FMT_UINT)
return BAD_ARGS;
break;
case SAMPLEFORMAT_INT:
if (pImg->format != FMT_INT)
return BAD_ARGS;
break;
case SAMPLEFORMAT_IEEEFP:
if (pImg->format != FMT_REAL)
return BAD_ARGS;
break;
default:
return NOT_IMPLEMENTED;
}
const tsize_t scanLen = TIFFScanlineSize(pTIF);
scoped_scanline pScanLine(_TIFFmalloc(scanLen));
if (!pScanLine)
return NO_MEMORY;
const int byteWidth = pImg->channelDepth > 0 ?
pImg->width * pImg->channels * pImg->channelDepth :
(pImg->width * pImg->channels + 7) >> 3;
if (byteWidth < scanLen)
return INTERNAL_ERROR;
bool invert = (metr == PHOTOMETRIC_MINISWHITE);
uint8_t *pScanLineUint8 = (uint8_t *)((void *)(pScanLine));
for (int y = 0; y < ht; y++)
{
SHOULD_WORK(TIFFReadScanline(pTIF, pScanLine, y));
if (bpc == 0 && bpc == pImg->channelDepth)
CopyBits(pImg->pScan0 + pImg->stride * y, pScanLineUint8, wd, invert);
else if (bpc == 0 && bpc < pImg->channelDepth)
UnpackLine(pImg->pScan0 + pImg->stride * y, pScanLineUint8, wd, invert);
else
memcpy(pImg->pScan0 + pImg->stride * y, pScanLine, scanLen);
}
return NO_ERRORS;
#endif // WITH_TIFF
}
int main(int argc, char *argv[])
{
const char *fn = __func__;
LALStatus status = empty_status;
SFTCatalog *catalog = NULL;
SFTConstraints constraints = empty_constraints;
SFTVector *sft_vect = NULL;
SFTVector *sft_vect2 = NULL;
MultiSFTVector *multsft_vect = NULL;
MultiSFTVector *multsft_vect2 = NULL;
CHAR detector[2] = "H1";
INT4 crc_check;
/* band to read from infile.* SFTs */
REAL8 fMin = 1008.5;
REAL8 fMax = 1009.1;
if ( argc == 1) /* avoid warning */
argc = 1;
/* check that mal-formated SFTs are properly detected */
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad1", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad2", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad3", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad4", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad5", NULL ), &status);
/* the following (SFT-bad6) has a wrong CRC64 checksum. However, this is
* not checked in LALSFTdataFind, so it should succeed! */
SHOULD_WORK( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad6", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad7", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad8", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad9", NULL ), &status);
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad10", NULL ), &status );
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad11", NULL ), &status );
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad12", NULL ), &status );
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad13", NULL ), &status );
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-bad14", NULL ), &status );
/* now check some crc-checksums */
SHOULD_WORK( LALCheckSFTs ( &status, &crc_check, TEST_DATA_DIR "SFT-test1", NULL ), &status );
if ( crc_check != 0 )
{
XLALPrintError ("\nLALCheckSFTs(): SFT-test1 has correct checksum but LALCheckSFTs claimed it hasn't.\n\n");
return crc_check;
}
SHOULD_WORK( LALCheckSFTs ( &status, &crc_check, TEST_DATA_DIR "SFT-bad6", NULL ), &status );
if ( crc_check != SFTFILEIO_ECRC64 )
{
XLALPrintError ( "\nLALCheckSFTs() failed to catch invalid CRC checksum in SFT-bad6 \n\n");
return SFTFILEIOTESTC_ESUB;
}
/* check that proper v2-SFTs are read-in properly */
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test1", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test2", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test3", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test4", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test5", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test6", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test7", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
/* now completely read-in a v2 merged-SFT */
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test*", NULL ), &status );
/* skip sft nr 4 with has Tsft=50 instead of Tsft=60 */
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test[123567]*", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
/* try the same with a ";" separated list of files and of patterns */
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog,
TEST_DATA_DIR "SFT-test1;"
TEST_DATA_DIR "SFT-test2;"
TEST_DATA_DIR "SFT-test3;"
TEST_DATA_DIR "SFT-test5;"
TEST_DATA_DIR "SFT-test6;"
TEST_DATA_DIR "SFT-test7", NULL ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
SHOULD_WORK ( LALSFTdataFind ( &status, &catalog, TEST_DATA_DIR "SFT-test[123]*;" TEST_DATA_DIR "SFT-test[5]*", NULL ), &status );
/* load once as a single SFT-vector (mix of detectors) */
SHOULD_WORK ( LALLoadSFTs ( &status, &sft_vect, catalog, -1, -1 ), &status );
/* load once as a multi-SFT vector */
SHOULD_WORK ( LALLoadMultiSFTs ( &status, &multsft_vect, catalog, -1, -1 ), &status );
/* load again, using XLAL API */
if ( ( multsft_vect2 = XLALLoadMultiSFTs ( catalog, -1, -1 )) == NULL ) {
XLALPrintError ("%s: XLALLoadMultiSFTs (cat, -1, -1) failed with xlalErrno = %d\n", fn, xlalErrno );
return SFTFILEIOTESTC_ESUB;
}
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
/* 6 SFTs from 2 IFOs should have been read */
if ( (sft_vect->length != 4) /* either as a single SFTVector */
|| (multsft_vect->length != 2) /* or separated by detector */
|| (multsft_vect->data[0]->length != 3) || ( multsft_vect->data[1]->length != 1 ) )
{
XLALPrintError ( "\nFailed to read in multi-SFT from 2 IFOs 'SFT-test*'!\n\n");
return SFTFILEIOTESTC_ESUB;
}
/* compare results from LALLoadMultiSFTs() and XLALLoadMultiSFTs() */
{
UINT4 numIFOs = multsft_vect->length;
UINT4 X;
for ( X=0; X < numIFOs; X ++ )
{
if( CompareSFTVectors ( multsft_vect->data[X], multsft_vect2->data[X] ) ) {
XLALPrintError ("%s: comparing (X)LALLoadMultiSFTs(): sft-vectors differ for X=%d\n", fn, X );
return SFTFILEIOTESTC_ESUB;
}
} /* for X < numIFOs */
} /* ------ */
/* ----- v2 SFT writing ----- */
/* write v2-SFT to disk */
SHOULD_WORK ( LALWriteSFT2file( &status, &(multsft_vect->data[0]->data[0]), "outputsftv2_v2.sft", "A v2-SFT file for testing!"), &status );
SHOULD_WORK ( LALWriteSFTVector2Dir( &status, multsft_vect->data[0], ".", "A v2-SFT file for testing!", "test"), &status);
/* write v2-SFT to single file */
{
const CHAR *currSingleSFT = NULL;
UINT4 i = 0;
FILE *fpConcat = NULL, *fpSingle = NULL;
int concat = 0, single = 0;
xlalErrno = 0;
if (XLAL_SUCCESS != XLALWriteSFTVector2File ( multsft_vect->data[0], ".", "A v2-SFT file for testing!", "test_concat" )) {
LALPrintError ( "\n XLALWriteSFTVector2File failed to write multi-SFT vector to file!\n\n");
return SFTFILEIOTESTC_ESUB;
}
/* check that the single file SFT is the same as the single SFTs */
const UINT4 numSingleSFTs = 3;
const CHAR *singleSFTs[] = {
"H-1_H1_60SFT_test-000012345-61.sft",
"H-1_H1_60SFT_test-000012465-61.sft",
"H-1_H1_60SFT_test-000012585-61.sft"
};
printf("*** Comparing single and concatenated SFTs ***\n");
/* try to open concatenated SFT */
const CHAR *concatSFT = "H-3_H1_60SFT_test_concat-000012345-302.sft";
if ( ( fpConcat = fopen(concatSFT, "rb" ) ) == NULL ) {
LALPrintError ( "\n Cound not open SFT '%s'!\n\n", concatSFT);
return SFTFILEIOTESTC_ESUB;
}
/* do loop while concat. SFT has data */
while (!feof(fpConcat)) {
/* get character from concat. SFT */
concat = fgetc(fpConcat);
if ( ferror(fpConcat) ) {
LALPrintError ( "\n IO error reading '%s'!\n\n", concatSFT);
return SFTFILEIOTESTC_ESUB;
}
/* get character from single SFT */
while (1) {
/* need to open next single SFT file */
if (fpSingle == NULL) {
/* break if we've run out of single SFTs */
if (i == numSingleSFTs)
break;
/* try to open single SFT */
if ( ( fpSingle = fopen(singleSFTs[i], "rb" ) ) == NULL ) {
LALPrintError ( "\n Cound not open SFT '%s'!\n\n", singleSFTs[i]);
return SFTFILEIOTESTC_ESUB;
}
currSingleSFT = singleSFTs[i];
}
/* get character from single SFT */
single = fgetc(fpSingle);
if ( ferror(fpSingle) ) {
LALPrintError ( "\n IO error reading '%s'!\n\n", singleSFTs[i]);
return SFTFILEIOTESTC_ESUB;
}
/* if single SFT is out of data, close it (open next one at beginning of loop) */
if (feof(fpSingle)) {
fclose(fpSingle);
fpSingle = NULL;
++i;
}
/* otherwise we have a valid character */
else
break;
}
/* do character-by-character comparison */
if ( concat != single ) {
LALPrintError ( "\n Comparison failed between '%s'(last char = %i) and '%s'(last char = %i)!!\n\n",
concatSFT, concat, currSingleSFT, single );
return SFTFILEIOTESTC_ESFTDIFF;
}
}
fclose(fpConcat);
printf( "*** Comparing was successful!!! ***\n");
}
/* write v2-SFt as a v1-SFT to disk (correct normalization) */
multsft_vect->data[0]->data[0].epoch.gpsSeconds += 60; /* shift start-time so they don't look like segmented SFTs! */
SHOULD_WORK ( LALWrite_v2SFT_to_v1file( &status, &(multsft_vect->data[0]->data[0]), "outputsftv2_v1.sft"), &status );
SUB ( LALDestroySFTVector ( &status, &sft_vect ), &status );
SUB ( LALDestroyMultiSFTVector (&status, &multsft_vect ), &status );
SUB ( LALDestroyMultiSFTVector (&status, &multsft_vect2 ), &status );
/* ----- read the previous two SFTs back */
SHOULD_FAIL ( LALSFTdataFind ( &status, &catalog, "outputsftv2_*.sft", NULL ), &status );
/* need to set proper detector! */
constraints.detector = detector;
SUB ( LALSFTdataFind ( &status, &catalog, "outputsftv2_*.sft", &constraints ), &status);
SUB ( LALLoadSFTs ( &status, &sft_vect, catalog, -1, -1 ), &status );
if ( sft_vect->length != 2 )
{
if ( lalDebugLevel ) XLALPrintError ("\nFailed to read back in 'outputsftv2_*.sft'\n\n");
return SFTFILEIOTESTC_ESUB;
}
sft_vect2 = XLALLoadSFTs ( catalog, -1, -1 );
if (!sft_vect2)
{
XLALPrintError ( "\nXLALLoadSFTs() call failed (where it should have succeeded)!\n\n");
return SFTFILEIOTESTC_ESUB;
}
/* compare the SFT vectors just read */
if(CompareSFTVectors(sft_vect, sft_vect2))
return SFTFILEIOTESTC_ESUB;
/* the data of 'outputsftv2_v2.sft' and 'outputsftv2_v1.sft' should agree, as the normalization
* should be corrected again when reading-in
*/
{
UINT4 i;
UINT4 numBins = sft_vect->data[0].data->length;
for ( i=0; i < numBins; i++)
{
COMPLEX8 *data1 = &(sft_vect->data[0].data->data[i]);
COMPLEX8 *data2 = &(sft_vect->data[1].data->data[i]);
if ( (crealf(*data1) != crealf(*data2)) || (cimagf(*data1) != cimagf(*data2)) )
{
XLALPrintError ("\nv1- and v2- SFT differ after writing/reading\n\n");
return SFTFILEIOTESTC_ESFTDIFF;
}
} /* for i < numBins */
}
SUB ( LALDestroySFTVector (&status, &sft_vect2 ), &status );
SUB ( LALDestroySFTVector (&status, &sft_vect ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
/* `----- v1 SFT writing */
/* read v1-SFTs: 'inputsft.0' and 'inputsft.1' (one is big-endian, the other little-endian!) */
SUB ( LALSFTdataFind (&status, &catalog, TEST_DATA_DIR "inputsft.?", &constraints ), &status );
SUB ( LALLoadSFTs ( &status, &sft_vect, catalog, fMin, fMax ), &status );
if ( sft_vect->length != 2 )
{
if ( lalDebugLevel ) XLALPrintError ("\nFailed to read in v1-SFTs 'inputsft.0' and 'inputsft.1'\n\n");
return SFTFILEIOTESTC_ESUB;
}
/* read with XLALLoadSFTs() */
sft_vect2 = XLALLoadSFTs ( catalog, fMin, fMax );
if (!sft_vect2)
{
XLALPrintError ( "\nXLALLoadSFTs() call failed (where it should have succeeded)!\n\n");
return SFTFILEIOTESTC_ESUB;
}
/* compare the SFT vectors just read */
if(CompareSFTVectors(sft_vect, sft_vect2))
return SFTFILEIOTESTC_ESUB;
/* write v1-SFT to disk */
SUB ( LALWriteSFTfile (&status, &(sft_vect->data[0]), "outputsft_v1.sft"), &status);
/* try to write this v1-SFTs as v2: should fail without detector-info ! */
strncpy( sft_vect->data[0].name, "??", 2 );
SHOULD_FAIL (LALWriteSFT2file( &status, &(sft_vect->data[0]), "outputsft_v2.sft", "Another v2-SFT file for testing!"), &status );
/* put detector there */
strcpy ( sft_vect->data[0].name, "H1" );
SHOULD_WORK (LALWriteSFT2file( &status, &(sft_vect->data[0]), "outputsft_v2.sft", "Another v2-SFT file for testing!"), &status );
SUB ( LALDestroySFTVector (&status, &sft_vect2 ), &status );
SUB ( LALDestroySFTVector (&status, &sft_vect ), &status );
SUB ( LALDestroySFTCatalog( &status, &catalog), &status );
/* ---------- test timestamps-reading functions by comparing LAL- and XLAL-versions against each other ---------- */
{
#define TS_FNAME "testTimestamps.dat"
LIGOTimeGPSVector *ts1 = NULL, *ts2 = NULL;
/* ----- load timestamps with deprecated LAL function */
SUB ( LALReadTimestampsFile ( &status, &ts1, TEST_DATA_DIR TS_FNAME ), &status );
/* ----- load timestamps w new XLAL function */
if ( (ts2 = XLALReadTimestampsFile ( TEST_DATA_DIR TS_FNAME )) == NULL ) {
XLALPrintError ("XLALReadTimestampsFile() failed to read timestamps from file '%s'. xlalErrno = %d\n", TS_FNAME );
return SFTFILEIOTESTC_ESUB;
}
/* ----- compare the two */
if ( ts1->length != ts2->length ) {
XLALPrintError ("Read timestamps-lists differ in length %d != %d\n", ts1->length, ts2->length );
return 1;
}
if ( ts1->deltaT != ts2->deltaT ) {
XLALPrintError ("Read timestamps-lists differ in deltaT %g != %g\n", ts1->deltaT, ts2->deltaT );
return 1;
}
UINT4 i, numTS = ts1->length;
for ( i = 0; i < numTS; i ++ )
{
if ( XLALGPSDiff( &ts1->data[i], &ts2->data[i]) != 0 ) {
XLALPrintError ("Read timestamps-lists differ in entry %d: { %d, %d } != { %d, %d }\n",
i + 1,
ts1->data[i].gpsSeconds, ts1->data[i].gpsNanoSeconds,
ts2->data[i].gpsSeconds, ts2->data[i].gpsNanoSeconds );
return 1;
}
} /* for i < numTS */
/* free mem */
XLALDestroyTimestampVector ( ts1 );
XLALDestroyTimestampVector ( ts2 );
}
/* ------------------------------ */
LALCheckMemoryLeaks();
XLALPrintError ("\n\n--------------------------------------------------------------------------------\n");
XLALPrintError ("\n OK. All tests passed correctly ! (error-messages above are OK!)\n");
XLALPrintError ("\n--------------------------------------------------------------------------------\n");
INFO( SFTFILEIOTESTC_MSGENORM );
return SFTFILEIOTESTC_ENORM;
}
/* ----------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
LALStatus status = empty_status;
CHAR filename[128];
NRWaveCatalog nrcatalog;
UINT4 k, length;
REAL4TimeVectorSeries *nrdata=NULL;
argc=0;
sprintf(filename, "NRWaveIOTest.data");
SHOULD_WORK (LALReadNRWave(&status, &nrdata, 10.0, filename), &status);
length = nrdata->data->vectorLength;
for (k = 0; k < length; k++) {
fprintf(stdout, "%e %e %e\n", k*nrdata->deltaT, nrdata->data->data[k],
nrdata->data->data[length+k]);
}
fprintf(stdout, "%%filename=%s, deltaT=%e sec, Heterodyne Freq.=%e, length=%d \n",
nrdata->name, nrdata->deltaT, nrdata->f0, nrdata->data->vectorLength);
XLALDestroyREAL4VectorSequence ( nrdata->data );
LALFree(nrdata);
/* test config file reading */
sprintf(filename, "example.cfg");
SHOULD_WORK (LALNRDataFind( &status, &nrcatalog, ".", filename), &status);
fprintf(stdout, "config file %s contains %d waves\n", filename, nrcatalog.length);
for ( k = 0; k < nrcatalog.length; k++) {
fprintf(stdout,"\n\n Wave # %d:\n", k);
fprintf(stdout, "Mass ratio = %f, spin1=(%f,%f,%f), spin2=(%f,%f, %f), l=%d, m=%d, datafile=%s\n",
nrcatalog.data[k].massRatio, nrcatalog.data[k].spin1[0], nrcatalog.data[k].spin1[1],
nrcatalog.data[k].spin1[2], nrcatalog.data[k].spin2[0], nrcatalog.data[k].spin1[1],
nrcatalog.data[k].spin1[2], nrcatalog.data[k].mode[0], nrcatalog.data[k].mode[1],
nrcatalog.data[k].filename);
}
SHOULD_WORK (LALReadNRWave(&status, &nrdata, 10.0, nrcatalog.data[0].filename), &status);
for (k = 0; k < length; k++) {
fprintf(stdout, "%e %e %e\n", k*nrdata->deltaT, nrdata->data->data[k],
nrdata->data->data[length+k]);
}
fprintf(stdout, "%%filename=%s, deltaT=%e sec, Heterodyne Freq.=%e, length=%d \n",
nrdata->name, nrdata->deltaT, nrdata->f0, nrdata->data->vectorLength);
XLALDestroyREAL4VectorSequence ( nrdata->data );
LALFree(nrdata);
LALFree(nrcatalog.data);
LALCheckMemoryLeaks();
INFO( NRWAVEIOTESTC_MSGENORM );
return NRWAVEIOTESTC_ENORM;
}
