/**
* This routine frees up all the memory.
*/
int
XLALFreeMem ( ConfigVars_t *cfg )
{
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL );
/* Free config-Variables and userInput stuff */
XLALDestroyUserVars();
/* free timestamps if any */
XLALDestroyMultiTimestamps ( cfg->multiTimestamps );
XLALFree ( cfg->VCSInfoString );
// free noise-SFT catalog
XLALDestroySFTCatalog ( cfg->noiseCatalog );
XLALDestroyMultiSFTCatalogView ( cfg->multiNoiseCatalogView );
// free noise time-series data
XLALDestroyMultiREAL8TimeSeries ( cfg->inputMultiTS );
/* Clean up earth/sun Ephemeris tables */
XLALDestroyEphemerisData ( cfg->edat );
return XLAL_SUCCESS;
} /* XLALFreeMem() */
/* ----- function definitions ---------- */
int
main ( void )
{
LALStatus XLAL_INIT_DECL(status);
SFTCatalog *catalog = NULL;
SFTConstraints XLAL_INIT_DECL(constraints);
MultiSFTVector *multiSFTs = NULL;
MultiPSDVector *multiPSDs = NULL;
MultiNoiseWeights *multiWeightsXLAL = NULL;
MultiNoiseWeights *multiWeightsCorrect = NULL;
UINT4 rngmedBins = 11;
REAL8 tolerance = 2e-6; /* same algorithm, should be basically identical results */
/* Construct the "correct" weights, calculated using the old LAL routines */
UINT4 numIFOsCorrect = 2;
XLAL_CHECK ( ( multiWeightsCorrect = XLALCalloc ( 1, sizeof(*multiWeightsCorrect ) ) ) != NULL, XLAL_ENOMEM );
multiWeightsCorrect->length = numIFOsCorrect;
multiWeightsCorrect->Sinv_Tsft = 1.980867126449e+52;
XLAL_CHECK ( ( multiWeightsCorrect->data = XLALCalloc ( numIFOsCorrect, sizeof(*multiWeightsCorrect->data ) ) ) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( ( multiWeightsCorrect->data[0] = XLALCreateREAL8Vector(4) ) != NULL, XLAL_ENOMEM );
multiWeightsCorrect->data[0]->data[0] = 6.425160659487e-05;
multiWeightsCorrect->data[0]->data[1] = 7.259453662367e-06;
multiWeightsCorrect->data[0]->data[2] = 9.838893684664e-04;
multiWeightsCorrect->data[0]->data[3] = 5.043766789923e-05;
XLAL_CHECK ( ( multiWeightsCorrect->data[1] = XLALCreateREAL8Vector(3) ) != NULL, XLAL_ENOMEM );
multiWeightsCorrect->data[1]->data[0] = 1.582309910283e-04;
multiWeightsCorrect->data[1]->data[1] = 5.345673753744e-04;
multiWeightsCorrect->data[1]->data[2] = 6.998201363537e+00;
/* Construct the catalog */
XLAL_CHECK ( ( catalog = XLALSFTdataFind ( TEST_DATA_DIR "MultiNoiseWeightsTest*.sft", &constraints ) ) != NULL, XLAL_EFUNC, " XLALSFTdataFind failed\n" );
/* Load the SFTs */
XLAL_CHECK ( ( multiSFTs = XLALLoadMultiSFTs ( catalog, -1, -1 ) ) != NULL, XLAL_EFUNC, " XLALLoadMultiSFTs failed\n" );
/* calculate the psd and normalize the SFTs */
XLAL_CHECK ( ( multiPSDs = XLALNormalizeMultiSFTVect ( multiSFTs, rngmedBins, NULL ) ) != NULL, XLAL_EFUNC, " XLALNormalizeMultiSFTVect failed\n" );
/* Get weights using XLAL function */
XLAL_CHECK ( ( multiWeightsXLAL = XLALComputeMultiNoiseWeights ( multiPSDs, rngmedBins, 0 ) ) != NULL, XLAL_EFUNC, " XLALComputeMultiNoiseWeights failed\n" );
/* Compare XLAL weights to reference */
XLAL_CHECK ( XLALCompareMultiNoiseWeights ( multiWeightsXLAL, multiWeightsCorrect, tolerance ) == XLAL_SUCCESS, XLAL_EFAILED, "Comparison between XLAL and reference MultiNoiseWeights failed\n" );
/* Clean up memory */
XLALDestroyMultiNoiseWeights ( multiWeightsCorrect );
XLALDestroyMultiNoiseWeights ( multiWeightsXLAL );
XLALDestroyMultiPSDVector ( multiPSDs );
XLALDestroyMultiSFTVector ( multiSFTs );
XLALDestroySFTCatalog ( catalog );
/* check for memory-leaks */
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} /* main() */
int main(int argc, char *argv[]){
static LALStatus status;
static LALDetector *detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
static REAL8 foft;
static HoughPulsarTemplate pulsarTemplate;
EphemerisData *edat = NULL;
CHAR *uvar_earthEphemeris = NULL;
CHAR *uvar_sunEphemeris = NULL;
SFTVector *inputSFTs = NULL;
REAL8 *alphaVec=NULL;
REAL8 *deltaVec=NULL;
REAL8 *freqVec=NULL;
REAL8 *spndnVec=NULL;
/* pgV is vector of peakgrams and pg1 is onepeakgram */
static UCHARPeakGram *pg1, **pgV;
UINT4 msp; /*number of spin-down parameters */
CHAR *uvar_ifo = NULL;
CHAR *uvar_sftDir = NULL; /* the directory where the SFT could be */
CHAR *uvar_fnameOut = NULL; /* The output prefix filename */
CHAR *uvar_fnameIn = NULL;
INT4 numberCount, ind;
UINT8 nTemplates;
UINT4 mObsCoh;
REAL8 uvar_peakThreshold;
REAL8 f_min, f_max, fWings, timeBase;
INT4 uvar_blocksRngMed;
UINT4 sftlength;
INT4 sftFminBin;
UINT4 loopId, tempLoopId;
FILE *fpOut = NULL;
CHAR *fnameLog=NULL;
FILE *fpLog = NULL;
CHAR *logstr=NULL;
/*REAL8 asq, bsq;*/ /* square of amplitude modulation functions a and b */
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
msp = 1; /*only one spin-down */
/* memory allocation for spindown */
pulsarTemplate.spindown.length = msp;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(msp*sizeof(REAL8));
uvar_peakThreshold = THRESHOLD;
uvar_earthEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
uvar_fnameOut = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameOut,VALIDATEOUT);
uvar_fnameIn = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameIn,VALIDATEIN);
uvar_blocksRngMed = BLOCKSRNGMED;
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", STRING, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameIn, "fnameIn", STRING, 'T', OPTIONAL, "Input template file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameOut, "fnameOut", STRING, 'o', OPTIONAL, "Output filename") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC);
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
exit(1);
/* open log file for writing */
fnameLog = LALCalloc( (strlen(uvar_fnameOut) + strlen(".log") + 10),1);
strcpy(fnameLog,uvar_fnameOut);
strcat(fnameLog,".log");
if ((fpLog = fopen(fnameLog, "w")) == NULL) {
fprintf(stderr, "Unable to open file %s for writing\n", fnameLog);
LALFree(fnameLog);
exit(1);
}
/* get the log string */
XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC);
fprintf( fpLog, "## Log file for HoughValidate\n\n");
fprintf( fpLog, "# User Input:\n");
fprintf( fpLog, "#-------------------------------------------\n");
fprintf( fpLog, "%s", logstr);
LALFree(logstr);
/* append an ident-string defining the exact CVS-version of the code used */
{
CHAR command[1024] = "";
fprintf (fpLog, "\n\n# CVS-versions of executable:\n");
fprintf (fpLog, "# -----------------------------------------\n");
fclose (fpLog);
sprintf (command, "ident %s | sort -u >> %s", argv[0], fnameLog);
/* we don't check this. If it fails, we assume that */
/* one of the system-commands was not available, and */
/* therefore the CVS-versions will not be logged */
if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command );
LALFree(fnameLog);
}
/* open output file for writing */
fpOut= fopen(uvar_fnameOut, "w");
/*setlinebuf(fpOut);*/ /* line buffered on */
setvbuf(fpOut, (char *)NULL, _IOLBF, 0);
/*****************************************************************/
/* read template file */
/*****************************************************************/
{
FILE *fpIn = NULL;
INT4 r;
REAL8 temp1, temp2, temp3, temp4, temp5;
UINT8 templateCounter;
fpIn = fopen(uvar_fnameIn, "r");
if ( !fpIn )
{
fprintf(stderr, "Unable to fine file %s\n", uvar_fnameIn);
return DRIVEHOUGHCOLOR_EFILE;
}
nTemplates = 0;
do
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5);
/* make sure the line has the right number of entries or is EOF */
if (r==5) nTemplates++;
} while ( r != EOF);
rewind(fpIn);
alphaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
deltaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
freqVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
spndnVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
for (templateCounter = 0; templateCounter < nTemplates; templateCounter++)
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, alphaVec + templateCounter, deltaVec + templateCounter,
freqVec + templateCounter, spndnVec + templateCounter);
}
fclose(fpIn);
}
/**************************************************/
/* read sfts */
/*************************************************/
f_min = freqVec[0]; /* initial frequency to be analyzed */
/* assume that the last frequency in the templates file is also the highest frequency */
f_max = freqVec[nTemplates-1] ;
/* we need to add wings to fmin and fmax to account for
the Doppler shift, the size of the rngmed block size
and also nfsizecylinder. The block size and nfsizecylinder are
specified in terms of frequency bins...this goes as one of the arguments of
LALReadSFTfiles */
/* first correct for Doppler shift */
fWings = f_max * VTOT;
f_min -= fWings;
f_max += fWings;
/* create pattern to look for in SFT directory */
{
CHAR *tempDir = NULL;
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
/* set detector constraint */
constraints.detector = NULL;
if ( XLALUserVarWasSet( &uvar_ifo ) )
constraints.detector = XLALGetChannelPrefix ( uvar_ifo );
/* get sft catalog */
tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
XLAL_CHECK_MAIN( ( catalog = XLALSFTdataFind( tempDir, &constraints) ) != NULL, XLAL_EFUNC);
detector = XLALGetSiteInfo( catalog->data[0].header.name);
mObsCoh = catalog->length;
timeBase = 1.0 / catalog->data->header.deltaF;
XLAL_CHECK_MAIN( ( inputSFTs = XLALLoadSFTs ( catalog, f_min, f_max) ) != NULL, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALNormalizeSFTVect( inputSFTs, uvar_blocksRngMed, 0.0 ) == XLAL_SUCCESS, XLAL_EFUNC);
if ( XLALUserVarWasSet( &uvar_ifo ) )
LALFree( constraints.detector );
LALFree( tempDir);
XLALDestroySFTCatalog(catalog );
}
sftlength = inputSFTs->data->data->length;
{
INT4 tempFbin;
sftFminBin = floor( (REAL4)(timeBase * inputSFTs->data->f0) + (REAL4)(0.5));
tempFbin = floor( timeBase * inputSFTs->data->f0 + 0.5);
if (tempFbin - sftFminBin)
{
fprintf(stderr, "Rounding error in calculating fminbin....be careful! \n");
}
}
/* loop over sfts and select peaks */
/* first the memory allocation for the peakgramvector */
pgV = NULL;
pgV = (UCHARPeakGram **)LALMalloc(mObsCoh*sizeof(UCHARPeakGram *));
/* memory for peakgrams */
for (tempLoopId=0; tempLoopId < mObsCoh; tempLoopId++)
{
pgV[tempLoopId] = (UCHARPeakGram *)LALMalloc(sizeof(UCHARPeakGram));
pgV[tempLoopId]->length = sftlength;
pgV[tempLoopId]->data = NULL;
pgV[tempLoopId]->data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR));
LAL_CALL (SFTtoUCHARPeakGram( &status, pgV[tempLoopId], inputSFTs->data + tempLoopId, uvar_peakThreshold), &status);
}
/* having calculated the peakgrams we don't need the sfts anymore */
XLALDestroySFTVector( inputSFTs);
/* ****************************************************************/
/* setting timestamps vector */
/* ****************************************************************/
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
{
UINT4 j;
for (j=0; j < mObsCoh; j++){
timeV.data[j].gpsSeconds = pgV[j]->epoch.gpsSeconds;
timeV.data[j].gpsNanoSeconds = pgV[j]->epoch.gpsNanoSeconds;
}
}
/******************************************************************/
/* compute the time difference relative to startTime for all SFTs */
/******************************************************************/
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
{
REAL8 t0, ts, tn, midTimeBase;
UINT4 j;
midTimeBase=0.5*timeBase;
ts = timeV.data[0].gpsSeconds;
tn = timeV.data[0].gpsNanoSeconds * 1.00E-9;
t0=ts+tn;
timeDiffV.data[0] = midTimeBase;
for (j=1; j< mObsCoh; ++j){
ts = timeV.data[j].gpsSeconds;
tn = timeV.data[j].gpsNanoSeconds * 1.00E-9;
timeDiffV.data[j] = ts + tn -t0 + midTimeBase;
}
}
/******************************************************************/
/* compute detector velocity for those time stamps */
/******************************************************************/
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
{
VelocityPar velPar;
REAL8 vel[3];
UINT4 j;
velPar.detector = *detector;
velPar.tBase = timeBase;
velPar.vTol = ACCURACY;
velPar.edat = NULL;
/* read in ephemeris data */
XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC);
velPar.edat = edat;
/* now calculate average velocity */
for(j=0; j< velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
LAL_CALL( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
}
/* amplitude modulation stuff */
{
AMCoeffs XLAL_INIT_DECL(amc);
AMCoeffsParams *amParams;
EarthState earth;
BarycenterInput baryinput; /* Stores detector location and other barycentering data */
/* detector location */
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.dInv = 0.e0;
/* alpha and delta must come from the skypatch */
/* for now set it to something arbitrary */
baryinput.alpha = 0.0;
baryinput.delta = 0.0;
/* 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;
/* make sure alpha and delta are correct */
amParams->das->pSource->equatorialCoords.latitude = baryinput.delta;
amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha;
amParams->das->pSource->orientation = 0.0;
amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/
/* timeV is start time ---> change to mid time */
LAL_CALL (LALComputeAM(&status, &amc, timeV.data, amParams), &status);
/* calculate a^2 and b^2 */
/* for (ii=0, asq=0.0, bsq=0.0; ii<mObsCoh; ii++) */
/* { */
/* REAL8 *a, *b; */
/* a = amc.a + ii; */
/* b = amc.b + ii; */
/* asq += (*a) * (*a); */
/* bsq += (*b) * (*b); */
/* } */
/* free amParams */
LALFree(amParams->das->pSource);
LALFree(amParams->das);
LALFree(amParams);
}
/* loop over templates */
for(loopId=0; loopId < nTemplates; ++loopId){
/* set template parameters */
pulsarTemplate.f0 = freqVec[loopId];
pulsarTemplate.longitude = alphaVec[loopId];
pulsarTemplate.latitude = deltaVec[loopId];
pulsarTemplate.spindown.data[0] = spndnVec[loopId];
{
REAL8 f0new, vcProdn, timeDiffN;
REAL8 sourceDelta, sourceAlpha, cosDelta, factorialN;
UINT4 j, i, f0newBin;
REAL8Cart3Coor sourceLocation;
sourceDelta = pulsarTemplate.latitude;
sourceAlpha = pulsarTemplate.longitude;
cosDelta = cos(sourceDelta);
sourceLocation.x = cosDelta* cos(sourceAlpha);
sourceLocation.y = cosDelta* sin(sourceAlpha);
sourceLocation.z = sin(sourceDelta);
/* loop for all different time stamps,calculate frequency and produce number count*/
/* first initialize number count */
numberCount=0;
for (j=0; j<mObsCoh; ++j)
{
/* calculate v/c.n */
vcProdn = velV.data[j].x * sourceLocation.x
+ velV.data[j].y * sourceLocation.y
+ velV.data[j].z * sourceLocation.z;
/* loop over spindown values to find f_0 */
f0new = pulsarTemplate.f0;
factorialN = 1.0;
timeDiffN = timeDiffV.data[j];
for (i=0; i<msp;++i)
{
factorialN *=(i+1.0);
f0new += pulsarTemplate.spindown.data[i]*timeDiffN / factorialN;
timeDiffN *= timeDiffN;
}
f0newBin = floor(f0new*timeBase + 0.5);
foft = f0newBin * (1.0 +vcProdn) / timeBase;
/* get the right peakgram */
pg1 = pgV[j];
/* calculate frequency bin for template */
ind = floor( foft * timeBase + 0.5 ) - sftFminBin;
/* update the number count */
numberCount+=pg1->data[ind];
}
} /* end of block calculating frequency path and number count */
/******************************************************************/
/* printing result in the output file */
/******************************************************************/
fprintf(fpOut,"%d %f %f %f %g \n",
numberCount, pulsarTemplate.longitude, pulsarTemplate.latitude, pulsarTemplate.f0,
pulsarTemplate.spindown.data[0] );
} /* end of loop over templates */
/******************************************************************/
/* Closing files */
/******************************************************************/
fclose(fpOut);
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(alphaVec);
LALFree(deltaVec);
LALFree(freqVec);
LALFree(spndnVec);
for (tempLoopId = 0; tempLoopId < mObsCoh; tempLoopId++){
pg1 = pgV[tempLoopId];
LALFree(pg1->data);
LALFree(pg1);
}
LALFree(pgV);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(velV.data);
LALFree(pulsarTemplate.spindown.data);
XLALDestroyEphemerisData(edat);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return DRIVEHOUGHCOLOR_ENORM;
}
/* deallocate memory associated with config variables */
int XLALDestroyConfigVars (ConfigVariables *config)
{
XLALDestroySFTCatalog(config->catalog);
XLALDestroyEphemerisData(config->edat);
return XLAL_SUCCESS;
}
REAL4Vector * readInSFTs(inputParamsStruct *input, REAL8 *normalization)
{
INT4 ii, jj;
SFTCatalog *catalog = NULL;
//Set the start and end times in the LIGO GPS format
LIGOTimeGPS start = LIGOTIMEGPSZERO, end = LIGOTIMEGPSZERO;
XLALGPSSetREAL8(&start, input->searchstarttime);
if (xlalErrno != 0) {
fprintf(stderr, "%s: XLALGPSSetREAL8() failed on start time = %.9f.\n", __func__, input->searchstarttime);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
XLALGPSSetREAL8(&end, input->searchstarttime+input->Tobs);
if (xlalErrno != 0) {
fprintf(stderr, "%s: XLALGPSSetREAL8() failed on end time = %.9f.\n", __func__, input->searchstarttime+input->Tobs);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Setup the constraints
SFTConstraints constraints;
constraints.detector = NULL;
constraints.minStartTime = constraints.maxStartTime = NULL;
constraints.timestamps = NULL;
constraints.detector = input->det[0].frDetector.prefix;
constraints.minStartTime = &start;
constraints.maxStartTime = &end;
//Find SFT files
catalog = XLALSFTdataFind(sft_dir_file, &constraints);
if (catalog==NULL) {
fprintf(stderr,"%s: XLALSFTdataFind() failed.\n", __func__);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Determine band size (remember to get extra bins because of the running median and the bin shifts due to detector velocity)
REAL8 minfbin = round(input->fmin*input->Tcoh - input->dfmax*input->Tcoh - 0.5*(input->blksize-1) - (REAL8)(input->maxbinshift) - 6.0)/input->Tcoh;
REAL8 maxfbin = round((input->fmin + input->fspan)*input->Tcoh + input->dfmax*input->Tcoh + 0.5*(input->blksize-1) + (REAL8)(input->maxbinshift) + 6.0)/input->Tcoh;
//Now extract the data
SFTVector *sfts = XLALLoadSFTs(catalog, minfbin+0.1/input->Tcoh, maxfbin-0.1/input->Tcoh);
if (sfts == NULL) {
fprintf(stderr,"%s: XLALLoadSFTs() failed to load SFTs with given input parameters.\n", __func__);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Now put the power data into the TF plane, looping through each SFT
//If an SFT doesn't exit, fill the TF pixels of the SFT with zeros
INT4 numffts = (INT4)floor(input->Tobs/(input->Tcoh-input->SFToverlap)-1);
INT4 sftlength;
if (sfts->length == 0) sftlength = (INT4)round(maxfbin*input->Tcoh - minfbin*input->Tcoh + 1);
else {
sftlength = sfts->data->data->length;
//Check the length is what we expect
if (sftlength!=(INT4)round(maxfbin*input->Tcoh - minfbin*input->Tcoh + 1)) {
fprintf(stderr, "%s: sftlength (%d) is not matching expected length (%d).\n", __func__, sftlength, (INT4)round(maxfbin*input->Tcoh - minfbin*input->Tcoh + 1));
XLAL_ERROR_NULL(XLAL_EFPINEXCT);
}
}
INT4 nonexistantsft = 0;
REAL4Vector *tfdata = XLALCreateREAL4Vector(numffts*sftlength);
if (tfdata==NULL) {
fprintf(stderr,"%s: XLALCreateREAL4Vector(%d) failed.\n", __func__, numffts*sftlength);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Load the data into the output vector, roughly normalizing as we go along from the input value
REAL8 sqrtnorm = sqrt(*(normalization));
for (ii=0; ii<numffts; ii++) {
SFTDescriptor *sftdescription = &(catalog->data[ii - nonexistantsft]);
if (sftdescription->header.epoch.gpsSeconds == (INT4)round(ii*(input->Tcoh-input->SFToverlap)+input->searchstarttime)) {
SFTtype *sft = &(sfts->data[ii - nonexistantsft]);
for (jj=0; jj<sftlength; jj++) {
COMPLEX8 sftcoeff = sft->data->data[jj];
tfdata->data[ii*sftlength + jj] = (REAL4)((sqrtnorm*crealf(sftcoeff))*(sqrtnorm*crealf(sftcoeff)) + (sqrtnorm*cimagf(sftcoeff))*(sqrtnorm*cimagf(sftcoeff))); //power, normalized
}
} else {
for (jj=0; jj<sftlength; jj++) tfdata->data[ii*sftlength + jj] = 0.0; //Set values to be zero
nonexistantsft++; //increment the nonexistantsft counter
}
} /* for ii < numffts */
//Vladimir's code uses a different SFT normalization factor than MFD
if (strcmp(input->sftType, "vladimir") == 0) {
REAL4 vladimirfactor = (REAL4)(0.25*(8.0/3.0));
for (ii=0; ii<(INT4)tfdata->length; ii++) tfdata->data[ii] *= vladimirfactor;
}
//Destroy stuff
XLALDestroySFTCatalog(catalog);
XLALDestroySFTVector(sfts);
fprintf(stderr, "Duty factor = %f\n", 1.0-(REAL4)nonexistantsft/(REAL4)numffts);
return tfdata;
} /* readInSFTs() */
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
// ---------- handle user input ----------
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->FstatMethod = XLALStringDuplicate("ResampBest");
uvar->Freq = 100;
uvar->f1dot = -3e-9;
uvar->FreqResolution = XLALCreateREAL8Vector ( 2 );
uvar->FreqResolution->data[0] = 1;
uvar->FreqResolution->data[1] = 10;
uvar->numFreqBins = XLALCreateINT4Vector ( 2 );
uvar->numFreqBins->data[0] = 1000;
uvar->numFreqBins->data[1] = 100000;
uvar->Tseg = 60 * 3600;
uvar->numSegments = 90;
uvar->numTrials = 1;
uvar->Tsft = 1800;
uvar->runBuffered = 0;
XLAL_CHECK ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) != NULL, XLAL_EFUNC );
uvar->outputInfo = NULL;
XLAL_CHECK ( XLALRegisterUvarMember ( help, BOOLEAN, 'h', HELP, "Print help message" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FstatMethod, STRING, 0, OPTIONAL, XLALFstatMethodHelpString() ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Freq, REAL8, 0, OPTIONAL, "Search frequency in Hz" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( f1dot, REAL8, 0, OPTIONAL, "Search spindown f1dot in Hz/s" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FreqResolution, REAL8Vector, 0, OPTIONAL, "Range of frequency resolution factor 'r' (st dFreq = 1/(r*T)) [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tseg, REAL8, 0, OPTIONAL, "Coherent segment length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numSegments, INT4, 0, OPTIONAL, "Number of semi-coherent segment" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numFreqBins, INT4Vector, 0, OPTIONAL, "Range of number of frequency bins to search [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( IFOs, STRINGVector, 0, OPTIONAL, "IFOs to use" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numTrials, INT4, 0, OPTIONAL, "Number of repeated trials to run (with potentially randomized parameters)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( outputInfo, STRING, 0, OPTIONAL, "Append Resampling internal info into this file") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tsft, REAL8, 0, DEVELOPER, "SFT length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( runBuffered, BOOLEAN, 0, DEVELOPER, "Explicitly time buffered Fstat call (only useful for double-checking and Demod timing)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar->help) { // if help was requested, we're done here
return XLAL_SUCCESS;
}
// check user input
XLAL_CHECK ( uvar->numSegments >= 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->FreqResolution->length == 1) || (uvar->FreqResolution->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[0] > 0, XLAL_EINVAL );
REAL8 FreqResolutionMin, FreqResolutionMax;
FreqResolutionMin = FreqResolutionMax = uvar->FreqResolution->data[0];
if ( uvar->FreqResolution->length == 2 )
{
XLAL_CHECK ( uvar->FreqResolution->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[1] > uvar->FreqResolution->data[0], XLAL_EINVAL );
FreqResolutionMax = uvar->FreqResolution->data[1];
}
XLAL_CHECK ( uvar->Freq > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tseg > uvar->Tsft, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tsft > 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->numFreqBins->length == 1) || (uvar->numFreqBins->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[0] > 0, XLAL_EINVAL );
UINT4 numFreqBinsMax, numFreqBinsMin;
numFreqBinsMin = numFreqBinsMax = uvar->numFreqBins->data[0];
if ( uvar->numFreqBins->length == 2 )
{
XLAL_CHECK ( uvar->numFreqBins->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[1] > uvar->numFreqBins->data[0], XLAL_EINVAL );
numFreqBinsMax = uvar->numFreqBins->data[1];
}
XLAL_CHECK ( uvar->numTrials >= 1, XLAL_EINVAL );
// ---------- end: handle user input ----------
// common setup over repeated trials
FstatMethodType FstatMethod;
XLAL_CHECK ( XLALParseFstatMethodString ( &FstatMethod, uvar->FstatMethod ) == XLAL_SUCCESS, XLAL_EFUNC );
EphemerisData *ephem;
XLAL_CHECK ( (ephem = XLALInitBarycenter ( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" )) != NULL, XLAL_EFUNC );
REAL8 memBase = XLALGetPeakHeapUsageMB();
UINT4 numDetectors = uvar->IFOs->length;
// ----- setup injection and data parameters
LIGOTimeGPS startTime = {711595934, 0};
LIGOTimeGPS startTime_l = startTime;
LIGOTimeGPS endTime_l;
SFTCatalog **catalogs;
XLAL_CHECK ( (catalogs = XLALCalloc ( uvar->numSegments, sizeof( catalogs[0] ))) != NULL, XLAL_ENOMEM );
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
endTime_l = startTime_l;
XLALGPSAdd( &endTime_l, uvar->Tseg );
MultiLIGOTimeGPSVector *multiTimestamps;
XLAL_CHECK ( (multiTimestamps = XLALMakeMultiTimestamps ( startTime_l, uvar->Tseg, uvar->Tsft, 0, numDetectors )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (catalogs[l] = XLALMultiAddToFakeSFTCatalog ( NULL, uvar->IFOs, multiTimestamps )) != NULL, XLAL_EFUNC );
XLALDestroyMultiTimestamps ( multiTimestamps );
startTime_l = endTime_l;
} // for l < numSegments
LIGOTimeGPS endTime = endTime_l;
UINT4 numSFTsPerSeg = catalogs[0]->length;
FILE *fpInfo = NULL;
if ( (uvar->outputInfo != NULL) && (FstatMethod == FMETHOD_RESAMP_GENERIC) )
{
XLAL_CHECK ( (fpInfo = fopen (uvar->outputInfo, "ab")) != NULL, XLAL_ESYS, "Failed to open '%s' for appending\n", uvar->outputInfo );
XLALAppendResampInfo2File ( fpInfo, NULL ); // create header comment line
}
PulsarSpinRange XLAL_INIT_DECL(spinRange);
LIGOTimeGPS refTime = { startTime.gpsSeconds - 2.3 * uvar->Tseg, 0 };
spinRange.refTime = refTime;
spinRange.fkdot[0] = uvar->Freq;
spinRange.fkdot[1] = uvar->f1dot;
spinRange.fkdotBand[1] = 0;
REAL8 asini = 0, Period = 0, ecc = 0;
REAL8 minCoverFreq, maxCoverFreq;
PulsarDopplerParams XLAL_INIT_DECL(Doppler);
Doppler.refTime = refTime;
Doppler.Alpha = 0.5;
Doppler.Delta = 0.5;
memcpy ( &Doppler.fkdot, &spinRange.fkdot, sizeof(Doppler.fkdot) );;
Doppler.period = Period;
Doppler.ecc = ecc;
Doppler.asini = asini;
// ----- setup optional Fstat arguments
FstatOptionalArgs optionalArgs = FstatOptionalArgsDefaults;
MultiNoiseFloor XLAL_INIT_DECL(injectSqrtSX);
injectSqrtSX.length = numDetectors;
for ( UINT4 X=0; X < numDetectors; X ++ ) {
injectSqrtSX.sqrtSn[X] = 1;
}
optionalArgs.injectSqrtSX = &injectSqrtSX;
optionalArgs.FstatMethod = FstatMethod;
FstatWorkspace *sharedWorkspace = NULL;
FstatInputVector *inputs;
FstatQuantities whatToCompute = (FSTATQ_2F | FSTATQ_2F_PER_DET);
FstatResults *results = NULL;
REAL8 tauF1NoBuf = 0;
REAL8 tauF1Buf = 0;
// ---------- main loop over repeated trials ----------
for ( INT4 i = 0; i < uvar->numTrials; i ++ )
{
// randomize numFreqBins
UINT4 numFreqBins_i = numFreqBinsMin + (UINT4)round ( 1.0 * (numFreqBinsMax - numFreqBinsMin) * rand() / RAND_MAX );
// randomize FreqResolution
REAL8 FreqResolution_i = FreqResolutionMin + 1.0 * ( FreqResolutionMax - FreqResolutionMin ) * rand() / RAND_MAX;
XLAL_CHECK ( (inputs = XLALCreateFstatInputVector ( uvar->numSegments )) != NULL, XLAL_EFUNC );
REAL8 dFreq = 1.0 / ( FreqResolution_i * uvar->Tseg );
REAL8 FreqBand = numFreqBins_i * dFreq;
fprintf ( stderr, "trial %d/%d: Tseg = %.1f d, numSegments = %d, Freq = %.1f Hz, f1dot = %.1e Hz/s, FreqResolution r = %f, numFreqBins = %d [dFreq = %.2e Hz, FreqBand = %.2e Hz]\n",
i+1, uvar->numTrials, uvar->Tseg / 86400.0, uvar->numSegments, uvar->Freq, uvar->f1dot, FreqResolution_i, numFreqBins_i, dFreq, FreqBand );
spinRange.fkdotBand[0] = FreqBand;
XLAL_CHECK ( XLALCWSignalCoveringBand ( &minCoverFreq, &maxCoverFreq, &startTime, &endTime, &spinRange, asini, Period, ecc ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numBinsSFT = ceil ( (maxCoverFreq - minCoverFreq) * uvar->Tsft + 2 * 8 );
REAL8 memSFTs = uvar->numSegments * numSFTsPerSeg * ( sizeof(SFTtype) + numBinsSFT * sizeof(COMPLEX8)) / 1e6;
// create per-segment input structs
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( (inputs->data[l] = XLALCreateFstatInput ( catalogs[l], minCoverFreq, maxCoverFreq, dFreq, ephem, &optionalArgs )) != NULL, XLAL_EFUNC );
if ( l == 0 ) {
sharedWorkspace = XLALGetSharedFstatWorkspace ( inputs->data[0] );
}
optionalArgs.sharedWorkspace = sharedWorkspace;
}
// ----- compute Fstatistics over segments
REAL8 tauF1NoBuf_i = 0;
REAL8 tauF1Buf_i = 0;
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( XLALComputeFstat ( &results, inputs->data[l], &Doppler, numFreqBins_i, whatToCompute ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- output timing details if requested
if ( (fpInfo != NULL) ) {
XLALAppendResampInfo2File ( fpInfo, inputs->data[l] );
}
REAL8 tauF1NoBuf_il, tauF1Buf_il;
XLAL_CHECK ( XLALGetResampTimingInfo ( &tauF1NoBuf_il, &tauF1Buf_il, inputs->data[l] ) == XLAL_SUCCESS, XLAL_EFUNC );
tauF1NoBuf_i += tauF1NoBuf_il;
tauF1Buf_i += tauF1Buf_il;
} // for l < numSegments
tauF1NoBuf_i /= uvar->numSegments;
tauF1Buf_i /= uvar->numSegments;
REAL8 memMaxCompute = XLALGetPeakHeapUsageMB() - memBase;
tauF1Buf += tauF1Buf_i;
tauF1NoBuf += tauF1NoBuf_i;
fprintf (stderr, "%-15s: tauF1Buf = %.2g s, tauF1NoBuf = %.2g s, memSFTs = %.1f MB, memMaxCompute = %.1f MB\n",
XLALGetFstatMethodName ( FstatMethod ), tauF1Buf_i, tauF1NoBuf_i, memSFTs, memMaxCompute );
XLALDestroyFstatInputVector ( inputs );
XLALDestroyFstatWorkspace ( sharedWorkspace );
optionalArgs.sharedWorkspace = NULL;
} // for i < numTrials
tauF1Buf /= uvar->numTrials;
tauF1NoBuf /= uvar->numTrials;
fprintf (stderr, "\nAveraged timings: <tauF1Buf> = %.2g s, <tauF1NoBuf> = %.2g s\n", tauF1Buf, tauF1NoBuf );
// ----- free memory ----------
if ( fpInfo != NULL ) {
fclose ( fpInfo );
}
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLALDestroySFTCatalog ( catalogs[l] );
}
XLALFree ( catalogs );
XLALDestroyFstatResults ( results );
XLALDestroyUserVars();
XLALDestroyEphemerisData ( ephem );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/**
* Load all SFTs according to user-input, returns multi-SFT vector.
* \return cfg:
* Returns 'effective' range of SFT-bins [firstBin, lastBin], which which the PSD will be estimated:
* - if the user input {fStart, fBand} then these are loaded from SFTs and directly translated into bins
* - if user input {Freq, FreqBand}, we load a wider frequency-band ADDING running-median/2 on either side
* from the SFTs, and firstBind, lastBin correspond to {Freq,FreqBand} (rounded to closest bins)
* Also returns the 'data-segment' for which SFTs were loaded
*
*/
MultiSFTVector *
XLALReadSFTs ( ConfigVariables_t *cfg, /**< [out] return derived configuration info (firstBin, lastBin, segment) */
const UserVariables_t *uvar /**< [in] complete user-input */
)
{
SFTCatalog *catalog = NULL;
SFTConstraints XLAL_INIT_DECL(constraints);
LIGOTimeGPS startTimeGPS = {0,0}, endTimeGPS = {0,0};
LIGOTimeGPSVector *inputTimeStampsVector = NULL;
/* check input */
if ( !uvar || !uvar->inputData ) {
XLALPrintError ("%s: invalid NULL input 'uvar' or 'uvar->inputData'\n", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
if ( !cfg ) {
XLALPrintError ("%s: invalid NULL input 'cfg'", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
/* set detector constraint */
if ( XLALUserVarWasSet ( &uvar->IFO ) )
constraints.detector = uvar->IFO;
else
constraints.detector = NULL;
if ( XLALUserVarWasSet( &uvar->startTime ) ) {
XLALGPSSetREAL8 ( &startTimeGPS, uvar->startTime);
constraints.minStartTime = &startTimeGPS;
}
if ( XLALUserVarWasSet( &uvar->endTime ) ) {
XLALGPSSetREAL8 ( &endTimeGPS, uvar->endTime);
constraints.maxStartTime = &endTimeGPS;
}
if ( XLALUserVarWasSet( &uvar->timeStampsFile ) ) {
if ( (inputTimeStampsVector = XLALReadTimestampsFile ( uvar->timeStampsFile )) == NULL )
XLAL_ERROR_NULL ( XLAL_EFUNC );
constraints.timestamps = inputTimeStampsVector;
}
/* get sft catalog */
LogPrintf ( LOG_DEBUG, "Finding all SFTs to load ... ");
if ( ( catalog = XLALSFTdataFind ( uvar->inputData, &constraints) ) == NULL ) {
XLALPrintError ("%s: XLALSFTdataFind() failed with xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR_NULL ( XLAL_EFAILED );
}
if ( (catalog == NULL) || (catalog->length == 0) ) {
XLALPrintError ("%s: Unable to match any SFTs with pattern '%s'\n", __func__, uvar->inputData );
XLAL_ERROR_NULL ( XLAL_EFAILED );
}
LogPrintfVerbatim ( LOG_DEBUG, "done (found %i SFTs).\n", catalog->length);
/* now we can free the inputTimeStampsVector */
if ( inputTimeStampsVector )
XLALDestroyTimestampVector ( inputTimeStampsVector );
/* ----- some user-input consistency checks */
BOOLEAN have_fStart = XLALUserVarWasSet ( &uvar->fStart );
BOOLEAN have_Freq = XLALUserVarWasSet ( &uvar->Freq );
BOOLEAN have_fBand = XLALUserVarWasSet ( &uvar->fBand );
BOOLEAN have_FreqBand = XLALUserVarWasSet ( &uvar->FreqBand );
if ( have_fStart && have_Freq ) {
XLALPrintError ("%s: use only one of --fStart OR --Freq (see --help)\n", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
if ( have_fBand && have_FreqBand ) {
XLALPrintError ("%s: use only one of --fBand OR --FreqBand (see --help)\n", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
if ( ( have_fStart && have_FreqBand ) || ( have_Freq && have_fBand ) ) {
XLALPrintError ("%s: don't mix {--fStart,--fBand} with {--Freq,--FreqBand} inputs (see --help)\n", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
/* ---------- figure out the right frequency-band to read from the SFTs, depending on user-input ----- */
REAL8 fMin, fMax;
UINT4 binsOffset; /* rngmed bin offset from start and end */
UINT4 binsBand=0; /* width of physical FreqBand in bins */
if ( have_Freq )
{
REAL8 dFreq = catalog->data[0].header.deltaF;
binsOffset = uvar->blocksRngMed / 2 + 1; /* truncates down plus add one bin extra safety! */
binsBand = ceil ( (uvar->FreqBand - 1e-9) / dFreq ) + 1; /* round up ! */
REAL8 rngmedSideBand = binsOffset * dFreq;
fMin = uvar->Freq - rngmedSideBand;
fMax = uvar->Freq + uvar->FreqBand + rngmedSideBand;
}
else /* NOTE: if no user-input on freq-band, we fall back to defaults on {fStart, fBand} */
{
fMin = uvar->fStart;
fMax = uvar->fStart + uvar->fBand;
binsOffset = 0; /* no truncation of rngmed sidebands */
}
/* ----- figure out the data-segment span from the user-input and SFT-catalog ----- */
/* if used passed these, then 'startTimeGPS' and 'endTimeGPS' are already set */
if ( startTimeGPS.gpsSeconds == 0 )
startTimeGPS = catalog->data[0].header.epoch;
if ( endTimeGPS.gpsSeconds == 0 )
endTimeGPS = catalog->data[catalog->length-1].header.epoch;
/* SFT 'constraints' only refer to SFT *start-times*, for segment we need the end-time */
REAL8 Tsft = 1.0 / catalog->data[0].header.deltaF;
XLALGPSAdd ( &endTimeGPS, Tsft );
/* ---------- read the sfts ---------- */
LogPrintf (LOG_DEBUG, "Loading all SFTs ... ");
MultiSFTVector *multi_sfts;
if ( ( multi_sfts = XLALLoadMultiSFTs ( catalog, fMin, fMax ) ) == NULL ) {
XLALPrintError ("%s: XLALLoadMultiSFTs( %f, %f ) failed with xlalErrno = %d\n", __func__, fMin, fMax, xlalErrno );
XLAL_ERROR_NULL ( XLAL_EFUNC );
}
XLALDestroySFTCatalog ( catalog );
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
/* ---------- end loading SFTs ---------- */
/* figure out effective PSD bin-boundaries for user */
UINT4 numBins = multi_sfts->data[0]->data[0].data->length;
INT4 bin0, bin1;
if ( have_Freq )
{
bin0 = 0 + binsOffset;
bin1 = bin0 + binsBand - 1;
}
else /* output all bins loaded from SFTs (includes rngmed-sidebands) */
{
bin0 = 0;
bin1 = numBins - 1;
}
/* return results */
cfg->firstBin = (UINT4) bin0;
cfg->lastBin = (UINT4) bin1;
cfg->dataSegment.start = startTimeGPS;
cfg->dataSegment.end = endTimeGPS;
XLALPrintInfo ("%s: loaded SFTs have %d bins, effective PSD output band is [%d, %d]\n", __func__, numBins, bin0, bin1 );
return multi_sfts;
} /* XLALReadSFTs() */
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
SFTConstraints XLAL_INIT_DECL(constraints);
LIGOTimeGPS XLAL_INIT_DECL(minStartTimeGPS);
LIGOTimeGPS XLAL_INIT_DECL(maxStartTimeGPS);
SFTCatalog *FullCatalog = NULL;
CHAR *add_comment = NULL;
UINT4 i;
REAL8 fMin, fMax;
UserInput_t XLAL_INIT_DECL(uvar);
/* register all user-variables */
XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK_MAIN ( XLALUserVarReadAllInput (argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit (0);
}
/* ----- make sure output directory exists ---------- */
if ( uvar.outputDir )
{
int ret;
ret = mkdir ( uvar.outputDir, 0777);
if ( (ret == -1) && ( errno != EEXIST ) )
{
int errsv = errno;
LogPrintf (LOG_CRITICAL, "Failed to create directory '%s': %s\n", uvar.outputDir, strerror(errsv) );
return -1;
}
}
LIGOTimeGPSVector *timestamps = NULL;
if ( uvar.timestampsFile )
{
if ( (timestamps = XLALReadTimestampsFile ( uvar.timestampsFile )) == NULL ) {
XLALPrintError ("XLALReadTimestampsFile() failed to load timestamps from file '%s'\n", uvar.timestampsFile );
return -1;
}
}
/* use IFO-contraint if one given by the user */
if ( LALUserVarWasSet ( &uvar.IFO ) ) {
XLAL_CHECK_MAIN ( (constraints.detector = XLALGetChannelPrefix ( uvar.IFO )) != NULL, XLAL_EINVAL );
}
minStartTimeGPS.gpsSeconds = uvar.minStartTime;
maxStartTimeGPS.gpsSeconds = uvar.maxStartTime;
constraints.minStartTime = &minStartTimeGPS;
constraints.maxStartTime = &maxStartTimeGPS;
constraints.timestamps = timestamps;
/* get full SFT-catalog of all matching (multi-IFO) SFTs */
XLAL_CHECK_MAIN ( (FullCatalog = XLALSFTdataFind ( uvar.inputSFTs, &constraints )) != NULL, XLAL_EFUNC );
if ( constraints.detector ) {
XLALFree ( constraints.detector );
}
XLAL_CHECK_MAIN ( (FullCatalog != NULL) && (FullCatalog->length > 0), XLAL_EINVAL, "\nSorry, didn't find any matching SFTs with pattern '%s'!\n\n", uvar.inputSFTs );
/* build up full comment-string to be added to SFTs: 1) converted by ConvertToSFTv2, VCS ID 2) user extraComment */
{
UINT4 len = 128;
len += strlen ( uvar.inputSFTs );
if ( uvar.extraComment )
len += strlen ( uvar.extraComment );
XLAL_CHECK_MAIN ( ( add_comment = LALCalloc ( 1, len )) != NULL, XLAL_ENOMEM );
/** \deprecated FIXME: the following code uses obsolete CVS ID tags.
* It should be modified to use git version information. */
sprintf ( add_comment, "Converted by $Id$, inputSFTs = '%s';", uvar.inputSFTs );
if ( uvar.extraComment )
{
strcat ( add_comment, "\n");
strcat ( add_comment, uvar.extraComment );
}
} /* construct comment-string */
/* which frequency-band to extract? */
fMin = -1; /* default: all */
fMax = -1;
if ( LALUserVarWasSet ( &uvar.fmin ) )
fMin = uvar.fmin;
if ( LALUserVarWasSet ( &uvar.fmax ) )
fMax = uvar.fmax;
FILE *fpSingleSFT = NULL;
if ( uvar.outputSingleSFT )
XLAL_CHECK ( ( fpSingleSFT = fopen ( uvar.outputSingleSFT, "wb" )) != NULL,
XLAL_EIO, "Failed to open singleSFT file '%s' for writing\n", uvar.outputSingleSFT );
/* loop over all SFTs in SFTCatalog */
for ( i=0; i < FullCatalog->length; i ++ )
{
SFTCatalog oneSFTCatalog;
SFTVector *thisSFT = NULL;
const CHAR *sft_comment;
CHAR *new_comment;
UINT4 comment_len = 0;
/* set catalog containing only one SFT */
oneSFTCatalog.length = 1;
oneSFTCatalog.data = &(FullCatalog->data[i]);
comment_len = strlen ( add_comment ) + 10;
sft_comment = oneSFTCatalog.data->comment;
if ( sft_comment )
comment_len += strlen ( sft_comment );
XLAL_CHECK_MAIN ( ( new_comment = LALCalloc (1, comment_len )) != NULL, XLAL_ENOMEM );
if ( sft_comment ) {
strcpy ( new_comment, sft_comment );
strcat ( new_comment, ";\n");
}
strcat ( new_comment, add_comment );
XLAL_CHECK_MAIN ( (thisSFT = XLALLoadSFTs ( &oneSFTCatalog, fMin, fMax )) != NULL, XLAL_EFUNC );
if ( uvar.mysteryFactor != 1.0 ) {
XLAL_CHECK_MAIN ( applyFactor2SFTs ( thisSFT, uvar.mysteryFactor ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// if user asked for single-SFT output, add this SFT to the open file
if ( uvar.outputSingleSFT )
XLAL_CHECK ( XLAL_SUCCESS == XLALWriteSFT2fp( &(thisSFT->data[0]), fpSingleSFT, new_comment ),
XLAL_EFUNC, "XLALWriteSFT2fp() failed to write SFT to '%s'!\n", uvar.outputSingleSFT );
// if user asked for directory output, write this SFT into that directory
if ( uvar.outputDir ) {
XLAL_CHECK_MAIN ( XLALWriteSFTVector2Dir ( thisSFT, uvar.outputDir, new_comment, uvar.descriptionMisc ) == XLAL_SUCCESS, XLAL_EFUNC );
}
XLALDestroySFTVector ( thisSFT );
XLALFree ( new_comment );
} /* for i < numSFTs */
if ( fpSingleSFT ) {
fclose ( fpSingleSFT );
}
/* free memory */
XLALFree ( add_comment );
XLALDestroySFTCatalog ( FullCatalog );
XLALDestroyUserVars();
XLALDestroyTimestampVector ( timestamps );
LALCheckMemoryLeaks();
return 0;
} /* main */
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
/* register all our user-variable */
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( XLALReadUserInput ( argc, argv, &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
SFTConstraints XLAL_INIT_DECL(constraints);
CHAR detector[2] = "??"; /* allow reading v1-SFTs without detector-info */
constraints.detector = detector;
SFTCatalog *catalog;
XLAL_CHECK ( (catalog = XLALSFTdataFind ( uvar.SFTfiles, &constraints )) != NULL, XLAL_EFUNC, "No SFTs matched your --SFTfiles query\n" );
if ( uvar.headerOnly )
{
for ( UINT4 i=0; i < catalog->length; i ++ )
{
SFTDescriptor *ptr = &(catalog->data[i]);
XLALprintHeader ( &(ptr->header) );
XLALprintDescriptor ( ptr );
} // for i < catalog->length
} // if header
else
{
SFTVector *sfts;
XLAL_CHECK ( (sfts = XLALLoadSFTs ( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
BOOLEAN segmentedSFTs = 0;
if ( sfts->length < catalog->length ) {
segmentedSFTs = 1;
printf ("\n");
printf ("%%%% Frequency-segmented SFTs: len(catalog) = %d, len(sft-vector) = %d\n", catalog->length, sfts->length );
if ( !uvar.noHeader ) {
printf ("%%%% For segmented SFTS we can't output SFT 'descriptors' + data. Use --headerOnly if you need the descriptor fields\n\n");
}
} // if we're dealing with 'segmented SFTs': currently can't map them to catalog-descriptors
for ( UINT4 i=0; i < sfts->length; i ++ )
{
SFTtype *sft_i = &(sfts->data[i]);;
if ( !uvar.noHeader ) {
XLALprintHeader ( sft_i );
if ( !segmentedSFTs ) { // skip descriptor fields for segmented SFTs (as we can't map them to SFTs)
XLALprintDescriptor ( &(catalog->data[i]) );
}
} // output header info
XLALprintData ( sft_i );
} // for i < num_sfts
XLALDestroySFTVector ( sfts );
} /* if !headerOnly */
/* free memory */
XLALDestroySFTCatalog (catalog);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return 0;
} /* main */
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
SFTConstraints XLAL_INIT_DECL(constraints);
CHAR detector[2] = "??"; /* allow reading v1-SFTs without detector-info */
SFTVector *diffs = NULL;
REAL8 maxd = 0;
/* register all user-variables */
UserInput_t XLAL_INIT_DECL(uvar);
XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK_MAIN ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit (0);
}
/* now read in the two complete sft-vectors */
constraints.detector = detector;
SFTCatalog *catalog;
XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname1, &constraints )) != NULL, XLAL_EFUNC );
SFTVector *SFTs1;
XLAL_CHECK_MAIN ( (SFTs1 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTCatalog ( catalog );
XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname2, &constraints )) != NULL, XLAL_EFUNC );
SFTVector *SFTs2;
XLAL_CHECK_MAIN ( (SFTs2 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTCatalog ( catalog );
/* ---------- do some sanity checks of consistency of SFTs ----------*/
XLAL_CHECK_MAIN ( SFTs1->length == SFTs2->length, XLAL_EINVAL, "Number of SFTs differ for SFTbname1 and SFTbname2!\n");
for ( UINT4 i=0; i < SFTs1->length; i++ )
{
SFTtype *sft1 = &(SFTs1->data[i]);
SFTtype *sft2 = &(SFTs2->data[i]);
if( strcmp( sft1->name, sft2->name ) )
{
if ( lalDebugLevel ) { XLALPrintError("WARNING SFT %d: detector-prefix differ! '%s' != '%s'\n", i, sft1->name, sft2->name ); }
/* exit (1); */ /* can't be too strict here, as we also allow v1-SFTs, which don't have detector-name */
}
XLAL_CHECK_MAIN ( sft1->data->length == sft2->data->length, XLAL_EINVAL, "\nERROR SFT %d: lengths differ! %d != %d\n", i, sft1->data->length, sft2->data->length );
REAL8 Tdiff = XLALGPSDiff(&(sft1->epoch), &(sft2->epoch));
CHAR buf1[32], buf2[32];;
XLAL_CHECK_MAIN ( Tdiff == 0.0, XLAL_EINVAL, "SFT %d: epochs differ: %s vs %s\n", i, XLALGPSToStr(buf1,&sft1->epoch), XLALGPSToStr(buf2,&sft2->epoch) );
XLAL_CHECK_MAIN ( sft1->f0 == sft2->f0, XLAL_EINVAL, "ERROR SFT %d: fmin differ: %fHz vs %fHz\n", i, sft1->f0, sft2->f0 );
XLAL_CHECK_MAIN ( sft1->deltaF == sft2->deltaF, XLAL_EINVAL, "ERROR SFT %d: deltaF differs: %fHz vs %fHz\n", i, sft1->deltaF, sft2->deltaF );
} /* for i < numSFTs */
/*---------- now do some actual comparisons ----------*/
XLAL_CHECK_MAIN ( (diffs = subtractSFTVectors ( SFTs1, SFTs2)) != NULL, XLAL_EFUNC );
if ( uvar.verbose)
{
for ( UINT4 i=0; i < SFTs1->length; i++)
{
SFTtype *sft1 = &(SFTs1->data[i]);
SFTtype *sft2 = &(SFTs2->data[i]);
XLALPrintInfo ("i=%02d: ", i);
REAL4 norm1 = scalarProductSFT ( sft1, sft1 );
norm1 = sqrt(norm1);
REAL4 norm2 = scalarProductSFT ( sft2, sft2 );
norm2 = sqrt(norm2);
REAL4 scalar = scalarProductSFT ( sft1, sft2 );
REAL4 normdiff = scalarProductSFT ( &(diffs->data[i]), &(diffs->data[i]) );
REAL4 d1 = (norm1 - norm2)/norm1;
REAL4 d2 = 1.0 - scalar / (norm1*norm2);
REAL4 d3 = normdiff / (norm1*norm1 + norm2*norm2 );
REAL4 d4 = getMaxErrSFT (sft1, sft2);
XLALPrintInfo ("(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2))=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4);
} /* for i < SFTs->length */
} /* if verbose */
/* ---------- COMBINED measures ---------- */
{
REAL4 ret;
ret = scalarProductSFTVector ( SFTs1, SFTs1 );
REAL8 norm1 = sqrt( (REAL8)ret );
ret = scalarProductSFTVector ( SFTs2, SFTs2 );
REAL8 norm2 = sqrt( (REAL8)ret );
ret = scalarProductSFTVector ( SFTs1, SFTs2 );
REAL8 scalar = (REAL8) ret;
ret = scalarProductSFTVector ( diffs, diffs );
REAL8 normdiff = (REAL8) ret;
REAL8 d1 = (norm1 - norm2)/norm1;
maxd = fmax ( maxd, d1 );
REAL8 d2 = 1.0 - scalar / (norm1*norm2);
maxd = fmax ( maxd, d2 );
REAL8 d3 = normdiff / ( norm1*norm1 + norm2*norm2);
maxd = fmax ( maxd, d3 );
REAL8 d4 = getMaxErrSFTVector (SFTs1, SFTs2);
maxd = fmax ( maxd, d4 );
if ( uvar.verbose ) {
printf ("\nTOTAL:(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2)=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4);
}
else
{
printf ("%10.3e %10.3e\n", d3, d4);
}
} /* combined total measures */
/* free memory */
XLALDestroySFTVector ( SFTs1 );
XLALDestroySFTVector ( SFTs2 );
XLALDestroySFTVector ( diffs );
XLALDestroyUserVars();
LALCheckMemoryLeaks();
if ( maxd <= uvar.relErrorMax ) {
return 0;
}
else {
return 1;
}
} /* main */
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
XLAL_CHECK ( argc == 1, XLAL_EINVAL, "No input arguments allowed.\n" );
XLAL_CHECK ( argv != NULL, XLAL_EINVAL );
// ----- load ephemeris
EphemerisData *ephem;
XLAL_CHECK ( (ephem = XLALInitBarycenter ( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" )) != NULL, XLAL_EFUNC );
// ----- setup injection and data parameters
LALStringVector *detNames = NULL;
XLAL_CHECK ( (detNames = XLALCreateStringVector ( "H1", "L1", NULL )) != NULL, XLAL_EFUNC );
UINT4 numDetectors = detNames->length;
// generate and assume some gaussian noise floors
MultiNoiseFloor XLAL_INIT_DECL(injectSqrtSX);
MultiNoiseFloor XLAL_INIT_DECL(assumeSqrtSX);
injectSqrtSX.length = numDetectors;
assumeSqrtSX.length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
injectSqrtSX.sqrtSn[X] = 0; // don't inject random noise to keep errors deterministic and informative (resampling differs much more on noise)
assumeSqrtSX.sqrtSn[X] = 1.0 + 2.0*X;
}
LIGOTimeGPS startTime = {711595934, 0};
REAL8 Tspan = 20 * 3600;
LIGOTimeGPS endTime = startTime;
XLALGPSAdd( &endTime, Tspan );
REAL8 Tsft = 1800;
LIGOTimeGPS refTime = { startTime.gpsSeconds - 2.3 * Tspan, 0 };
MultiLIGOTimeGPSVector *multiTimestamps;
XLAL_CHECK ( ( multiTimestamps = XLALCalloc ( 1, sizeof(*multiTimestamps))) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( ( multiTimestamps->data = XLALCalloc ( numDetectors, sizeof(multiTimestamps->data[0]) )) != NULL, XLAL_ENOMEM );
multiTimestamps->length = numDetectors;
LIGOTimeGPS startTimeX = startTime;
for ( UINT4 X=0; X < numDetectors; X ++ )
{
XLAL_CHECK ( (multiTimestamps->data[X] = XLALMakeTimestamps ( startTimeX, Tspan, Tsft, 0 ) ) != NULL, XLAL_EFUNC );
XLALGPSAdd ( &startTimeX, 0.5 * Tspan ); // shift start-times by 1/2 Tspan for each detector
Tspan *= 2.0;
} // for X < numDetectors
// shift a few timestamps around to create gaps
UINT4 numSFTsPerDet = multiTimestamps->data[0]->length;
multiTimestamps->data[0]->data[numSFTsPerDet-1].gpsSeconds += 10000;
multiTimestamps->data[0]->data[numSFTsPerDet-2].gpsSeconds += 5000;
multiTimestamps->data[1]->data[0].gpsSeconds -= 10000;
multiTimestamps->data[1]->data[1].gpsSeconds -= 5000;
SFTCatalog *catalog;
XLAL_CHECK ( (catalog = XLALMultiAddToFakeSFTCatalog ( NULL, detNames, multiTimestamps )) != NULL, XLAL_EFUNC );
// ----- CW sources to injet ----------
REAL8 Freq = 100.0;
PulsarParamsVector *injectSources;
XLAL_CHECK ( (injectSources = XLALCreatePulsarParamsVector(1)) != NULL, XLAL_EFUNC );
injectSources->data[0].Amp.h0 = 1;
injectSources->data[0].Amp.cosi = 0.5;
injectSources->data[0].Amp.psi = 0.1;
injectSources->data[0].Amp.phi0 = 1.2;
REAL8 asini = 0; // 1.4; // sco-X1 like
REAL8 Period = 0; // 19 * 3600;// sco-X1 like
REAL8 ecc = 0; // 0.1; // much larger than ScoX1
PulsarDopplerParams XLAL_INIT_DECL(Doppler);
Doppler.Alpha = 0.5;
Doppler.Delta = -0.5;
Doppler.fkdot[0] = Freq;
Doppler.fkdot[1] = -1e-9;
Doppler.refTime = refTime;
Doppler.asini = asini;
Doppler.ecc = ecc;
Doppler.tp = startTime;
Doppler.period = Period;
Doppler.argp = 0.5;
injectSources->data[0].Doppler = Doppler;
REAL8 dFreq = 0.1 / Tspan; // 10x finer than native FFT resolution
REAL8 mis = 0.5;
REAL8 df1dot = sqrt( 720.0 * mis ) / (LAL_PI * Tspan * Tspan); // metric (f-projected) stepsize for given mismatch mis
REAL8 dSky = 1e4 / (Freq * Tspan); // rough estimate of a 'metric' sky step, eg. Eq.(118) in \cite Prix07
REAL8 dPeriod = 3600;
UINT4 numFreqBins = 1000;
UINT4 numf1dotPoints = 2;
UINT4 numSkyPoints = 2;
UINT4 numPeriodPoints = 2;
PulsarSpinRange XLAL_INIT_DECL(spinRange);
spinRange.refTime = refTime;
memcpy ( &spinRange.fkdot, &injectSources->data[0].Doppler.fkdot, sizeof(spinRange.fkdot) );
spinRange.fkdotBand[0] = (numFreqBins - 1)*dFreq - 10*LAL_REAL8_EPS;
spinRange.fkdotBand[1] = (numf1dotPoints - 1)*df1dot - 10*LAL_REAL8_EPS;
Doppler.fkdot[0] -= 0.4 * spinRange.fkdotBand[0];
REAL8 minCoverFreq, maxCoverFreq;
XLAL_CHECK ( XLALCWSignalCoveringBand ( &minCoverFreq, &maxCoverFreq, &startTime, &endTime, &spinRange, asini, Period, ecc ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- setup optional Fstat arguments
FstatOptionalArgs optionalArgs = FstatOptionalArgsDefaults;
optionalArgs.injectSources = injectSources;
optionalArgs.injectSqrtSX = &injectSqrtSX;
optionalArgs.assumeSqrtSX = &assumeSqrtSX;
// ----- prepare input data with injection for all available methods
FstatInput *input[FMETHOD_END];
FstatResults *results[FMETHOD_END];
for ( UINT4 iMethod = FMETHOD_START; iMethod < FMETHOD_END; iMethod ++ )
{
results[iMethod] = NULL;
if ( !XLALFstatMethodIsAvailable(iMethod) ) {
continue;
}
optionalArgs.FstatMethod = iMethod;
XLAL_CHECK ( (input[iMethod] = XLALCreateFstatInput ( catalog, minCoverFreq, maxCoverFreq, dFreq, ephem, &optionalArgs )) != NULL, XLAL_EFUNC );
}
FstatQuantities whatToCompute = (FSTATQ_2F | FSTATQ_FAFB);
// ----- loop over all templates {sky, f1dot, period}
for ( UINT4 iSky = 0; iSky < numSkyPoints; iSky ++ )
{
for ( UINT4 if1dot = 0; if1dot < numf1dotPoints; if1dot ++ )
{
for ( UINT4 iPeriod = 0; iPeriod < numPeriodPoints; iPeriod ++ )
{
// ----- loop over all available methods and compare Fstat results
FstatMethodType firstMethod = FMETHOD_START;
for ( UINT4 iMethod = FMETHOD_START; iMethod < FMETHOD_END; iMethod ++ )
{
if ( !XLALFstatMethodIsAvailable(iMethod) ) {
continue;
}
if ( firstMethod == FMETHOD_START ) { // keep track of first available method found
firstMethod = iMethod;
}
XLAL_CHECK ( XLALComputeFstat ( &results[iMethod], input[iMethod], &Doppler, numFreqBins, whatToCompute ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( lalDebugLevel & LALINFOBIT )
{
FILE *fp;
char fname[1024]; XLAL_INIT_MEM ( fname );
snprintf ( fname, sizeof(fname)-1, "twoF%s-iSky%02d-if1dot%02d-iPeriod%02d.dat", XLALGetFstatMethodName(iMethod), iSky, if1dot, iPeriod );
XLAL_CHECK ( (fp = fopen ( fname, "wb" )) != NULL, XLAL_EFUNC );
for ( UINT4 k = 0; k < results[iMethod]->numFreqBins; k ++ )
{
REAL8 Freq0 = results[iMethod]->doppler.fkdot[0];
REAL8 Freq_k = Freq0 + k * results[iMethod]->dFreq;
if ( whatToCompute & FSTATQ_FAFB ) {
fprintf ( fp, "%20.16g %10.4g %10.4g %10.4g %10.4g %10.4g\n",
Freq_k, results[iMethod]->twoF[k],
crealf(results[iMethod]->Fa[k]), cimagf(results[iMethod]->Fa[k]),
crealf(results[iMethod]->Fb[k]), cimagf(results[iMethod]->Fb[k])
);
} else {
fprintf ( fp, "%20.16g %10.4g\n",
Freq_k, results[iMethod]->twoF[k] );
}
} // for k < numFreqBins
fclose(fp);
} // if info
// compare to first result
if ( iMethod != firstMethod )
{
XLALPrintInfo ("Comparing results between method '%s' and '%s'\n", XLALGetFstatMethodName(firstMethod), XLALGetFstatMethodName(iMethod) );
if ( compareFstatResults ( results[firstMethod], results[iMethod] ) != XLAL_SUCCESS )
{
XLALPrintError ("Comparison between method '%s' and '%s' failed\n", XLALGetFstatMethodName(firstMethod), XLALGetFstatMethodName(iMethod) );
XLAL_ERROR ( XLAL_EFUNC );
}
}
} // for i < FMETHOD_END
Doppler.period += dPeriod;
} // for iPeriod < numPeriodPoints
Doppler.fkdot[1] += df1dot;
} // for if1dot < numf1dotPoints
Doppler.Alpha += dSky;
} // for iSky < numSkyPoints
// free remaining memory
for ( UINT4 iMethod=FMETHOD_START; iMethod < FMETHOD_END; iMethod ++ )
{
if ( !XLALFstatMethodIsAvailable(iMethod) ) {
continue;
}
XLALDestroyFstatInput ( input[iMethod] );
XLALDestroyFstatResults ( results[iMethod] );
} // for i < FMETHOD_END
XLALDestroyPulsarParamsVector ( injectSources );
XLALDestroySFTCatalog ( catalog );
XLALDestroyMultiTimestamps ( multiTimestamps );
XLALDestroyStringVector ( detNames );
XLALDestroyEphemerisData ( ephem );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
