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;
}
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;
}