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 pointer */ static LALStatus status; /* time and velocity */ static LIGOTimeGPSVector timeV; static REAL8Cart3CoorVector velV; static REAL8Vector timeDiffV; LIGOTimeGPS firstTimeStamp; /* standard pulsar sft types */ MultiSFTVector *inputSFTs = NULL; UINT4 binsSFT; UINT4 sftFminBin; UINT4 numsft; INT4 k; FILE *fp=NULL; /* information about all the ifos */ MultiDetectorStateSeries *mdetStates = NULL; UINT4 numifo; /* vector of weights */ REAL8Vector weightsV; /* ephemeris */ EphemerisData *edat=NULL; static UCHARPeakGram pg1; static HoughTemplate pulsarTemplate; static REAL8Vector foft; /* miscellaneous */ UINT4 mObsCoh; REAL8 timeBase, deltaF; REAL8 numberCount; /* Chi2Test parameters */ HoughParamsTest chi2Params; REAL8Vector numberCountV; /* Vector with the number count of each block inside */ REAL8 numberCountTotal; /* Sum over all the numberCounts */ REAL8 chi2; /* sft constraint variables */ LIGOTimeGPS startTimeGPS, endTimeGPS; LIGOTimeGPSVector *inputTimeStampsVector=NULL; REAL8 alphaPeak, meanN, sigmaN; /* user input variables */ BOOLEAN uvar_help, uvar_weighAM, uvar_weighNoise; INT4 uvar_blocksRngMed, uvar_nfSizeCylinder, uvar_maxBinsClean; REAL8 uvar_startTime, uvar_endTime; REAL8 uvar_fStart, uvar_peakThreshold, uvar_fSearchBand; REAL8 uvar_Alpha, uvar_Delta, uvar_Freq, uvar_fdot; REAL8 uvar_AlphaWeight, uvar_DeltaWeight; CHAR *uvar_earthEphemeris=NULL; CHAR *uvar_sunEphemeris=NULL; CHAR *uvar_sftDir=NULL; CHAR *uvar_timeStampsFile=NULL; CHAR *uvar_outfile=NULL; LALStringVector *uvar_linefiles=NULL; INT4 uvar_p; /* Set up the default parameters */ /* LAL error-handler */ lal_errhandler = LAL_ERR_EXIT; uvar_help = FALSE; uvar_weighAM = TRUE; uvar_weighNoise = TRUE; uvar_blocksRngMed = BLOCKSRNGMED; uvar_nfSizeCylinder = NFSIZE; uvar_fStart = F0; uvar_fSearchBand = FBAND; uvar_peakThreshold = THRESHOLD; uvar_maxBinsClean = 100; uvar_startTime= 0; uvar_endTime = LAL_INT4_MAX; uvar_Alpha = 1.0; uvar_Delta = 1.0; uvar_Freq = 310.0; uvar_fdot = 0.0; uvar_AlphaWeight = uvar_Alpha; uvar_DeltaWeight = uvar_Delta; uvar_p = NBLOCKSTEST; chi2Params.length=uvar_p; chi2Params.numberSFTp=NULL; chi2Params.sumWeight=NULL; chi2Params.sumWeightSquare=NULL; uvar_outfile = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_outfile, "./tempout"); uvar_earthEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_earthEphemeris,EARTHEPHEMERIS); uvar_sunEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_sunEphemeris,SUNEPHEMERIS); uvar_sftDir = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR)); strcpy(uvar_sftDir,SFTDIRECTORY); /* register user input variables */ LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status); LAL_CALL( LALRegisterREALUserVar( &status, "fStart", 'f', UVAR_OPTIONAL, "Start search frequency", &uvar_fStart), &status); LAL_CALL( LALRegisterREALUserVar( &status, "fSearchBand", 'b', UVAR_OPTIONAL, "Search frequency band", &uvar_fSearchBand), &status); LAL_CALL( LALRegisterREALUserVar( &status, "startTime", 0, UVAR_OPTIONAL, "GPS start time of observation", &uvar_startTime), &status); LAL_CALL( LALRegisterREALUserVar( &status, "endTime", 0, UVAR_OPTIONAL, "GPS end time of observation", &uvar_endTime), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "timeStampsFile", 0, UVAR_OPTIONAL, "Input time-stamps file", &uvar_timeStampsFile), &status); LAL_CALL( LALRegisterREALUserVar( &status, "peakThreshold", 0, UVAR_OPTIONAL, "Peak selection threshold", &uvar_peakThreshold), &status); LAL_CALL( LALRegisterBOOLUserVar( &status, "weighAM", 0, UVAR_OPTIONAL, "Use amplitude modulation weights", &uvar_weighAM), &status); LAL_CALL( LALRegisterBOOLUserVar( &status, "weighNoise", 0, UVAR_OPTIONAL, "Use SFT noise weights", &uvar_weighNoise), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_OPTIONAL, "Earth Ephemeris file", &uvar_earthEphemeris), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_OPTIONAL, "Sun Ephemeris file", &uvar_sunEphemeris), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status); LAL_CALL( LALRegisterLISTUserVar( &status, "linefiles", 0, UVAR_OPTIONAL, "Comma separated List of linefiles (filenames must contain IFO name)", &uvar_linefiles), &status); LAL_CALL( LALRegisterREALUserVar( &status, "Alpha", 0, UVAR_OPTIONAL, "Sky location (longitude)", &uvar_Alpha), &status); LAL_CALL( LALRegisterREALUserVar( &status, "Delta", 0, UVAR_OPTIONAL, "Sky location (latitude)", &uvar_Delta), &status); LAL_CALL( LALRegisterREALUserVar( &status, "Freq", 0, UVAR_OPTIONAL, "Template frequency", &uvar_Freq), &status); LAL_CALL( LALRegisterREALUserVar( &status, "fdot", 0, UVAR_OPTIONAL, "First spindown", &uvar_fdot), &status); LAL_CALL( LALRegisterREALUserVar( &status, "AlphaWeight", 0, UVAR_OPTIONAL, "sky Alpha for weight calculation", &uvar_AlphaWeight), &status); LAL_CALL( LALRegisterREALUserVar( &status, "DeltaWeight", 0, UVAR_OPTIONAL, "sky Delta for weight calculation", &uvar_DeltaWeight), &status); LAL_CALL( LALRegisterINTUserVar( &status, "nfSizeCylinder", 0, UVAR_OPTIONAL, "Size of cylinder of PHMDs", &uvar_nfSizeCylinder), &status); LAL_CALL( LALRegisterINTUserVar( &status, "blocksRngMed", 0, UVAR_OPTIONAL, "Running Median block size", &uvar_blocksRngMed), &status); LAL_CALL( LALRegisterINTUserVar( &status, "maxBinsClean", 0, UVAR_OPTIONAL, "Maximum number of bins in cleaning", &uvar_maxBinsClean), &status); LAL_CALL( LALRegisterSTRINGUserVar( &status, "outfile", 0, UVAR_OPTIONAL, "output file name", &uvar_outfile), &status); LAL_CALL( LALRegisterINTUserVar( &status, "pdatablock", 'p', UVAR_OPTIONAL, "Number of data blocks for veto tests", &uvar_p), &status); /* read all command line variables */ LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status); /* exit if help was required */ if (uvar_help) exit(0); /* very basic consistency checks on user input */ if ( uvar_fStart < 0 ) { fprintf(stderr, "start frequency must be positive\n"); exit(1); } if ( uvar_fSearchBand < 0 ) { fprintf(stderr, "search frequency band must be positive\n"); exit(1); } if ( uvar_peakThreshold < 0 ) { fprintf(stderr, "peak selection threshold must be positive\n"); exit(1); } /***** start main calculations *****/ chi2Params.length=uvar_p; chi2Params.numberSFTp = (UINT4 *)LALMalloc( uvar_p*sizeof(UINT4)); chi2Params.sumWeight = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8)); chi2Params.sumWeightSquare = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8)); /* read sft Files and set up weights */ { /* new SFT I/O data types */ SFTCatalog *catalog = NULL; static SFTConstraints constraints; REAL8 doppWings, f_min, f_max; /* set detector constraint */ constraints.detector = NULL; if ( LALUserVarWasSet( &uvar_startTime ) ) { XLALGPSSetREAL8(&startTimeGPS, uvar_startTime); constraints.minStartTime = &startTimeGPS; } if ( LALUserVarWasSet( &uvar_endTime ) ) { XLALGPSSetREAL8(&endTimeGPS, uvar_endTime); constraints.maxEndTime = &endTimeGPS; } if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) { LAL_CALL ( LALReadTimestampsFile ( &status, &inputTimeStampsVector, uvar_timeStampsFile), &status); constraints.timestamps = inputTimeStampsVector; } /* get sft catalog */ LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status); if ( (catalog == NULL) || (catalog->length == 0) ) { fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir ); exit(1); } /* now we can free the inputTimeStampsVector */ if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) { LALDestroyTimestampVector ( &status, &inputTimeStampsVector); } /* get some sft parameters */ mObsCoh = catalog->length; /* number of sfts */ deltaF = catalog->data->header.deltaF; /* frequency resolution */ timeBase= 1.0/deltaF; /* coherent integration time */ // unused: UINT8 f0Bin = floor( uvar_fStart * timeBase + 0.5); /* initial search frequency */ // unused: INT4 length = uvar_fSearchBand * timeBase; /* total number of search bins - 1 */ /* catalog is ordered in time so we can get start, end time and tObs*/ firstTimeStamp = catalog->data[0].header.epoch; // unused: LIGOTimeGPS lastTimeStamp = catalog->data[mObsCoh - 1].header.epoch; /* allocate memory for velocity vector */ velV.length = mObsCoh; velV.data = NULL; velV.data = (REAL8Cart3Coor *)LALCalloc(mObsCoh, sizeof(REAL8Cart3Coor)); /* allocate memory for timestamps vector */ timeV.length = mObsCoh; timeV.data = NULL; timeV.data = (LIGOTimeGPS *)LALCalloc( mObsCoh, sizeof(LIGOTimeGPS)); /* allocate memory for vector of time differences from start */ timeDiffV.length = mObsCoh; timeDiffV.data = NULL; timeDiffV.data = (REAL8 *)LALCalloc(mObsCoh, sizeof(REAL8)); /* add wings for Doppler modulation and running median block size*/ doppWings = (uvar_fStart + uvar_fSearchBand) * VTOT; f_min = uvar_fStart - doppWings - (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF; f_max = uvar_fStart + uvar_fSearchBand + doppWings + (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF; /* read sft files making sure to add extra bins for running median */ /* read the sfts */ LAL_CALL( LALLoadMultiSFTs ( &status, &inputSFTs, catalog, f_min, f_max), &status); /* clean sfts if required */ if ( LALUserVarWasSet( &uvar_linefiles ) ) { RandomParams *randPar=NULL; FILE *fpRand=NULL; INT4 seed, ranCount; if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) { fprintf(stderr,"Error in opening /dev/urandom" ); exit(1); } if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) { fprintf(stderr,"Error in getting random seed" ); exit(1); } LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status ); LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar_maxBinsClean, uvar_blocksRngMed, uvar_linefiles, randPar), &status); LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status); fclose(fpRand); } /* end cleaning */ /* SFT info -- assume all SFTs have same length */ numifo = inputSFTs->length; binsSFT = inputSFTs->data[0]->data->data->length; sftFminBin = (INT4) floor(inputSFTs->data[0]->data[0].f0 * timeBase + 0.5); LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status); } /* end of sft reading block */ /* get detector velocities weights vector, and timestamps */ { MultiNoiseWeights *multweight = NULL; MultiPSDVector *multPSD = NULL; UINT4 iIFO, iSFT, j; /* get ephemeris */ edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData)); (*edat).ephiles.earthEphemeris = uvar_earthEphemeris; (*edat).ephiles.sunEphemeris = uvar_sunEphemeris; LAL_CALL( LALInitBarycenter( &status, edat), &status); /* normalize sfts */ LAL_CALL( LALNormalizeMultiSFTVect (&status, &multPSD, inputSFTs, uvar_blocksRngMed), &status); /* set up weights */ weightsV.length = mObsCoh; weightsV.data = (REAL8 *)LALCalloc(1, mObsCoh * sizeof(REAL8)); /* initialize all weights to unity */ LAL_CALL( LALHOUGHInitializeWeights( &status, &weightsV), &status); /* compute multi noise weights if required */ if ( uvar_weighNoise ) { LAL_CALL ( LALComputeMultiNoiseWeights ( &status, &multweight, multPSD, uvar_blocksRngMed, 0), &status); } /* we are now done with the psd */ LAL_CALL ( LALDestroyMultiPSDVector ( &status, &multPSD), &status); /* get information about all detectors including velocity and timestamps */ /* note that this function returns the velocity at the mid-time of the SFTs -- should not make any difference */ LAL_CALL ( LALGetMultiDetectorStates ( &status, &mdetStates, inputSFTs, edat), &status); /* copy the timestamps, weights, and velocity vector */ for (j = 0, iIFO = 0; iIFO < numifo; iIFO++ ) { numsft = mdetStates->data[iIFO]->length; for ( iSFT = 0; iSFT < numsft; iSFT++, j++) { velV.data[j].x = mdetStates->data[iIFO]->data[iSFT].vDetector[0]; velV.data[j].y = mdetStates->data[iIFO]->data[iSFT].vDetector[1]; velV.data[j].z = mdetStates->data[iIFO]->data[iSFT].vDetector[2]; if ( uvar_weighNoise ) weightsV.data[j] = multweight->data[iIFO]->data[iSFT]; /* mid time of sfts */ timeV.data[j] = mdetStates->data[iIFO]->data[iSFT].tGPS; } /* loop over SFTs */ } /* loop over IFOs */ if ( uvar_weighNoise ) { LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status); } /* compute the time difference relative to startTime for all SFTs */ for(j = 0; j < mObsCoh; j++) timeDiffV.data[j] = XLALGPSDiff( timeV.data + j, &firstTimeStamp ); if ( uvar_weighNoise ) { LAL_CALL ( LALDestroyMultiNoiseWeights ( &status, &multweight), &status); } } /* end block for noise weights, velocity and time */ /* calculate amplitude modulation weights if required */ if (uvar_weighAM) { MultiAMCoeffs *multiAMcoef = NULL; UINT4 iIFO, iSFT; SkyPosition skypos; /* get the amplitude modulation coefficients */ skypos.longitude = uvar_AlphaWeight; skypos.latitude = uvar_DeltaWeight; skypos.system = COORDINATESYSTEM_EQUATORIAL; LAL_CALL ( LALGetMultiAMCoeffs ( &status, &multiAMcoef, mdetStates, skypos), &status); /* loop over the weights and multiply them by the appropriate AM coefficients */ for ( k = 0, iIFO = 0; iIFO < numifo; iIFO++) { numsft = mdetStates->data[iIFO]->length; for ( iSFT = 0; iSFT < numsft; iSFT++, k++) { REAL8 a, b; a = multiAMcoef->data[iIFO]->a->data[iSFT]; b = multiAMcoef->data[iIFO]->b->data[iSFT]; weightsV.data[k] *= (a*a + b*b); } /* loop over SFTs */ } /* loop over IFOs */ LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status); XLALDestroyMultiAMCoeffs ( multiAMcoef ); } /* end AM weights calculation */ /* misc. memory allocations */ /* memory for one spindown */ pulsarTemplate.spindown.length = 1; pulsarTemplate.spindown.data = NULL; pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8)); /* copy template parameters */ pulsarTemplate.spindown.data[0] = uvar_fdot; pulsarTemplate.f0 = uvar_Freq; pulsarTemplate.latitude = uvar_Delta; pulsarTemplate.longitude = uvar_Alpha; /* memory for f(t) vector */ foft.length = mObsCoh; foft.data = NULL; foft.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8)); /* memory for peakgram */ pg1.length = binsSFT; pg1.data = NULL; pg1.data = (UCHAR *)LALCalloc( binsSFT, sizeof(UCHAR)); /* memory for number Count Vector */ numberCountV.length = uvar_p; numberCountV.data = NULL; numberCountV.data = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8)); /* block for calculating peakgram and number count */ { UINT4 iIFO, iSFT, ii, numberSFTp; INT4 ind; REAL8 sumWeightSquare; SFTtype *sft; /* compute mean and sigma for noise only */ /* first calculate the sum of the weights squared */ sumWeightSquare = 0.0; for ( k = 0; k < (INT4)mObsCoh; k++) sumWeightSquare += weightsV.data[k] * weightsV.data[k]; /* probability of selecting a peak expected mean and standard deviation for noise only */ alphaPeak = exp( - uvar_peakThreshold); meanN = mObsCoh* alphaPeak; sigmaN = sqrt(sumWeightSquare * alphaPeak * (1.0 - alphaPeak)); /* the received frequency as a function of time */ LAL_CALL( ComputeFoft(&status, &foft, &pulsarTemplate, &timeDiffV, &velV, timeBase), &status); LAL_CALL(SplitSFTs(&status, &weightsV, &chi2Params), &status); /* loop over SFT, generate peakgram and get number count */ UINT4 j; j=0; iIFO=0; iSFT=0; numsft = mdetStates->data[iIFO]->length; for (k=0 ; k<uvar_p ; k++ ){ numberSFTp=chi2Params.numberSFTp[k]; numberCount = 0; for (ii=0 ; (ii < numberSFTp)&&(iIFO<numifo) ; ii++) { sft = inputSFTs->data[iIFO]->data + iSFT; LAL_CALL (SFTtoUCHARPeakGram( &status, &pg1, sft, uvar_peakThreshold), &status); ind = floor( foft.data[j]*timeBase - sftFminBin + 0.5); numberCount += pg1.data[ind]*weightsV.data[j]; j++; iSFT++; if (iSFT >= numsft){ iIFO++; iSFT=0; if (iIFO<numifo){ numsft = mdetStates->data[iIFO]->length; } } } /* loop over SFTs */ numberCountV.data[k]=numberCount; } /* loop over blocks */ } /* Chi2 Test */ { REAL8 eta; /* Auxiliar variable */ REAL8 nj, sumWeightj, sumWeightSquarej; numberCountTotal=0; chi2=0; for(k=0; k<uvar_p ; k++){ numberCountTotal += numberCountV.data[k]; } eta=numberCountTotal/mObsCoh; INT4 j; for(j=0 ; j<(uvar_p) ; j++){ nj=numberCountV.data[j]; sumWeightj=chi2Params.sumWeight[j]; sumWeightSquarej=chi2Params.sumWeightSquare[j]; chi2 += (nj-sumWeightj*eta)*(nj-sumWeightj*eta)/(sumWeightSquarej*eta*(1-eta)); } } fp = fopen(uvar_outfile , "w"); setvbuf(fp, (char *)NULL, _IOLBF, 0); fprintf(fp, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot); /* fprintf(stdout, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot);*/ fclose(fp); /* free memory */ LALFree(pulsarTemplate.spindown.data); LALFree(timeV.data); LALFree(timeDiffV.data); LALFree(foft.data); LALFree(velV.data); LALFree(weightsV.data); XLALDestroyMultiDetectorStateSeries ( mdetStates ); LALFree(edat->ephemE); LALFree(edat->ephemS); LALFree(edat); LAL_CALL (LALDestroyMultiSFTVector(&status, &inputSFTs), &status ); LALFree(pg1.data); LALFree(numberCountV.data); LALFree(chi2Params.numberSFTp); LALFree(chi2Params.sumWeight); LALFree(chi2Params.sumWeightSquare); LAL_CALL (LALDestroyUserVars(&status), &status); LALCheckMemoryLeaks(); if ( lalDebugLevel ) REPORTSTATUS ( &status); return status.statusCode; }
/** * Handle user-input and check its validity. * Load ephemeris and calculate AM-coefficients (stored globally) */ void Initialize (LALStatus *status, struct CommandLineArgsTag *CLA) { EphemerisData *edat=NULL; /* Stores earth/sun ephemeris data for barycentering */ BarycenterInput baryinput; /* Stores detector location and other barycentering data */ EarthState earth; AMCoeffsParams *amParams; LIGOTimeGPS *midTS=NULL; /* Time stamps for amplitude modulation coefficients */ LALDetector *Detector; /* Our detector*/ INT4 k; INITSTATUS(status); ATTATCHSTATUSPTR (status); if ( LALUserVarWasSet ( &(CLA->nTsft) ) ) CLA->duration = 1.0 * CLA->nTsft * CLA->Tsft; /* read or generate SFT timestamps */ if ( LALUserVarWasSet(&(CLA->timestamps)) ) { TRY ( LALReadTimestampsFile (status->statusPtr, ×tamps, CLA->timestamps ), status ); if ( (CLA->nTsft > 0) && ( (UINT4)CLA->nTsft < timestamps->length ) ) /* truncate if required */ timestamps->length = CLA->nTsft; CLA->nTsft = timestamps->length; } /* if have_timestamps */ else { LIGOTimeGPS tStart; tStart.gpsSeconds = CLA->gpsStart; tStart.gpsNanoSeconds = 0; TRY ( LALMakeTimestamps(status->statusPtr, ×tamps, tStart, CLA->duration, CLA->Tsft ), status ); CLA->nTsft = timestamps->length; } /* no timestamps */ /*---------- initialize detector ---------- */ { BOOLEAN have_IFO = LALUserVarWasSet ( &CLA->IFO ); BOOLEAN have_detector = LALUserVarWasSet ( &CLA->detector ); CHAR *IFO; if ( !have_IFO && !have_detector ) { fprintf (stderr, "\nNeed to specify the detector (--IFO) !\n\n"); ABORT (status, SEMIANALYTIC_EINPUT, SEMIANALYTIC_MSGEINPUT); } if ( have_IFO ) IFO = CLA->IFO; else IFO = CLA->detector; if ( ( Detector = XLALGetSiteInfo ( IFO ) ) == NULL ) { ABORT (status, SEMIANALYTIC_EINPUT, SEMIANALYTIC_MSGEINPUT); } } /* ---------- load ephemeris-files ---------- */ { edat = XLALInitBarycenter( CLA->ephemEarth, CLA->ephemSun ); if ( !edat ) { XLALPrintError("XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", CLA->ephemEarth, CLA->ephemSun); ABORT (status, SEMIANALYTIC_EINPUT, SEMIANALYTIC_MSGEINPUT); } } /* ephemeris-reading */ /* ---------- calculate AM-coefficients ---------- */ /* prepare call to barycentering routing */ baryinput.site.location[0] = Detector->location[0]/LAL_C_SI; baryinput.site.location[1] = Detector->location[1]/LAL_C_SI; baryinput.site.location[2] = Detector->location[2]/LAL_C_SI; baryinput.alpha = CLA->Alpha; baryinput.delta = CLA->Delta; baryinput.dInv = 0.e0; /* amParams structure to compute a(t) and b(t) */ /* Allocate space for amParams stucture */ /* Here, amParams->das is the Detector and Source info */ amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams)); amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource)); amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource)); /* Fill up AMCoeffsParams structure */ amParams->baryinput = &baryinput; amParams->earth = &earth; amParams->edat = edat; amParams->das->pDetector = Detector; amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL; amParams->das->pSource->equatorialCoords.longitude = CLA->Alpha; amParams->das->pSource->equatorialCoords.latitude = CLA->Delta; amParams->das->pSource->orientation = 0.0; amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!!!!!!!!*/ /* Allocate space for AMCoeffs */ amc.a = NULL; amc.b = NULL; TRY ( LALSCreateVector(status->statusPtr, &(amc.a), (UINT4) CLA->nTsft), status); TRY ( LALSCreateVector(status->statusPtr, &(amc.b), (UINT4) CLA->nTsft), status); /* Mid point of each SFT */ midTS = (LIGOTimeGPS *)LALCalloc(CLA->nTsft,sizeof(LIGOTimeGPS)); for(k=0; k < CLA->nTsft; k++) { /* FIXME: loss of precision; consider midTS[k] = timestamps->data[k]; XLALGPSAdd(&midTS[k], 0.5*CLA->Tsft); */ REAL8 teemp=0.0; teemp = XLALGPSGetREAL8(&(timestamps->data[k])); teemp += 0.5*CLA->Tsft; XLALGPSSetREAL8(&(midTS[k]), teemp); } TRY ( LALComputeAM(status->statusPtr, &amc, midTS, amParams), status); /* Free memory */ TRY ( LALDestroyTimestampVector (status->statusPtr, ×tamps), status ); LALFree(midTS); LALFree(Detector); XLALDestroyEphemerisData(edat); LALFree(amParams->das->pSource); LALFree(amParams->das); LALFree(amParams); DETATCHSTATUSPTR (status); RETURN(status); } /* ParseUserInput() */