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;
}
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[]){
static LALStatus status; /* LALStatus pointer */
static MultiSFTVector *inputSFTs = NULL;
static SFTCatalog *catalog = NULL;
static SFTCatalog thisCatalog;
static SFTConstraints constraints;
/* 09/09/05 gam; randPar now a parameter for LALCleanCOMPLEX8SFT */
FILE *fp=NULL;
INT4 seed, ranCount;
RandomParams *randPar=NULL;
UINT4 k, j;
/* user input variables */
BOOLEAN uvar_help;
LALStringVector *uvar_linefiles=NULL; /* files with harmonics info */
CHAR *uvar_sftDir; /* directory for unclean sfts */
CHAR *uvar_outDir; /* directory for cleaned sfts */
REAL8 uvar_fMin, uvar_fMax;
INT4 uvar_window, uvar_maxBins;
/* set defaults */
uvar_help = FALSE;
uvar_sftDir = (CHAR *)LALMalloc(256 * sizeof(CHAR));
strcpy(uvar_sftDir, INPUTSFTDIR);
uvar_outDir = (CHAR *)LALMalloc(256 * sizeof(CHAR));
strcpy(uvar_outDir, OUTPUTSFTDIR);
uvar_fMin = STARTFREQ;
uvar_fMax = ENDFREQ;
uvar_window = WINDOWSIZE;
uvar_maxBins = MAXBINS;
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h',UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'i',UVAR_OPTIONAL, "Input SFT file pattern", &uvar_sftDir), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "outDir", 'o',UVAR_OPTIONAL, "Output SFT Directory", &uvar_outDir), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fMin", 0, UVAR_OPTIONAL, "start Frequency", &uvar_fMin), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fMax", 0, UVAR_OPTIONAL, "Max Frequency Band", &uvar_fMax), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "window", 'w',UVAR_OPTIONAL, "Window size", &uvar_window), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "maxBins", 'm',UVAR_OPTIONAL, "Max. bins to clean", &uvar_maxBins),&status);
LAL_CALL( LALRegisterLISTUserVar( &status, "linefiles", 0, UVAR_OPTIONAL, "List of linefiles (filenames must contain IFO name)", &uvar_linefiles), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* set detector constraint */
constraints.detector = NULL;
/* 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);
}
thisCatalog.length = 1;
fprintf(stdout, "%d\n",catalog->length);
/* get a new seed value, and use it to create a new random parameter structure */
fp=fopen("/dev/urandom", "r");
if (!fp)
{
fprintf(stderr,"Error in opening /dev/urandom \n");
exit(1);
}
ranCount = fread(&seed, sizeof(seed), 1, fp);
fclose(fp);
if (!(ranCount==1))
{
fprintf(stderr,"Error in reading random seed \n");
exit(1);
}
LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status );
/* loop over sfts and clean them -- load one sft at a time */
for (j=0; j<catalog->length; j++) {
thisCatalog.data = catalog->data + j;
/* read the sfts */
LAL_CALL( LALLoadMultiSFTs ( &status, &inputSFTs, &thisCatalog, uvar_fMin, uvar_fMax), &status);
/* clean lines */
if ( LALUserVarWasSet( &uvar_linefiles ) ) {
LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar_maxBins,
uvar_window, uvar_linefiles, randPar), &status);
}
/* write output */
for (k = 0; k < inputSFTs->length; k++) {
LAL_CALL( LALWriteSFTVector2Dir ( &status, inputSFTs->data[k], uvar_outDir, "cleaned", "cleaned"), &status);
}
LAL_CALL( LALDestroyMultiSFTVector(&status, &inputSFTs), &status );
} /* end loop over sfts */
/* Free memory */
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
LAL_CALL( LALDestroyUserVars(&status), &status);
LAL_CALL( LALDestroyRandomParams (&status, &randPar), &status);
LALCheckMemoryLeaks();
return 0;
}
/** Initialized Fstat-code: handle user-input and set everything up. */
void
InitPFS ( LALStatus *status, ConfigVariables *cfg, const UserInput_t *uvar )
{
static const char *fn = "InitPFS()";
SFTCatalog *catalog = NULL;
SFTConstraints constraints = empty_SFTConstraints;
SkyPosition skypos;
LIGOTimeGPS startTime, endTime;
REAL8 duration, Tsft;
LIGOTimeGPS minStartTimeGPS, maxEndTimeGPS;
EphemerisData *edat = NULL; /* ephemeris data */
MultiAMCoeffs *multiAMcoef = NULL;
MultiPSDVector *multiRngmed = NULL;
MultiNoiseWeights *multiNoiseWeights = NULL;
MultiSFTVector *multiSFTs = NULL; /* multi-IFO SFT-vectors */
MultiDetectorStateSeries *multiDetStates = NULL; /* pos, vel and LMSTs for detector at times t_i */
UINT4 X, i;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
{ /* Check user-input consistency */
BOOLEAN have_h0, have_cosi, have_cosiota, have_Ap, have_Ac;
REAL8 cosi = 0;
have_h0 = LALUserVarWasSet ( &uvar->h0 );
have_cosi = LALUserVarWasSet ( &uvar->cosi );
have_cosiota = LALUserVarWasSet ( &uvar->cosiota );
have_Ap = LALUserVarWasSet ( &uvar->aPlus );
have_Ac = LALUserVarWasSet ( &uvar->aCross );
/* ----- handle cosi/cosiota ambiguity */
if ( (have_cosi && have_cosiota) ) {
LogPrintf (LOG_CRITICAL, "Need EITHER --cosi [preferred] OR --cosiota [deprecated]!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( have_cosiota ) {
cosi = uvar->cosiota;
have_cosi = TRUE;
}
else if ( have_cosi ) {
cosi = uvar->cosi;
have_cosi = TRUE;
}
/* ----- handle {h0,cosi} || {aPlus,aCross} freedom ----- */
if ( ( have_h0 && !have_cosi ) || ( !have_h0 && have_cosi ) )
{
LogPrintf (LOG_CRITICAL, "Need both (h0, cosi) to specify signal!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( ( have_Ap && !have_Ac) || ( !have_Ap && have_Ac ) )
{
LogPrintf (LOG_CRITICAL, "Need both (aPlus, aCross) to specify signal!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( have_h0 && have_Ap )
{
LogPrintf (LOG_CRITICAL, "Overdetermined: specify EITHER (h0,cosi) OR (aPlus,aCross)!\n");
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
/* ----- internally we always use Aplus, Across */
if ( have_h0 )
{
cfg->aPlus = 0.5 * uvar->h0 * ( 1.0 + SQ( cosi) );
cfg->aCross = uvar->h0 * uvar->cosi;
}
else
{
cfg->aPlus = uvar->aPlus;
cfg->aCross = uvar->aCross;
}
}/* check user-input */
/* ----- prepare SFT-reading ----- */
if ( LALUserVarWasSet ( &uvar->IFO ) )
if ( (constraints.detector = XLALGetChannelPrefix ( uvar->IFO )) == NULL ) {
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT);
}
minStartTimeGPS.gpsSeconds = uvar->minStartTime;
minStartTimeGPS.gpsNanoSeconds = 0;
maxEndTimeGPS.gpsSeconds = uvar->maxEndTime;
maxEndTimeGPS.gpsNanoSeconds = 0;
constraints.minStartTime = &minStartTimeGPS;
constraints.maxEndTime = &maxEndTimeGPS;
/* ----- get full SFT-catalog of all matching (multi-IFO) SFTs */
LogPrintf (LOG_DEBUG, "Finding all SFTs to load ... ");
TRY ( LALSFTdataFind ( status->statusPtr, &catalog, uvar->DataFiles, &constraints ), status);
LogPrintfVerbatim (LOG_DEBUG, "done. (found %d SFTs)\n", catalog->length);
if ( constraints.detector )
LALFree ( constraints.detector );
if ( catalog->length == 0 )
{
LogPrintf (LOG_CRITICAL, "No matching SFTs for pattern '%s'!\n", uvar->DataFiles );
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT);
}
/* ----- deduce start- and end-time of the observation spanned by the data */
{
GV.numSFTs = catalog->length; /* total number of SFTs */
Tsft = 1.0 / catalog->data[0].header.deltaF;
startTime = catalog->data[0].header.epoch;
endTime = catalog->data[GV.numSFTs-1].header.epoch;
XLALGPSAdd(&endTime, Tsft);
duration = GPS2REAL8(endTime) - GPS2REAL8 (startTime);
}
{ /* ----- load ephemeris-data ----- */
edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun );
if ( !edat ) {
XLALPrintError("XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", uvar->ephemEarth, uvar->ephemSun);
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT);
}
}
{/* ----- load the multi-IFO SFT-vectors ----- */
UINT4 wings = uvar->RngMedWindow/2 + 10; /* extra frequency-bins needed for rngmed */
REAL8 fMax = uvar->Freq + 1.0 * wings / Tsft;
REAL8 fMin = uvar->Freq - 1.0 * wings / Tsft;
LogPrintf (LOG_DEBUG, "Loading SFTs ... ");
TRY ( LALLoadMultiSFTs ( status->statusPtr, &multiSFTs, catalog, fMin, fMax ), status );
LogPrintfVerbatim (LOG_DEBUG, "done.\n");
TRY ( LALDestroySFTCatalog ( status->statusPtr, &catalog ), status );
}
TRY ( LALNormalizeMultiSFTVect (status->statusPtr, &multiRngmed, multiSFTs, uvar->RngMedWindow ), status);
TRY ( LALComputeMultiNoiseWeights (status->statusPtr, &multiNoiseWeights, multiRngmed, uvar->RngMedWindow, 0 ), status );
/* correctly handle the --SignalOnly case:
* set noise-weights to 1, and
* set Sh->1 (single-sided)
*/
if ( uvar->SignalOnly )
{
multiNoiseWeights->Sinv_Tsft = Tsft;
for ( X=0; X < multiNoiseWeights->length; X ++ )
for ( i=0; i < multiNoiseWeights->data[X]->length; i ++ )
multiNoiseWeights->data[X]->data[i] = 1.0;
}
/* ----- handle transient-signal window if given ----- */
if ( LALUserVarWasSet ( &uvar->transientWindowType ) && strcmp ( uvar->transientWindowType, "none") )
{
transientWindow_t transientWindow; /**< properties of transient-signal window */
MultiLIGOTimeGPSVector *mTS;
if ( !strcmp ( uvar->transientWindowType, "rect" ) )
transientWindow.type = TRANSIENT_RECTANGULAR; /* rectangular window [t0, t0+tau] */
else if ( !strcmp ( uvar->transientWindowType, "exp" ) )
transientWindow.type = TRANSIENT_EXPONENTIAL; /* exponential decay window e^[-(t-t0)/tau for t>t0, 0 otherwise */
else
{
XLALPrintError ("Illegal transient window '%s' specified: valid are 'none', 'rect' or 'exp'\n", uvar->transientWindowType);
ABORT ( status, PREDICTFSTAT_EINPUT, PREDICTFSTAT_MSGEINPUT );
}
if ( LALUserVarWasSet ( &uvar->transientStartTime ) )
transientWindow.t0 = uvar->transientStartTime;
else
transientWindow.t0 = XLALGPSGetREAL8( &startTime ); /* if not set, default window startTime == startTime here */
transientWindow.tau = uvar->transientTauDays;
if ( (mTS = XLALExtractMultiTimestampsFromSFTs ( multiSFTs )) == NULL ) {
XLALPrintError ("%s: failed to XLALExtractMultiTimestampsFromSFTs() from SFTs. xlalErrno = %d.\n", fn, xlalErrno );
ABORT ( status, PREDICTFSTAT_EXLAL, PREDICTFSTAT_MSGEXLAL );
}
if ( XLALApplyTransientWindow2NoiseWeights ( multiNoiseWeights, mTS, transientWindow ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALApplyTransientWindow2NoiseWeights() failed! xlalErrno = %d\n", fn, xlalErrno );
ABORT ( status, PREDICTFSTAT_EXLAL, PREDICTFSTAT_MSGEXLAL );
}
XLALDestroyMultiTimestamps ( mTS );
} /* apply transient window to noise-weights */
/* ----- obtain the (multi-IFO) 'detector-state series' for all SFTs ----- */
TRY (LALGetMultiDetectorStates( status->statusPtr, &multiDetStates, multiSFTs, edat), status );
/* normalize skyposition: correctly map into [0,2pi]x[-pi/2,pi/2] */
skypos.longitude = uvar->Alpha;
skypos.latitude = uvar->Delta;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
TRY (LALNormalizeSkyPosition ( status->statusPtr, &skypos, &skypos), status);
TRY ( LALGetMultiAMCoeffs ( status->statusPtr, &multiAMcoef, multiDetStates, skypos ), status);
/* noise-weighting of Antenna-patterns and compute A,B,C */
if ( XLALWeightMultiAMCoeffs ( multiAMcoef, multiNoiseWeights ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "XLALWeightMultiAMCoeffs() failed with error = %d\n\n", xlalErrno );
ABORT ( status, PREDICTFSTAT_EXLAL, PREDICTFSTAT_MSGEXLAL );
}
/* OK: we only need the antenna-pattern matrix M_mu_nu */
cfg->Mmunu = multiAMcoef->Mmunu;
/* ----- produce a log-string describing the data-specific setup ----- */
{
struct tm utc;
time_t tp;
CHAR dateStr[512], line[512], summary[1024];
UINT4 j, numDet;
numDet = multiSFTs->length;
tp = time(NULL);
sprintf (summary, "%%%% Date: %s", asctime( gmtime( &tp ) ) );
strcat (summary, "%% Loaded SFTs: [ " );
for ( j=0; j < numDet; j ++ ) {
sprintf (line, "%s:%d%s", multiSFTs->data[j]->data->name, multiSFTs->data[j]->length,
(j < numDet - 1)?", ":" ]\n");
strcat ( summary, line );
}
utc = *XLALGPSToUTC( &utc, (INT4)GPS2REAL8(startTime) );
strcpy ( dateStr, asctime(&utc) );
dateStr[ strlen(dateStr) - 1 ] = 0;
sprintf (line, "%%%% Start GPS time tStart = %12.3f (%s GMT)\n", GPS2REAL8(startTime), dateStr);
strcat ( summary, line );
sprintf (line, "%%%% Total time spanned = %12.3f s (%.1f hours)\n", duration, duration/3600 );
strcat ( summary, line );
if ( (cfg->dataSummary = LALCalloc(1, strlen(summary) + 1 )) == NULL ) {
ABORT (status, PREDICTFSTAT_EMEM, PREDICTFSTAT_MSGEMEM);
}
strcpy ( cfg->dataSummary, summary );
LogPrintfVerbatim( LOG_DEBUG, cfg->dataSummary );
} /* write dataSummary string */
/* free everything not needed any more */
TRY ( LALDestroyMultiPSDVector (status->statusPtr, &multiRngmed ), status );
TRY ( LALDestroyMultiNoiseWeights (status->statusPtr, &multiNoiseWeights ), status );
TRY ( LALDestroyMultiSFTVector (status->statusPtr, &multiSFTs ), status );
XLALDestroyMultiDetectorStateSeries ( multiDetStates );
XLALDestroyMultiAMCoeffs ( multiAMcoef );
/* Free ephemeris data */
XLALDestroyEphemerisData (edat);
DETATCHSTATUSPTR (status);
RETURN (status);
} /* InitPFS() */
