/** \deprecated use XLALUserVarGetLog() instead */
void
LALUserVarGetLog (LALStatus *status, CHAR **logstr, UserVarLogFormat format)
{
INITSTATUS(status);
if ( ((*logstr) = XLALUserVarGetLog ( format )) == NULL ) {
XLALPrintError ("UserVarLogFormat() failed.\n" );
ABORT (status, USERINPUTH_EXLAL, USERINPUTH_MSGEXLAL);
}
RETURN (status);
} /* LALUserVarGetLog() */
/**
* Log the all relevant parameters of this run into a log-file.
* The name of the log-file used is uvar_logfile
* <em>NOTE:</em> Currently this function only logs the user-input and code-versions.
*/
int
XLALWriteMFDlog ( const char *logfile, const ConfigVars_t *cfg )
{
XLAL_CHECK ( logfile != NULL, XLAL_EINVAL, "Invalid NULL input 'logfile'\n" );
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL, "Invalid NULL input 'cfg'\n");
FILE *fplog = fopen ( logfile, "wb" );
XLAL_CHECK ( fplog != NULL, XLAL_EIO, "Failed to fopen log-file '%s' for writing ('wb').\n", logfile );
/* write out a log describing the complete user-input (in cfg-file format) */
CHAR *logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE );
XLAL_CHECK ( logstr != NULL, XLAL_EFUNC, "XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) failed.\n" );
fprintf ( fplog, "## LOG-FILE of Makefakedata run\n\n");
fprintf ( fplog, "# User-input: [formatted as config-file]\n");
fprintf ( fplog, "# ----------------------------------------------------------------------\n\n");
fprintf ( fplog, "%s", logstr);
XLALFree ( logstr );
/* write out a log describing the complete user-input (in commandline format) */
logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE );
XLAL_CHECK ( logstr != NULL, XLAL_EFUNC, "XLALUserVarGetLog(UVAR_LOGFMT_CMDLINE) failed.\n" );
fprintf ( fplog, "\n\n# User-input: [formatted as commandline]\n");
fprintf ( fplog, "# ----------------------------------------------------------------------\n\n");
fprintf ( fplog, "%s", logstr );
XLALFree ( logstr );
/* append an VCS-version string of the code used */
fprintf ( fplog, "\n\n# VCS-versions of executable:\n");
fprintf ( fplog, "# ----------------------------------------------------------------------\n");
fprintf ( fplog, "\n%s\n", cfg->VCSInfoString );
fclose ( fplog );
return XLAL_SUCCESS;
} /* XLALWriteMFDLog() */
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[]){
UserInput_t XLAL_INIT_DECL(uvar);
static ConfigVariables config;
/* sft related variables */
MultiSFTVector *inputSFTs = NULL;
MultiPSDVector *multiPSDs = NULL;
MultiNoiseWeights *multiWeights = NULL;
MultiLIGOTimeGPSVector *multiTimes = NULL;
MultiLALDetector multiDetectors;
MultiDetectorStateSeries *multiStates = NULL;
MultiAMCoeffs *multiCoeffs = NULL;
SFTIndexList *sftIndices = NULL;
SFTPairIndexList *sftPairs = NULL;
REAL8Vector *shiftedFreqs = NULL;
UINT4Vector *lowestBins = NULL;
COMPLEX8Vector *expSignalPhases = NULL;
REAL8VectorSequence *sincList = NULL;
PulsarDopplerParams XLAL_INIT_DECL(dopplerpos);
PulsarDopplerParams thisBinaryTemplate, binaryTemplateSpacings;
PulsarDopplerParams minBinaryTemplate, maxBinaryTemplate;
SkyPosition XLAL_INIT_DECL(skyPos);
MultiSSBtimes *multiBinaryTimes = NULL;
INT4 k;
UINT4 j;
REAL8 fMin, fMax; /* min and max frequencies read from SFTs */
REAL8 deltaF; /* frequency resolution associated with time baseline of SFTs */
REAL8 diagff = 0; /*diagonal metric components*/
REAL8 diagaa = 0;
REAL8 diagTT = 0;
REAL8 diagpp = 1;
REAL8 ccStat = 0;
REAL8 evSquared=0;
REAL8 estSens=0; /*estimated sensitivity(4.13)*/
BOOLEAN dopplerShiftFlag = TRUE;
toplist_t *ccToplist=NULL;
CrossCorrBinaryOutputEntry thisCandidate;
UINT4 checksum;
LogPrintf (LOG_CRITICAL, "Starting time\n"); /*for debug convenience to record calculating time*/
/* initialize and register user variables */
LIGOTimeGPS computingStartGPSTime, computingEndGPSTime;
XLALGPSTimeNow (&computingStartGPSTime); /* record the rough starting GPS time*/
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read user input from the command line or config file */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if (uvar.help) /* if help was requested, then exit */
return 0;
CHAR *VCSInfoString = XLALGetVersionString(0); /**<LAL + LALapps Vsersion string*/
/*If the version information was requested, output it and exit*/
if ( uvar.version ){
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
printf ("%s\n", VCSInfoString );
exit (0);
}
/* configure useful variables based on user input */
if ( XLALInitializeConfigVars ( &config, &uvar) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
deltaF = config.catalog->data[0].header.deltaF;
REAL8 Tsft = 1.0 / deltaF;
if (XLALUserVarWasSet(&uvar.spacingF) && XLALUserVarWasSet(&uvar.mismatchF))
LogPrintf (LOG_CRITICAL, "spacingF and mismatchF are both set, use spacingF %.9g by default\n\n", uvar.spacingF);
if (XLALUserVarWasSet(&uvar.spacingA) && XLALUserVarWasSet(&uvar.mismatchA))
LogPrintf (LOG_CRITICAL, "spacingA and mismatchA are both set, use spacingA %.9g by default\n\n", uvar.spacingA);
if (XLALUserVarWasSet(&uvar.spacingT) && XLALUserVarWasSet(&uvar.mismatchT))
LogPrintf (LOG_CRITICAL, "spacingT and mismatchT are both set, use spacingT %.9g by default\n\n", uvar.spacingT);
if (XLALUserVarWasSet(&uvar.spacingP) && XLALUserVarWasSet(&uvar.mismatchP))
LogPrintf (LOG_CRITICAL, "spacingP and mismatchP are both set, use spacingP %.9g by default\n\n", uvar.spacingP);
/* create the toplist */
create_crossCorrBinary_toplist( &ccToplist, uvar.numCand);
/* now read the data */
/* /\* get SFT parameters so that we can initialise search frequency resolutions *\/ */
/* /\* calculate deltaF_SFT *\/ */
/* deltaF_SFT = catalog->data[0].header.deltaF; /\* frequency resolution *\/ */
/* timeBase= 1.0/deltaF_SFT; /\* sft baseline *\/ */
/* /\* catalog is ordered in time so we can get start, end time and tObs *\/ */
/* firstTimeStamp = catalog->data[0].header.epoch; */
/* lastTimeStamp = catalog->data[catalog->length - 1].header.epoch; */
/* tObs = XLALGPSDiff( &lastTimeStamp, &firstTimeStamp ) + timeBase; */
/* /\*set pulsar reference time *\/ */
/* if (LALUserVarWasSet ( &uvar_refTime )) { */
/* XLALGPSSetREAL8(&refTime, uvar_refTime); */
/* } */
/* else { /\*if refTime is not set, set it to midpoint of sfts*\/ */
/* XLALGPSSetREAL8(&refTime, (0.5*tObs) + XLALGPSGetREAL8(&firstTimeStamp)); */
/* } */
/* /\* set frequency resolution defaults if not set by user *\/ */
/* if (!(LALUserVarWasSet (&uvar_fResolution))) { */
/* uvar_fResolution = 1/tObs; */
/* } */
/* { */
/* /\* block for calculating frequency range to read from SFTs *\/ */
/* /\* user specifies freq and fdot range at reftime */
/* we translate this range of fdots to start and endtime and find */
/* the largest frequency band required to cover the */
/* frequency evolution *\/ */
/* PulsarSpinRange spinRange_startTime; /\**< freq and fdot range at start-time of observation *\/ */
/* PulsarSpinRange spinRange_endTime; /\**< freq and fdot range at end-time of observation *\/ */
/* PulsarSpinRange spinRange_refTime; /\**< freq and fdot range at the reference time *\/ */
/* REAL8 startTime_freqLo, startTime_freqHi, endTime_freqLo, endTime_freqHi, freqLo, freqHi; */
/* REAL8Vector *fdotsMin=NULL; */
/* REAL8Vector *fdotsMax=NULL; */
/* UINT4 k; */
/* fdotsMin = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMin->length = N_SPINDOWN_DERIVS; */
/* fdotsMin->data = (REAL8 *)LALCalloc(fdotsMin->length, sizeof(REAL8)); */
/* fdotsMax = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMax->length = N_SPINDOWN_DERIVS; */
/* fdotsMax->data = (REAL8 *)LALCalloc(fdotsMax->length, sizeof(REAL8)); */
/* XLAL_INIT_MEM(spinRange_startTime); */
/* XLAL_INIT_MEM(spinRange_endTime); */
/* XLAL_INIT_MEM(spinRange_refTime); */
/* spinRange_refTime.refTime = refTime; */
/* spinRange_refTime.fkdot[0] = uvar_f0; */
/* spinRange_refTime.fkdotBand[0] = uvar_fBand; */
/* } */
/* FIXME: need to correct fMin and fMax for Doppler shift, rngmedian bins and spindown range */
/* this is essentially just a place holder for now */
/* FIXME: this running median buffer is overkill, since the running median block need not be centered on the search frequency */
REAL8 vMax = LAL_TWOPI * (uvar.orbitAsiniSec + uvar.orbitAsiniSecBand) / uvar.orbitPSec + LAL_TWOPI * LAL_REARTH_SI / (LAL_DAYSID_SI * LAL_C_SI) + LAL_TWOPI * LAL_AU_SI/(LAL_YRSID_SI * LAL_C_SI); /*calculate the maximum relative velocity in speed of light*/
fMin = uvar.fStart * (1 - vMax) - 0.5 * uvar.rngMedBlock * deltaF;
fMax = (uvar.fStart + uvar.fBand) * (1 + vMax) + 0.5 * uvar.rngMedBlock * deltaF;
/* read the SFTs*/
if ((inputSFTs = XLALLoadMultiSFTs ( config.catalog, fMin, fMax)) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALLoadMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* calculate the psd and normalize the SFTs */
if (( multiPSDs = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.rngMedBlock, NULL )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALNormalizeMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* compute the noise weights for the AM coefficients */
if (( multiWeights = XLALComputeMultiNoiseWeights ( multiPSDs, uvar.rngMedBlock, 0 )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiNoiseWeights() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the timestamps from the SFTs */
if ((multiTimes = XLALExtractMultiTimestampsFromSFTs ( inputSFTs )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALExtractMultiTimestampsFromSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the detector information from the SFTs */
if ( XLALMultiLALDetectorFromMultiSFTs ( &multiDetectors, inputSFTs ) != XLAL_SUCCESS){
LogPrintf ( LOG_CRITICAL, "%s: XLALMultiLALDetectorFromMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Find the detector state for each SFT */
/* Offset by Tsft/2 to get midpoint as timestamp */
if ((multiStates = XLALGetMultiDetectorStates ( multiTimes, &multiDetectors, config.edat, 0.5 * Tsft )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiDetectorStates() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Note this is specialized to a single sky position */
/* This might need to be moved into the config variables */
skyPos.system = COORDINATESYSTEM_EQUATORIAL;
skyPos.longitude = uvar.alphaRad;
skyPos.latitude = uvar.deltaRad;
/* Calculate the AM coefficients (a,b) for each SFT */
if ((multiCoeffs = XLALComputeMultiAMCoeffs ( multiStates, multiWeights, skyPos )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiAMCoeffs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the flat list of SFTs (this sort of replicates the
catalog, but there's not an obvious way to get the information
back) */
if ( ( XLALCreateSFTIndexListFromMultiSFTVect( &sftIndices, inputSFTs ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTIndexListFromMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the list of SFT pairs */
#define PCC_SFTPAIR_HEADER "# The length of SFT-pair list is %u #\n"
#define PCC_SFTPAIR_BODY "%u %u\n"
#define PCC_SFT_HEADER "# The length of SFT list is %u #\n"
#define PCC_SFT_BODY "%s %d %d\n"
FILE *fp = NULL;
if (XLALUserVarWasSet(&uvar.pairListInputFilename)) { /* If the user provided a list for reading, use it */
if((sftPairs = XLALCalloc(1, sizeof(sftPairs))) == NULL){
XLAL_ERROR(XLAL_ENOMEM);
}
if((fp = fopen(uvar.pairListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "didn't find SFT-pair list file with given input name\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(fscanf(fp,PCC_SFTPAIR_HEADER,&sftPairs->length)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read the length of SFT-pair list from the header\n");
XLAL_ERROR( XLAL_EFUNC );
}
if((sftPairs->data = XLALCalloc(sftPairs->length, sizeof(*sftPairs->data)))==NULL){
XLALFree(sftPairs);
XLAL_ERROR(XLAL_ENOMEM);
}
for(j = 0; j < sftPairs->length; j++){ /*read in the SFT-pair list */
if(fscanf(fp,PCC_SFTPAIR_BODY, &sftPairs->data[j].sftNum[0], &sftPairs->data[j].sftNum[1])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT-pair list doesn't match!");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
}
else { /* if not, construct the list of pairs */
if ( ( XLALCreateSFTPairIndexList( &sftPairs, sftIndices, inputSFTs, uvar.maxLag, uvar.inclAutoCorr ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTPairIndexList() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if (XLALUserVarWasSet(&uvar.pairListOutputFilename)) { /* Write the list of pairs to a file, if a name was provided */
if((fp = fopen(uvar.pairListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in SFT-pair list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFTPAIR_HEADER, sftPairs->length ); /*output the length of SFT-pair list to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_SFTPAIR_BODY, sftPairs->data[j].sftNum[0], sftPairs->data[j].sftNum[1]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.sftListOutputFilename)) { /* Write the list of SFTs to a file for sanity-checking purposes */
if((fp = fopen(uvar.sftListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFT_HEADER, sftIndices->length ); /*output the length of SFT list to the header*/
for(j = 0; j < sftIndices->length; j++){ /*output the SFT list */
fprintf(fp,PCC_SFT_BODY, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds);
}
fclose(fp);
}
else if(XLALUserVarWasSet(&uvar.sftListInputFilename)){ /*do a sanity check of the order of SFTs list if the name of input SFT list is given*/
UINT4 numofsft=0;
if((fp = fopen(uvar.sftListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't read in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
if (fscanf(fp, PCC_SFT_HEADER, &numofsft)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read in the length of SFT list from header\n");
XLAL_ERROR( XLAL_EFUNC );
}
CHARVectorSequence *checkDet=NULL;
if ((checkDet = XLALCreateCHARVectorSequence (numofsft, LALNameLength) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateCHARVector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
INT4 checkGPS[numofsft], checkGPSns[numofsft];
if(numofsft == sftIndices->length){
for (j=0; j<numofsft; j++){
if( fscanf(fp,PCC_SFT_BODY,&checkDet->data[j * LALNameLength], &checkGPS[j], &checkGPSns[j])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT list doesn't match\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(strcmp( inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, &checkDet->data[j * LALNameLength] ) != 0
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds != checkGPS[j]
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds != checkGPSns[j] ){
LogPrintf ( LOG_CRITICAL, "The order of SFTs has been changed, it's the end of civilization\n");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
XLALDestroyCHARVectorSequence(checkDet);
}
else{
LogPrintf ( LOG_CRITICAL, "Run for your life, the length of SFT list doesn't match");
XLAL_ERROR( XLAL_EFUNC );
}
}
else
{
}
/* Get weighting factors for calculation of metric */
/* note that the sigma-squared is now absorbed into the curly G
because the AM coefficients are noise-weighted. */
REAL8Vector *GammaAve = NULL;
REAL8Vector *GammaCirc = NULL;
if ( ( XLALCalculateCrossCorrGammas( &GammaAve, &GammaCirc, sftPairs, sftIndices, multiCoeffs) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrGammas() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
#define PCC_GAMMA_HEADER "# The normalization Sinv_Tsft is %g #\n"
#define PCC_GAMMA_BODY "%.10g\n"
if (XLALUserVarWasSet(&uvar.gammaAveOutputFilename)) { /* Write the aa+bb weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaAveOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_ave list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaAve->data[j]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.gammaCircOutputFilename)) { /* Write the ab-ba weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaCircOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_circ list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaCirc->data[j]);
}
fclose(fp);
}
/*initialize binary parameters structure*/
XLAL_INIT_MEM(minBinaryTemplate);
XLAL_INIT_MEM(maxBinaryTemplate);
XLAL_INIT_MEM(thisBinaryTemplate);
XLAL_INIT_MEM(binaryTemplateSpacings);
/*fill in minbinaryOrbitParams*/
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc);
minBinaryTemplate.argp = 0.0;
minBinaryTemplate.asini = uvar.orbitAsiniSec;
minBinaryTemplate.ecc = 0.0;
minBinaryTemplate.period = uvar.orbitPSec;
minBinaryTemplate.fkdot[0] = uvar.fStart;
/*fill in maxBinaryParams*/
XLALGPSSetREAL8( &maxBinaryTemplate.tp, uvar.orbitTimeAsc + uvar.orbitTimeAscBand);
maxBinaryTemplate.argp = 0.0;
maxBinaryTemplate.asini = uvar.orbitAsiniSec + uvar.orbitAsiniSecBand;
maxBinaryTemplate.ecc = 0.0;
maxBinaryTemplate.period = uvar.orbitPSec;
maxBinaryTemplate.fkdot[0] = uvar.fStart + uvar.fBand;
/*fill in thisBinaryTemplate*/
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * uvar.orbitTimeAscBand);
thisBinaryTemplate.argp = 0.0;
thisBinaryTemplate.asini = 0.5*(minBinaryTemplate.asini + maxBinaryTemplate.asini);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.period =0.5*(minBinaryTemplate.period + maxBinaryTemplate.period);
thisBinaryTemplate.fkdot[0]=0.5*(minBinaryTemplate.fkdot[0] + maxBinaryTemplate.fkdot[0]);
/*Get metric diagonal components, also estimate sensitivity i.e. E[rho]/(h0)^2 (4.13)*/
if ( (XLALCalculateLMXBCrossCorrDiagMetric(&estSens, &diagff, &diagaa, &diagTT, thisBinaryTemplate, GammaAve, sftPairs, sftIndices, inputSFTs, multiWeights /*, kappaValues*/) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateLMXBCrossCorrDiagMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* spacing in frequency from diagff */ /* set spacings in new dopplerparams struct */
if (XLALUserVarWasSet(&uvar.spacingF)) /* If spacing was given by CMD line, use it, else calculate spacing by mismatch*/
binaryTemplateSpacings.fkdot[0] = uvar.spacingF;
else
binaryTemplateSpacings.fkdot[0] = sqrt(uvar.mismatchF / diagff);
if (XLALUserVarWasSet(&uvar.spacingA))
binaryTemplateSpacings.asini = uvar.spacingA;
else
binaryTemplateSpacings.asini = sqrt(uvar.mismatchA / diagaa);
/* this is annoying: tp is a GPS time while we want a difference
in time which should be just REAL8 */
if (XLALUserVarWasSet(&uvar.spacingT))
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, uvar.spacingT);
else
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, sqrt(uvar.mismatchT / diagTT));
if (XLALUserVarWasSet(&uvar.spacingP))
binaryTemplateSpacings.period = uvar.spacingP;
else
binaryTemplateSpacings.period = sqrt(uvar.mismatchP / diagpp);
/* metric elements for eccentric case not considered? */
UINT8 fCount = 0, aCount = 0, tCount = 0 , pCount = 0;
const UINT8 fSpacingNum = floor( uvar.fBand / binaryTemplateSpacings.fkdot[0]);
const UINT8 aSpacingNum = floor( uvar.orbitAsiniSecBand / binaryTemplateSpacings.asini);
const UINT8 tSpacingNum = floor( uvar.orbitTimeAscBand / XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
const UINT8 pSpacingNum = floor( uvar.orbitPSecBand / binaryTemplateSpacings.period);
/*reset minbinaryOrbitParams to shift the first point a factor so as to make the center of all seaching points centers at the center of searching band*/
minBinaryTemplate.fkdot[0] = uvar.fStart + 0.5 * (uvar.fBand - fSpacingNum * binaryTemplateSpacings.fkdot[0]);
minBinaryTemplate.asini = uvar.orbitAsiniSec + 0.5 * (uvar.orbitAsiniSecBand - aSpacingNum * binaryTemplateSpacings.asini);
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * (uvar.orbitTimeAscBand - tSpacingNum * XLALGPSGetREAL8(&binaryTemplateSpacings.tp)));
minBinaryTemplate.period = uvar.orbitPSec + 0.5 * (uvar.orbitPSecBand - pSpacingNum * binaryTemplateSpacings.period);
/* initialize the doppler scan struct which stores the current template information */
XLALGPSSetREAL8(&dopplerpos.refTime, config.refTime);
dopplerpos.Alpha = uvar.alphaRad;
dopplerpos.Delta = uvar.deltaRad;
dopplerpos.fkdot[0] = minBinaryTemplate.fkdot[0];
/* set all spindowns to zero */
for (k=1; k < PULSAR_MAX_SPINS; k++)
dopplerpos.fkdot[k] = 0.0;
dopplerpos.asini = minBinaryTemplate.asini;
dopplerpos.period = minBinaryTemplate.period;
dopplerpos.tp = minBinaryTemplate.tp;
dopplerpos.ecc = minBinaryTemplate.ecc;
dopplerpos.argp = minBinaryTemplate.argp;
/* now set the initial values of binary parameters */
/* thisBinaryTemplate.asini = uvar.orbitAsiniSec;
thisBinaryTemplate.period = uvar.orbitPSec;
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.argp = 0.0;*/
/* copy to dopplerpos */
/* Calculate SSB times (can do this once since search is currently only for one sky position, and binary doppler shift is added later) */
MultiSSBtimes *multiSSBTimes = NULL;
if ((multiSSBTimes = XLALGetMultiSSBtimes ( multiStates, skyPos, dopplerpos.refTime, SSBPREC_RELATIVISTICOPT )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* "New" general metric computation */
/* For now hard-code circular parameter space */
const DopplerCoordinateSystem coordSys = {
.dim = 4,
.coordIDs = { DOPPLERCOORD_FREQ,
DOPPLERCOORD_ASINI,
DOPPLERCOORD_TASC,
DOPPLERCOORD_PORB, },
};
REAL8VectorSequence *phaseDerivs = NULL;
if ( ( XLALCalculateCrossCorrPhaseDerivatives ( &phaseDerivs, &thisBinaryTemplate, config.edat, sftIndices, multiSSBTimes, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseDerivatives() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill in metric and parameter offsets */
gsl_matrix *g_ij = NULL;
gsl_vector *eps_i = NULL;
REAL8 sumGammaSq = 0;
if ( ( XLALCalculateCrossCorrPhaseMetric ( &g_ij, &eps_i, &sumGammaSq, phaseDerivs, sftPairs, GammaAve, GammaCirc, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
XLALDestroyREAL8VectorSequence ( phaseDerivs );
XLALDestroyREAL8Vector ( GammaCirc );
if ((fp = fopen("gsldata.dat","w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in gsl matrix file");
XLAL_ERROR( XLAL_EFUNC );
}
XLALfprintfGSLvector(fp, "%g", eps_i);
XLALfprintfGSLmatrix(fp, "%g", g_ij);
/* Allocate structure for binary doppler-shifting information */
if ((multiBinaryTimes = XLALDuplicateMultiSSBtimes ( multiSSBTimes )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALDuplicateMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
UINT8 numSFTs = sftIndices->length;
if ((shiftedFreqs = XLALCreateREAL8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((lowestBins = XLALCreateUINT4Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateUINT4Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((expSignalPhases = XLALCreateCOMPLEX8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((sincList = XLALCreateREAL8VectorSequence ( numSFTs, uvar.numBins ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8VectorSequence() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* args should be : spacings, min and max doppler params */
BOOLEAN firstPoint = TRUE; /* a boolean to help to search at the beginning point in parameter space, after the search it is set to be FALSE to end the loop*/
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
} /*Need to apply additional doppler shifting before the loop, or the first point in parameter space will be lost and return a wrong SNR when fBand!=0*/
while ( GetNextCrossCorrTemplate(&dopplerShiftFlag, &firstPoint, &dopplerpos, &binaryTemplateSpacings, &minBinaryTemplate, &maxBinaryTemplate, &fCount, &aCount, &tCount, &pCount, fSpacingNum, aSpacingNum, tSpacingNum, pSpacingNum) == 0)
{
/* do useful stuff here*/
/* Apply additional Doppler shifting using current binary orbital parameters */
/* Might want to be clever about checking whether we've changed the orbital parameters or only the frequency */
if (dopplerShiftFlag == TRUE)
{
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if ( (XLALGetDopplerShiftedFrequencyInfo( shiftedFreqs, lowestBins, expSignalPhases, sincList, uvar.numBins, &dopplerpos, sftIndices, inputSFTs, multiBinaryTimes, Tsft ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALGetDopplerShiftedFrequencyInfo() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ( (XLALCalculatePulsarCrossCorrStatistic( &ccStat, &evSquared, GammaAve, expSignalPhases, lowestBins, sincList, sftPairs, sftIndices, inputSFTs, multiWeights, uvar.numBins) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculatePulsarCrossCorrStatistic() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill candidate struct and insert into toplist if necessary */
thisCandidate.freq = dopplerpos.fkdot[0];
thisCandidate.tp = XLALGPSGetREAL8( &dopplerpos.tp );
thisCandidate.argp = dopplerpos.argp;
thisCandidate.asini = dopplerpos.asini;
thisCandidate.ecc = dopplerpos.ecc;
thisCandidate.period = dopplerpos.period;
thisCandidate.rho = ccStat;
thisCandidate.evSquared = evSquared;
thisCandidate.estSens = estSens;
insert_into_crossCorrBinary_toplist(ccToplist, thisCandidate);
} /* end while loop over templates */
/* write candidates to file */
sort_crossCorrBinary_toplist( ccToplist );
/* add error checking */
final_write_crossCorrBinary_toplist_to_file( ccToplist, uvar.toplistFilename, &checksum);
REAL8 h0Sens = sqrt((10 / sqrt(estSens))); /*for a SNR=10 signal, the h0 we can detect*/
XLALGPSTimeNow (&computingEndGPSTime); /*record the rough end time*/
UINT4 computingTime = computingEndGPSTime.gpsSeconds - computingStartGPSTime.gpsSeconds;
/* make a meta-data file*/
if(XLALUserVarWasSet(&uvar.logFilename)){
CHAR *CMDInputStr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE );
if ((fp = fopen(uvar.logFilename,"w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in logfile");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp, "[UserInput]\n\n");
fprintf(fp, "%s\n", CMDInputStr);
fprintf(fp, "[CalculatedValues]\n\n");
fprintf(fp, "g_ff = %.9f\n", diagff );
fprintf(fp, "g_aa = %.9f\n", diagaa );
fprintf(fp, "g_TT = %.9f\n", diagTT );
fprintf(fp, "FSpacing = %.9g\n", binaryTemplateSpacings.fkdot[0]);
fprintf(fp, "ASpacing = %.9g\n", binaryTemplateSpacings.asini);
fprintf(fp, "TSpacing = %.9g\n", XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
/* fprintf(fp, "PSpacing = %.9g\n", binaryTemplateSpacings.period );*/
fprintf(fp, "TemplatenumF = %" LAL_UINT8_FORMAT "\n", (fSpacingNum + 1));
fprintf(fp, "TemplatenumA = %" LAL_UINT8_FORMAT "\n", (aSpacingNum + 1));
fprintf(fp, "TemplatenumT = %" LAL_UINT8_FORMAT "\n", (tSpacingNum + 1));
fprintf(fp, "TemplatenumP = %" LAL_UINT8_FORMAT "\n", (pSpacingNum + 1));
fprintf(fp, "TemplatenumTotal = %" LAL_UINT8_FORMAT "\n",(fSpacingNum + 1) * (aSpacingNum + 1) * (tSpacingNum + 1) * (pSpacingNum + 1));
fprintf(fp, "Sens = %.9g\n", estSens);/*(E[rho]/h0^2)^2*/
fprintf(fp, "h0_min_SNR10 = %.9g\n", h0Sens);/*for rho = 10 in our pipeline*/
fprintf(fp, "startTime = %" LAL_INT4_FORMAT "\n", computingStartGPSTime.gpsSeconds );/*start time in GPS-time*/
fprintf(fp, "endTime = %" LAL_INT4_FORMAT "\n", computingEndGPSTime.gpsSeconds );/*end time in GPS-time*/
fprintf(fp, "computingTime = %" LAL_UINT4_FORMAT "\n", computingTime );/*total time in sec*/
fprintf(fp, "SFTnum = %" LAL_UINT4_FORMAT "\n", sftIndices->length);/*total number of SFT*/
fprintf(fp, "pairnum = %" LAL_UINT4_FORMAT "\n", sftPairs->length);/*total number of pair of SFT*/
fprintf(fp, "Tsft = %.6g\n", Tsft);/*SFT duration*/
fprintf(fp, "\n[Version]\n\n");
fprintf(fp, "%s", VCSInfoString);
fclose(fp);
XLALFree(CMDInputStr);
}
XLALFree(VCSInfoString);
XLALDestroyCOMPLEX8Vector ( expSignalPhases );
XLALDestroyUINT4Vector ( lowestBins );
XLALDestroyREAL8Vector ( shiftedFreqs );
XLALDestroyREAL8VectorSequence ( sincList );
XLALDestroyMultiSSBtimes ( multiBinaryTimes );
XLALDestroyMultiSSBtimes ( multiSSBTimes );
XLALDestroyREAL8Vector ( GammaAve );
XLALDestroySFTPairIndexList( sftPairs );
XLALDestroySFTIndexList( sftIndices );
XLALDestroyMultiAMCoeffs ( multiCoeffs );
XLALDestroyMultiDetectorStateSeries ( multiStates );
XLALDestroyMultiTimestamps ( multiTimes );
XLALDestroyMultiNoiseWeights ( multiWeights );
XLALDestroyMultiPSDVector ( multiPSDs );
XLALDestroyMultiSFTVector ( inputSFTs );
/* de-allocate memory for configuration variables */
XLALDestroyConfigVars ( &config );
/* de-allocate memory for user input variables */
XLALDestroyUserVars();
/* free toplist memory */
free_crossCorr_toplist(&ccToplist);
/* check memory leaks if we forgot to de-allocate anything */
LALCheckMemoryLeaks();
LogPrintf (LOG_CRITICAL, "End time\n");/*for debug convenience to record calculating time*/
return 0;
} /* main */
/* initialize and register user variables */
int XLALInitUserVars (UserInput_t *uvar)
{
/* initialize with some defaults */
uvar->help = FALSE;
uvar->maxLag = 0.0;
uvar->inclAutoCorr = FALSE;
uvar->fStart = 100.0;
uvar->fBand = 0.1;
/* uvar->fdotStart = 0.0; */
/* uvar->fdotBand = 0.0; */
uvar->alphaRad = 0.0;
uvar->deltaRad = 0.0;
uvar->refTime = 0.0;
uvar->rngMedBlock = 50;
uvar->numBins = 1;
/* zero binary orbital parameters means not a binary */
uvar->orbitAsiniSec = 0.0;
uvar->orbitAsiniSecBand = 0.0;
uvar->orbitPSec = 0.0;
uvar->orbitPSecBand = 0.0;
uvar->orbitTimeAsc = 0;
uvar->orbitTimeAscBand = 0;
/*default mismatch values */
/* set to 0.1 by default -- for no real reason */
/* make 0.1 a macro? */
uvar->mismatchF = 0.1;
uvar->mismatchA = 0.1;
uvar->mismatchT = 0.1;
uvar->mismatchP = 0.1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->sftLocation = XLALCalloc(1, MAXFILENAMELENGTH+1);
/* initialize number of candidates in toplist -- default is just to return the single best candidate */
uvar->numCand = 1;
uvar->toplistFilename = XLALStringDuplicate("toplist_crosscorr.dat");
uvar->version = FALSE;
/* register user-variables */
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP, "Print this message");
XLALregINTUserStruct ( startTime, 0, UVAR_REQUIRED, "Desired start time of analysis in GPS seconds");
XLALregINTUserStruct ( endTime, 0, UVAR_REQUIRED, "Desired end time of analysis in GPS seconds");
XLALregREALUserStruct ( maxLag, 0, UVAR_OPTIONAL, "Maximum lag time in seconds between SFTs in correlation");
XLALregBOOLUserStruct ( inclAutoCorr, 0, UVAR_OPTIONAL, "Include auto-correlation terms (an SFT with itself)");
XLALregREALUserStruct ( fStart, 0, UVAR_OPTIONAL, "Start frequency in Hz");
XLALregREALUserStruct ( fBand, 0, UVAR_OPTIONAL, "Frequency band to search over in Hz ");
/* XLALregREALUserStruct ( fdotStart, 0, UVAR_OPTIONAL, "Start value of spindown in Hz/s"); */
/* XLALregREALUserStruct ( fdotBand, 0, UVAR_OPTIONAL, "Band for spindown values in Hz/s"); */
XLALregREALUserStruct ( alphaRad, 0, UVAR_OPTIONAL, "Right ascension for directed search (radians)");
XLALregREALUserStruct ( deltaRad, 0, UVAR_OPTIONAL, "Declination for directed search (radians)");
XLALregREALUserStruct ( refTime, 0, UVAR_OPTIONAL, "SSB reference time for pulsar-parameters [Default: midPoint]");
XLALregREALUserStruct ( orbitAsiniSec, 0, UVAR_OPTIONAL, "Start of search band for projected semimajor axis (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitAsiniSecBand, 0, UVAR_OPTIONAL, "Width of search band for projected semimajor axis (seconds)");
XLALregREALUserStruct ( orbitPSec, 0, UVAR_OPTIONAL, "Binary orbital period (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitPSecBand, 0, UVAR_OPTIONAL, "Band for binary orbital period (seconds) ");
XLALregREALUserStruct ( orbitTimeAsc, 0, UVAR_OPTIONAL, "Start of orbital time-of-ascension band in GPS seconds");
XLALregREALUserStruct ( orbitTimeAscBand, 0, UVAR_OPTIONAL, "Width of orbital time-of-ascension band (seconds)");
XLALregSTRINGUserStruct( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregSTRINGUserStruct( sftLocation, 0, UVAR_REQUIRED, "Filename pattern for locating SFT data");
XLALregINTUserStruct ( rngMedBlock, 0, UVAR_OPTIONAL, "Running median block size for PSD estimation");
XLALregINTUserStruct ( numBins, 0, UVAR_OPTIONAL, "Number of frequency bins to include in calculation");
XLALregREALUserStruct ( mismatchF, 0, UVAR_OPTIONAL, "Desired mismatch for frequency spacing");
XLALregREALUserStruct ( mismatchA, 0, UVAR_OPTIONAL, "Desired mismatch for asini spacing");
XLALregREALUserStruct ( mismatchT, 0, UVAR_OPTIONAL, "Desired mismatch for periapse passage time spacing");
XLALregREALUserStruct ( mismatchP, 0, UVAR_OPTIONAL, "Desired mismatch for period spacing");
XLALregREALUserStruct ( spacingF, 0, UVAR_OPTIONAL, "Desired frequency spacing");
XLALregREALUserStruct ( spacingA, 0, UVAR_OPTIONAL, "Desired asini spacing");
XLALregREALUserStruct ( spacingT, 0, UVAR_OPTIONAL, "Desired periapse passage time spacing");
XLALregREALUserStruct ( spacingP, 0, UVAR_OPTIONAL, "Desired period spacing");
XLALregINTUserStruct ( numCand, 0, UVAR_OPTIONAL, "Number of candidates to keep in toplist");
XLALregSTRINGUserStruct( pairListInputFilename, 0, UVAR_OPTIONAL, "Name of file from which to read list of SFT pairs");
XLALregSTRINGUserStruct( pairListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFT pairs");
XLALregSTRINGUserStruct( sftListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( sftListInputFilename, 0, UVAR_OPTIONAL, "Name of file to which to read in list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( gammaAveOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write aa+bb weights (for e.g., false alarm estimation)");
XLALregSTRINGUserStruct( gammaCircOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write ab-ba weights (for e.g., systematic error)");
XLALregSTRINGUserStruct( toplistFilename, 0, UVAR_OPTIONAL, "Output filename containing candidates in toplist");
XLALregSTRINGUserStruct( logFilename, 0, UVAR_OPTIONAL, "Output a meta-data file for the search");
XLALregBOOLUserStruct ( version, 'V', UVAR_SPECIAL, "Output version(VCS) information");
if ( xlalErrno ) {
XLALPrintError ("%s: user variable initialization failed with errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
}
/** Initialize Fstat-code: handle user-input and set everything up. */
int
XLALInitCode ( ConfigVariables *cfg, const UserInput_t *uvar )
{
/* generate log-string for file-output, containing cmdline-options + code VCS version info */
char *vcs;
if ( (vcs = XLALGetVersionString(0)) == NULL ) { /* short VCS version string */
XLALPrintError ( "%s: XLALGetVersionString(0) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
char *cmdline;
if ( (cmdline = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) == NULL ) {
XLALPrintError ( "%s: XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE ) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
const char fmt[] = "%%%% cmdline: %s\n%%%%\n%s%%%%\n";
UINT4 len = strlen(vcs) + strlen(cmdline) + strlen(fmt) + 1;
if ( ( cfg->logString = XLALMalloc ( len )) == NULL ) {
XLALPrintError ("%s: XLALMalloc ( %d ) failed.\n", __func__, len );
XLAL_ERROR ( XLAL_ENOMEM );
}
sprintf ( cfg->logString, fmt, cmdline, vcs );
XLALFree ( cmdline );
XLALFree ( vcs );
/* trivial settings from user-input */
cfg->SignalOnly = uvar->SignalOnly;
/* ----- parse user-input on signal amplitude-paramters + ranges ----- */
/* skypos */
cfg->skypos.longitude = uvar->Alpha; /* Alpha < 0 indicates 'allsky' */
cfg->skypos.latitude = uvar->Delta;
cfg->skypos.system = COORDINATESYSTEM_EQUATORIAL;
/* ----- amplitude-params: create prior pdfs reflecting the user-input */
if ( XLALInitAmplitudePrior ( &cfg->AmpPrior, uvar ) != XLAL_SUCCESS )
XLAL_ERROR ( XLAL_EFUNC );
/* ----- initialize random-number generator ----- */
/* read out environment variables GSL_RNG_xxx
* GSL_RNG_SEED: use to set random seed: default = 0, override by using --randSeed on cmdline
* GSL_RNG_TYPE: type of random-number generator to use: default = 'mt19937'
*/
gsl_rng_env_setup ();
/* allow overriding the random-seed per command-line */
if ( XLALUserVarWasSet ( &uvar->randSeed ) )
gsl_rng_default_seed = uvar->randSeed;
cfg->rng = gsl_rng_alloc (gsl_rng_default);
LogPrintf ( LOG_DEBUG, "random-number generator type: %s\n", gsl_rng_name (cfg->rng));
LogPrintf ( LOG_DEBUG, "seed = %lu\n", gsl_rng_default_seed );
/* init ephemeris-data */
EphemerisData *edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun );
if ( !edat ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", __func__, uvar->ephemEarth, uvar->ephemSun);
XLAL_ERROR ( XLAL_EFUNC );
}
UINT4 numDetectors = uvar->IFOs->length;
MultiLALDetector multiDet;
XLAL_CHECK ( XLALParseMultiLALDetector ( &multiDet, uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC );
/* init timestamps vector covering observation time */
UINT4 numSteps = (UINT4) ceil ( uvar->dataDuration / uvar->TAtom );
MultiLIGOTimeGPSVector * multiTS;
if ( (multiTS = XLALCreateMultiLIGOTimeGPSVector (numDetectors)) == NULL ) {
XLALPrintError ("%s: XLALCreateMultiLIGOTimeGPSVector(%d) failed.\n", __func__, numDetectors );
}
for ( UINT4 X=0; X < numDetectors; X++ ) {
if ( (multiTS->data[X] = XLALCreateTimestampVector (numSteps)) == NULL ) {
XLALPrintError ("%s: XLALCreateTimestampVector(%d) failed.\n", __func__, numSteps );
}
multiTS->data[X]->deltaT = uvar->TAtom;
UINT4 i;
for ( i=0; i < numSteps; i ++ )
{
UINT4 ti = uvar->dataStartGPS + i * uvar->TAtom;
multiTS->data[X]->data[i].gpsSeconds = ti;
multiTS->data[X]->data[i].gpsNanoSeconds = 0;
}
}
/* get detector states */
if ( (cfg->multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiDet, edat, 0.5 * uvar->TAtom )) == NULL ) {
XLALPrintError ( "%s: XLALGetMultiDetectorStates() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar->sqrtSX ) { /* translate user-input PSD sqrt(SX) to noise-weights (this actually does not care whether they were normalized or not) */
/* parse input comma-separated list */
MultiNoiseFloor multiNoiseFloor;
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &multiNoiseFloor, uvar->sqrtSX, numDetectors ) == XLAL_SUCCESS, XLAL_EFUNC );
/* translate to noise weights */
XLAL_CHECK ( ( cfg->multiNoiseWeights = XLALComputeConstantMultiNoiseWeightsFromNoiseFloor ( &multiNoiseFloor, multiTS, uvar->TAtom ) ) != NULL, XLAL_EFUNC );
} /* if ( uvar->sqrtSX ) */
/* get rid of all temporary memory allocated for this step */
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiTimestamps ( multiTS );
multiTS = NULL;
/* ---------- initialize transient window ranges, for injection ... ---------- */
cfg->transientInjectRange.type = TRANSIENT_NONE; /* default: no transient signal window */
/* apply correct defaults if unset: t0=dataStart, t0Band=dataDuration-3*tauMax */
// cfg->transientInjectRange.t0 = uvar->dataStartGPS + uvar->injectWindow_t0Days * DAY24;
cfg->transientSearchRange = cfg->transientInjectRange;
return XLAL_SUCCESS;
} /* XLALInitCode() */
/** Initialize Fstat-code: handle user-input and set everything up. */
int
XLALInitCode ( ConfigVariables *cfg, const UserInput_t *uvar )
{
/* generate log-string for file-output, containing cmdline-options + code VCS version info */
char *vcs;
if ( (vcs = XLALGetVersionString(0)) == NULL ) { /* short VCS version string */
XLALPrintError ( "%s: XLALGetVersionString(0) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
char *cmdline;
if ( (cmdline = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) == NULL ) {
XLALPrintError ( "%s: XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE ) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
const char fmt[] = "%%%% cmdline: %s\n%%%%\n%s%%%%\n";
UINT4 len = strlen(vcs) + strlen(cmdline) + strlen(fmt) + 1;
if ( ( cfg->logString = XLALMalloc ( len )) == NULL ) {
XLALPrintError ("%s: XLALMalloc ( %d ) failed.\n", __func__, len );
XLAL_ERROR ( XLAL_ENOMEM );
}
sprintf ( cfg->logString, fmt, cmdline, vcs );
XLALFree ( cmdline );
XLALFree ( vcs );
/* trivial settings from user-input */
cfg->SignalOnly = uvar->SignalOnly;
/* ----- parse user-input on signal amplitude-paramters + ranges ----- */
/* skypos */
cfg->skypos.longitude = uvar->Alpha; /* Alpha < 0 indicates 'allsky' */
cfg->skypos.latitude = uvar->Delta;
cfg->skypos.system = COORDINATESYSTEM_EQUATORIAL;
/* ----- amplitude-params: create prior pdfs reflecting the user-input */
if ( XLALInitAmplitudePrior ( &cfg->AmpPrior, uvar ) != XLAL_SUCCESS )
XLAL_ERROR ( XLAL_EFUNC );
/* ----- initialize random-number generator ----- */
/* read out environment variables GSL_RNG_xxx
* GSL_RNG_SEED: use to set random seed: default = 0, override by using --randSeed on cmdline
* GSL_RNG_TYPE: type of random-number generator to use: default = 'mt19937'
*/
gsl_rng_env_setup ();
/* allow overriding the random-seed per command-line */
if ( XLALUserVarWasSet ( &uvar->randSeed ) )
gsl_rng_default_seed = uvar->randSeed;
cfg->rng = gsl_rng_alloc (gsl_rng_default);
LogPrintf ( LOG_DEBUG, "random-number generator type: %s\n", gsl_rng_name (cfg->rng));
LogPrintf ( LOG_DEBUG, "seed = %lu\n", gsl_rng_default_seed );
/* init ephemeris-data */
EphemerisData *edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun );
if ( !edat ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", __func__, uvar->ephemEarth, uvar->ephemSun);
XLAL_ERROR ( XLAL_EFUNC );
}
/* init detector info */
LALDetector *site;
if ( (site = XLALGetSiteInfo ( uvar->IFO )) == NULL ) {
XLALPrintError ("%s: Failed to get site-info for detector '%s'\n", __func__, uvar->IFO );
XLAL_ERROR ( XLAL_EFUNC );
}
MultiLALDetector multiDet;
multiDet.length = 1;
multiDet.sites[0] = (*site); /* copy! */
XLALFree ( site );
/* init timestamps vector covering observation time */
UINT4 numSteps = (UINT4) ceil ( uvar->dataDuration / uvar->TAtom );
MultiLIGOTimeGPSVector * multiTS;
if ( (multiTS = XLALCalloc ( 1, sizeof(*multiTS))) == NULL ) {
XLAL_ERROR ( XLAL_ENOMEM );
}
multiTS->length = 1;
if ( (multiTS->data = XLALCalloc (1, sizeof(*multiTS->data))) == NULL ) {
XLAL_ERROR ( XLAL_ENOMEM );
}
if ( (multiTS->data[0] = XLALCreateTimestampVector (numSteps)) == NULL ) {
XLALPrintError ("%s: XLALCreateTimestampVector(%d) failed.\n", __func__, numSteps );
}
multiTS->data[0]->deltaT = uvar->TAtom;
UINT4 i;
for ( i=0; i < numSteps; i ++ )
{
UINT4 ti = uvar->dataStartGPS + i * uvar->TAtom;
multiTS->data[0]->data[i].gpsSeconds = ti;
multiTS->data[0]->data[i].gpsNanoSeconds = 0;
}
/* get detector states */
if ( (cfg->multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiDet, edat, 0.5 * uvar->TAtom )) == NULL ) {
XLALPrintError ( "%s: XLALGetMultiDetectorStates() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* get rid of all temporary memory allocated for this step */
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiTimestamps ( multiTS );
multiTS = NULL;
/* ---------- initialize transient window ranges, for injection ... ---------- */
transientWindowRange_t XLAL_INIT_DECL(InjectRange);
int twtype;
XLAL_CHECK ( (twtype = XLALParseTransientWindowName ( uvar->injectWindow_type )) >= 0, XLAL_EFUNC );
InjectRange.type = twtype;
/* make sure user doesn't set window=none but sets window-parameters => indicates she didn't mean 'none' */
if ( InjectRange.type == TRANSIENT_NONE ) {
if ( XLALUserVarWasSet ( &uvar->injectWindow_t0Days ) || XLALUserVarWasSet ( &uvar->injectWindow_t0DaysBand ) ||
XLALUserVarWasSet ( &uvar->injectWindow_tauDays ) || XLALUserVarWasSet ( &uvar->injectWindow_tauDaysBand ) ) {
XLALPrintError ("%s: ERROR: injectWindow_type == NONE, but window-parameters were set! Use a different window-type!\n", __func__ );
XLAL_ERROR ( XLAL_EINVAL );
}
}
if ( uvar->injectWindow_t0DaysBand < 0 || uvar->injectWindow_tauDaysBand < 0 ) {
XLALPrintError ("%s: only positive t0/tau window injection bands allowed (%f, %f)\n", __func__, uvar->injectWindow_t0DaysBand, uvar->injectWindow_tauDaysBand );
XLAL_ERROR ( XLAL_EINVAL );
}
/* apply correct defaults if unset: t0=dataStart, t0Band=dataDuration-3*tauMax */
InjectRange.t0 = uvar->dataStartGPS + uvar->injectWindow_t0Days * DAY24;
REAL8 tauMax = ( uvar->injectWindow_tauDays + uvar->injectWindow_tauDaysBand ) * DAY24;
if ( XLALUserVarWasSet (&uvar->injectWindow_t0DaysBand ) )
InjectRange.t0Band = uvar->injectWindow_t0DaysBand * DAY24;
else
InjectRange.t0Band = fmax ( 0.0, uvar->dataDuration - TRANSIENT_EXP_EFOLDING * tauMax - InjectRange.t0 ); /* make sure it's >= 0 */
InjectRange.tau = (UINT4) ( uvar->injectWindow_tauDays * DAY24 );
InjectRange.tauBand = (UINT4) ( uvar->injectWindow_tauDaysBand * DAY24 );
cfg->transientInjectRange = InjectRange;
/* ---------- ... and for search -------------------- */
transientWindowRange_t XLAL_INIT_DECL(SearchRange);
XLAL_CHECK ( (twtype = XLALParseTransientWindowName ( uvar->searchWindow_type )) >= 0, XLAL_EFUNC );
SearchRange.type = twtype;
/* apply correct defaults if unset: use inect window */
if ( !XLALUserVarWasSet ( &uvar->searchWindow_type ) )
SearchRange.type = InjectRange.type;
if ( !XLALUserVarWasSet ( &uvar->searchWindow_t0Days ) )
SearchRange.t0 = InjectRange.t0;
else
SearchRange.t0 = uvar->dataStartGPS + uvar->searchWindow_t0Days * DAY24;
if ( !XLALUserVarWasSet ( &uvar->searchWindow_t0DaysBand ) )
SearchRange.t0Band = InjectRange.t0Band;
else
SearchRange.t0Band = (UINT4) (uvar->searchWindow_t0DaysBand * DAY24);
if ( !XLALUserVarWasSet ( &uvar->searchWindow_tauDays ) )
SearchRange.tau = InjectRange.tau;
else
SearchRange.tau = (UINT4) ( uvar->searchWindow_tauDays * DAY24 );
if ( !XLALUserVarWasSet ( &uvar->searchWindow_tauDaysBand ) )
SearchRange.tauBand = InjectRange.tauBand;
else
SearchRange.tauBand = (UINT4) ( uvar->searchWindow_tauDaysBand * DAY24 );
if ( XLALUserVarWasSet ( &uvar->searchWindow_dt0 ) )
SearchRange.dt0 = uvar->searchWindow_dt0;
else
SearchRange.dt0 = uvar->TAtom;
if ( XLALUserVarWasSet ( &uvar->searchWindow_dtau ) )
SearchRange.dtau = uvar->searchWindow_dtau;
else
SearchRange.dtau = uvar->TAtom;
/* make sure user doesn't set window=none but sets window-parameters => indicates she didn't mean 'none' */
if ( SearchRange.type == TRANSIENT_NONE )
if ( XLALUserVarWasSet ( &uvar->searchWindow_t0Days ) || XLALUserVarWasSet ( &uvar->searchWindow_t0DaysBand ) ||
XLALUserVarWasSet ( &uvar->searchWindow_tauDays ) || XLALUserVarWasSet ( &uvar->searchWindow_tauDaysBand ) ) {
XLALPrintError ("%s: ERROR: searchWindow_type == NONE, but window-parameters were set! Use a different window-type!\n", __func__ );
XLAL_ERROR ( XLAL_EINVAL );
}
if ( uvar->searchWindow_t0DaysBand < 0 || uvar->searchWindow_tauDaysBand < 0 ) {
XLALPrintError ("%s: only positive t0/tau window injection bands allowed (%f, %f)\n", __func__, uvar->searchWindow_t0DaysBand, uvar->searchWindow_tauDaysBand );
XLAL_ERROR ( XLAL_EINVAL );
}
cfg->transientSearchRange = SearchRange;
return XLAL_SUCCESS;
} /* XLALInitCode() */
/** The main function of binary2sft.c
*
*/
int main( int argc, char *argv[] ) {
UserInput_t uvar = empty_UserInput; /* user input variables */
INT4 i,j; /* counter */
SFTVector *SFTvect = NULL;
char *noisestr = XLALCalloc(1,sizeof(char));
/**********************************************************************************/
/* register and read all user-variables */
if (XLALReadUserVars(argc,argv,&uvar)) {
LogPrintf(LOG_CRITICAL,"%s : XLALReadUserVars() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_DEBUG,"%s : read in uservars\n",__func__);
/**********************************************************************************/
/* read in the cache file */
FILE *cachefp = NULL;
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
i = 0;
while (fscanf(cachefp,"%*s %*d %*d")!=EOF) i++;
INT4 Nfiles = i;
fclose(cachefp);
LogPrintf(LOG_DEBUG,"%s : counted %d files listed in the cache file.\n",__func__,Nfiles);
/* allocate memory */
char **filenames = LALCalloc(Nfiles,sizeof(char*));
LIGOTimeGPSVector fileStart;
fileStart.data = LALCalloc(Nfiles,sizeof(LIGOTimeGPS));
for (i=0;i<Nfiles;i++) filenames[i] = LALCalloc(512,sizeof(char));
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
for (i=0;i<Nfiles;i++) {
fscanf(cachefp,"%s %d %d %*d",filenames[i],&(fileStart.data[i].gpsSeconds),&(fileStart.data[i].gpsNanoSeconds));
}
fclose(cachefp);
/* initialise the random number generator */
gsl_rng * r;
if (XLALInitgslrand(&r,uvar.seed)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
/* setup the binaryToSFT parameters */
BinaryToSFTparams par;
par.tsft = uvar.tsft;
par.freq = uvar.freq;
par.freqband = uvar.freqband;
par.tsamp = uvar.tsamp;
par.highpassf = uvar.highpassf;
par.amp_inj = uvar.amp_inj;
par.f_inj = uvar.f_inj;
par.asini_inj = uvar.asini_inj;
XLALGPSSetREAL8(&(par.tasc_inj),uvar.tasc_inj);
par.tref = fileStart.data[0];
par.P_inj = uvar.P_inj;
par.phi_inj = uvar.phi_inj;
par.r = r;
/**********************************************************************************/
/* loop over the input files */
long int ntot = 0;
for (j=0;j<Nfiles;j++) {
UINT4 k = 0;
INT8Vector *np = NULL;
REAL8Vector *R = NULL;
par.tstart = fileStart.data[j];
REAL8 norm1 = par.tsamp/par.tsft;
REAL8 norm2 = 1.0/(par.tsamp*par.tsft);
UINT4 oldlen;
if (SFTvect==NULL) oldlen = 0;
else oldlen = SFTvect->length;
LogPrintf(LOG_DEBUG,"%s : working on file %s\n",__func__,filenames[j]);
if (XLALBinaryToSFTVector(&SFTvect,filenames[j],&(fileStart.data[j]),&par,&np,&R)) {
LogPrintf(LOG_CRITICAL,"%s : failed to convert binary input file %s to sfts\n",__func__,filenames[j]);
return 1;
}
if ((np!=NULL) && (R!=NULL)) {
for (k=0;k<np->length;k++) {
ntot += np->data[k];
char temp[64];
sprintf(temp,"%d %e %e\n",SFTvect->data[oldlen+k].epoch.gpsSeconds,(REAL8)np->data[k]*norm1,R->data[k]*norm2);
noisestr = (char *)XLALRealloc(noisestr,sizeof(char)*(1+strlen(noisestr)+strlen(temp)));
strcat(noisestr,temp);
}
XLALDestroyINT8Vector(np);
XLALDestroyREAL8Vector(R);
}
} /* end loop over input files */
/**********************************************************************************/
/* create a noise string */
/**********************************************************************************/
/* generate comment string */
char *VCSInfoString = XLALGetVersionString(0);
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
CHAR *logstr;
size_t len;
XLAL_CHECK ( (logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) != NULL, XLAL_EFUNC );
char *comment = XLALCalloc ( 1, len = strlen ( logstr ) + strlen(VCSInfoString) + strlen(noisestr) + 512 );
XLAL_CHECK ( comment != NULL, XLAL_ENOMEM, "XLALCalloc(1,%zd) failed.\n", len );
sprintf ( comment, "Generated by:\n%s\n%s\nTotal number of photons = %ld\n%s\n", logstr, VCSInfoString, ntot, noisestr );
/**********************************************************************************/
/* either write whole SFT-vector to single concatenated file */
if ( uvar.outSingleSFT ) {
XLAL_CHECK ( XLALWriteSFTVector2File( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
} else { /* or as individual SFT-files */
XLAL_CHECK ( XLALWriteSFTVector2Dir( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
}
/**********************************************************************************/
/* free memory */
XLALDestroySFTVector(SFTvect);
XLALFree(logstr);
XLALFree(comment);
XLALFree(noisestr);
LALCheckMemoryLeaks();
return 0;
}
/**
* basic initializations: set-up 'ConfigVariables'
*/
int
XLALInitCode ( ConfigVariables *cfg, const UserVariables_t *uvar, const char *app_name)
{
if ( !cfg || !uvar || !app_name ) {
LogPrintf (LOG_CRITICAL, "%s: illegal NULL pointer input.\n\n", __func__ );
XLAL_ERROR (XLAL_EINVAL );
}
/* Init ephemerides */
XLAL_CHECK ( (cfg->edat = XLALInitBarycenter ( uvar->ephemEarth, uvar->ephemSun )) != NULL, XLAL_EFUNC );
// ----- figure out which segments to use
BOOLEAN manualSegments = XLALUserVarWasSet(&uvar->duration) || XLALUserVarWasSet(&uvar->startTime) || XLALUserVarWasSet(&uvar->Nseg);
if ( manualSegments && uvar->segmentList ) {
XLAL_ERROR ( XLAL_EDOM, "Can specify EITHER {--startTime, --duration, --Nseg} OR --segmentList\n");
}
LIGOTimeGPS startTimeGPS;
REAL8 duration;
if ( uvar->segmentList == NULL )
{
XLAL_CHECK ( uvar->Nseg >= 1, XLAL_EDOM, "Invalid input --Nseg=%d: number of segments must be >= 1\n", uvar->Nseg );
XLAL_CHECK ( uvar->duration >= 1, XLAL_EDOM, "Invalid input --duration=%f: duration must be >= 1 s\n", uvar->duration );
startTimeGPS = uvar->startTime;
int ret = XLALSegListInitSimpleSegments ( &cfg->segmentList, startTimeGPS, uvar->Nseg, uvar->duration / uvar->Nseg );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALSegListInitSimpleSegments() failed with xlalErrno = %d\n", xlalErrno );
duration = uvar->duration;
}
else
{
LALSegList *segList = XLALReadSegmentsFromFile ( uvar->segmentList );
XLAL_CHECK ( segList != NULL, XLAL_EIO, "XLALReadSegmentsFromFile() failed to load segment list from file '%s', xlalErrno = %d\n", uvar->segmentList, xlalErrno );
cfg->segmentList = (*segList); // copy *contents*
XLALFree ( segList );
startTimeGPS = cfg->segmentList.segs[0].start;
UINT4 Nseg = cfg->segmentList.length;
LIGOTimeGPS endTimeGPS = cfg->segmentList.segs[Nseg-1].end;
duration = XLALGPSDiff( &endTimeGPS, &startTimeGPS );
}
/* ----- figure out reference time */
LIGOTimeGPS refTimeGPS;
/* treat special values first */
if ( uvar->refTime.gpsSeconds == 0 ) /* 0 = use startTime */
{
refTimeGPS = uvar->startTime;
}
else if ( !XLALUserVarWasSet ( &uvar->refTime ) ) /* default = use mid-time of observation */
{
refTimeGPS = startTimeGPS;
XLALGPSAdd( &refTimeGPS, duration / 2.0 );
}
else
{
refTimeGPS = uvar->refTime;
}
/* ----- get parameter-space point from user-input) */
cfg->signalParams.Amp.h0 = uvar->h0;
cfg->signalParams.Amp.cosi = uvar->cosi;
cfg->signalParams.Amp.psi = uvar->psi;
cfg->signalParams.Amp.phi0 = uvar->phi0;
{
PulsarDopplerParams *dop = &(cfg->signalParams.Doppler);
XLAL_INIT_MEM((*dop));
dop->refTime = refTimeGPS;
dop->Alpha = uvar->Alpha;
dop->Delta = uvar->Delta;
dop->fkdot[0] = uvar->Freq;
dop->fkdot[1] = uvar->f1dot;
dop->fkdot[2] = uvar->f2dot;
dop->fkdot[3] = uvar->f3dot;
dop->asini = uvar->orbitasini;
dop->period = uvar->orbitPeriod;
dop->tp = uvar->orbitTp;
dop->ecc = uvar->orbitEcc;
dop->argp = uvar->orbitArgp;
}
/* ----- initialize IFOs and (Multi-)DetectorStateSeries ----- */
XLAL_CHECK ( XLALParseMultiLALDetector ( &cfg->multiIFO, uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numDet = cfg->multiIFO.length;
XLAL_CHECK ( numDet >= 1, XLAL_EINVAL );
if ( uvar->sqrtSX ) {
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &cfg->multiNoiseFloor, uvar->sqrtSX, numDet ) == XLAL_SUCCESS, XLAL_EFUNC );
}
/* ---------- translate coordinate system into internal representation ---------- */
if ( XLALDopplerCoordinateNames2System ( &cfg->coordSys, uvar->coords ) ) {
LogPrintf (LOG_CRITICAL, "%s: Call to XLALDopplerCoordinateNames2System() failed. errno = %d\n\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ---------- record full 'history' up to and including this application ---------- */
{
CHAR *cmdline = NULL;
CHAR *tmp;
size_t len = strlen ( app_name ) + 1;
if ( (cfg->history = XLALCalloc ( 1, sizeof(*cfg->history))) == NULL ) {
LogPrintf (LOG_CRITICAL, "%s: XLALCalloc(1,%zu) failed.\n\n", __func__, sizeof(*cfg->history));
XLAL_ERROR ( XLAL_ENOMEM );
}
if ( (tmp = XLALMalloc ( len )) == NULL ) {
LogPrintf (LOG_CRITICAL, "%s: XLALMalloc (%zu) failed.\n\n", __func__, len );
XLAL_ERROR ( XLAL_ENOMEM );
}
strcpy ( tmp, app_name );
cfg->history->app_name = tmp;
/* get commandline describing search*/
if ( (cmdline = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) == NULL ) {
LogPrintf (LOG_CRITICAL, "%s: XLALUserVarGetLog() failed with xlalErrno = %d.\n\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
cfg->history->cmdline = cmdline;
} /* record history */
return XLAL_SUCCESS;
} /* XLALInitCode() */
/**
* some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,
* but should be enough to catch big obvious malfunctions
*/
int
main(void)
{
int i, my_argc = 8;
char **my_argv;
const char *argv_in[] = { "progname", "--argNum=1", "--argStr=xyz", "--argBool=true", "-a", "1", "-b", "@" TEST_DATA_DIR "ConfigFileSample.cfg" };
UserInput_t XLAL_INIT_DECL(my_uvars);
my_argv = XLALCalloc ( my_argc, sizeof(char*) );
for (i=0; i < my_argc; i ++ )
{
my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);
strcpy ( my_argv[i], argv_in[i] );
}
/* ---------- Register all test user-variables ---------- */
UserInput_t *uvar = &my_uvars;
uvar->string2 = XLALStringDuplicate ( "this is the default value");
XLAL_CHECK ( XLALRegisterUvarMember( argNum, REAL8, 0, REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argStr, STRING, 0, REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argBool, BOOLEAN, 0, REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argInt, INT4, 'a', REQUIRED, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( dummy, INT4, 'c', OPTIONAL, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argB2, BOOLEAN, 'b', REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( string2, STRING, 0, REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( epochGPS, EPOCH, 0, REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( epochMJDTT, EPOCH, 0, REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longHMS, RAJ, 0, REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longRad, RAJ, 0, REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( latDMS, DECJ, 0, REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( latRad, DECJ, 0, REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longInt, INT8, 0, REQUIRED, "Testing INT8 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( long_help, BOOLEAN, 0, NODEFAULT,
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"\n"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces."
) == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- now read all input from commandline and config-file ---------- */
BOOLEAN should_exit = 0;
XLAL_CHECK ( XLALUserVarReadAllInput ( &should_exit, my_argc, my_argv ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( should_exit == 0, XLAL_EFUNC );
/* ---------- test print usage and help page */
printf( "=== Begin usage string ===\n" );
fflush( stdout );
XLALUserVarPrintUsage( stdout );
printf( "--- End usage string ---\n" );
printf( "=== Begin help page ===\n" );
fflush( stdout );
XLALUserVarPrintHelp( stdout );
printf( "--- End help page ---\n" );
fflush( stdout );
/* ---------- test log-generation */
CHAR *logstr;
XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE )) != NULL, XLAL_EFUNC );
XLALFree ( logstr );
/* ---------- test values were read in correctly ---------- */
XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );
XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );
XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );
XLAL_CHECK ( uvar->argInt == 1, XLAL_EFAILED, "Failed to read in argInt\n" );
XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );
XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );
char buf1[256], buf2[256];
XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",
XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );
REAL8 diff, tol = 3e-15;
XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > %g\n", uvar->longHMS, uvar->longRad, diff, tol );
XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > %g\n", uvar->latDMS, uvar->latRad, diff, tol );
XLAL_CHECK ( uvar->longInt == 4294967294, XLAL_EFAILED, "Failed to read an INT8: longInt = %" LAL_INT8_FORMAT " != 4294967294", uvar->longInt );
/* ----- cleanup ---------- */
XLALDestroyUserVars();
for (i=0; i < my_argc; i ++ ) {
XLALFree ( my_argv[i] );
}
XLALFree ( my_argv );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
size_t len;
ConfigVars_t XLAL_INIT_DECL(GV);
UserVariables_t XLAL_INIT_DECL(uvar);
/* ------------------------------
* read user-input and set up shop
*------------------------------*/
XLAL_CHECK ( XLALInitUserVars ( &uvar, argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALInitMakefakedata ( &GV, &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
MultiSFTVector *mSFTs = NULL;
MultiREAL8TimeSeries *mTseries = NULL;
PulsarParamsVector *injectionSources = NULL;
if ( uvar.injectionSources ) {
XLAL_CHECK ( (injectionSources = XLALPulsarParamsFromUserInput ( uvar.injectionSources, NULL ) ) != NULL, XLAL_EFUNC );
}
CWMFDataParams XLAL_INIT_DECL(DataParams);
DataParams.multiIFO = GV.multiIFO;
DataParams.multiNoiseFloor = GV.multiNoiseFloor;
DataParams.multiTimestamps = (*GV.multiTimestamps);
DataParams.randSeed = uvar.randSeed;
DataParams.SFTWindowType = uvar.SFTWindowType;
DataParams.SFTWindowBeta = uvar.SFTWindowBeta;
if ( GV.inputMultiTS == NULL )
{
DataParams.fMin = uvar.fmin;
DataParams.Band = uvar.Band;
DataParams.inputMultiTS = NULL;
}
else // current limitation: FIXME
{
DataParams.fMin = 0;
DataParams.Band = 0;
DataParams.inputMultiTS = GV.inputMultiTS;
}
XLAL_CHECK ( XLALCWMakeFakeMultiData ( &mSFTs, &mTseries, injectionSources, &DataParams, GV.edat ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyPulsarParamsVector ( injectionSources );
injectionSources = NULL;
// if noiseSFTs specified, load them and add them to the resulting SFT-vector
if ( GV.multiNoiseCatalogView )
{
SFTtype *sft0 = &(mSFTs->data[0]->data[0]);
/* load effective frequency-band from noise-SFTs */
UINT4 numBins = sft0->data->length;
REAL8 dFreq = sft0->deltaF;
REAL8 fMin = sft0->f0;
REAL8 fMax = fMin + ( numBins - 1 ) * dFreq;
MultiSFTVector *mNoiseSFTs;
XLAL_CHECK ( (mNoiseSFTs = XLALLoadMultiSFTsFromView ( GV.multiNoiseCatalogView, fMin, fMax )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( XLALMultiSFTVectorAdd ( mSFTs, mNoiseSFTs ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyMultiSFTVector ( mNoiseSFTs );
}
if (uvar.outSFTdir)
{
XLAL_CHECK ( is_directory ( uvar.outSFTdir ), XLAL_EINVAL );
/* generate comment string */
CHAR *logstr;
XLAL_CHECK ( (logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) != NULL, XLAL_EFUNC );
char *comment = XLALCalloc ( 1, len = strlen ( logstr ) + strlen(GV.VCSInfoString) + 512 );
XLAL_CHECK ( comment != NULL, XLAL_ENOMEM, "XLALCalloc(1,%zu) failed.\n", len );
sprintf ( comment, "Generated by:\n%s\n%s\n", logstr, GV.VCSInfoString );
for ( UINT4 X=0; X < mSFTs->length; X ++ )
{
SFTVector *sfts = mSFTs->data[X];
/* either write whole SFT-vector to single concatenated file */
if ( uvar.outSingleSFT ) {
XLAL_CHECK ( XLALWriteSFTVector2File( sfts, uvar.outSFTdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
} else { // or as individual SFT-files
XLAL_CHECK ( XLALWriteSFTVector2Dir( sfts, uvar.outSFTdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
}
} // for X < numIFOs
XLALFree ( logstr );
XLALFree ( comment );
} /* if outSFTdir */
/* output ASCII time-series if requested */
if ( uvar.TDDfile )
{
CHAR *fname = XLALCalloc (1, len = strlen(uvar.TDDfile) + 10 );
XLAL_CHECK ( fname != NULL, XLAL_ENOMEM, "XLALCalloc(1,%zu) failed\n", len );
for ( UINT4 X=0; X < mTseries->length; X ++ )
{
const REAL8TimeSeries *TS = mTseries->data[X];
sprintf (fname, "%c%c-%s", TS->name[0], TS->name[1], uvar.TDDfile );
XLAL_CHECK ( XLALdumpREAL8TimeSeries ( fname, TS ) == XLAL_SUCCESS, XLAL_EFUNC );
} // for X < numDet
XLALFree (fname);
} /* if outputting ASCII time-series */
/* output time-series to frames if requested */
#ifdef HAVE_LIBLALFRAME
if ( GV.outFrameDir != NULL )
{
XLAL_CHECK ( XLALCheckValidDescriptionField ( uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
len = strlen(GV.outFrameDir) + strlen(uvar.outLabel) + 100;
char *fname;
char *hist = XLALUserVarGetLog (UVAR_LOGFMT_CMDLINE);
if ( XLALUserVarWasSet ( &uvar.outFrChannels ) ) {
XLAL_CHECK ( uvar.outFrChannels->length == mTseries->length, XLAL_EINVAL, "--outFrChannels: number of channel names (%d) must agree with number of IFOs (%d)\n",
uvar.outFrChannels->length, mTseries->length );
}
for ( UINT4 X=0; X < mTseries->length; X ++ )
{
REAL8TimeSeries *Tseries = mTseries->data[X];
/* use standard frame output filename format */
char IFO[2] = { Tseries->name[0], Tseries->name[1] };
LIGOTimeGPS startTimeGPS = Tseries->epoch;
REAL8 duration = Tseries->data->length * Tseries->deltaT;
XLAL_CHECK ( (fname = LALCalloc (1, len )) != NULL, XLAL_ENOMEM );
size_t written = snprintf ( fname, len, "%s/%c-%c%c_%s-%d-%d.gwf",
GV.outFrameDir, IFO[0], IFO[0], IFO[1], uvar.outLabel, startTimeGPS.gpsSeconds, (int)duration );
XLAL_CHECK ( written < len, XLAL_ESIZE, "Frame-filename exceeds expected maximal length (%zu): '%s'\n", len, fname );
/* define the output frame */
LALFrameH *outFrame;
XLAL_CHECK ( (outFrame = XLALFrameNew ( &startTimeGPS, duration, uvar.outLabel, 1, 0, 0 )) != NULL, XLAL_EFUNC );
/* add timeseries to the frame - make sure to change the timeseries name since this is used as the channel name */
char buffer[LALNameLength];
// if output frame channel names given, use those
if ( XLALUserVarWasSet ( &uvar.outFrChannels ) ) {
written = snprintf ( buffer, sizeof(buffer), "%s", uvar.outFrChannels->data[X] );
if ( buffer[2] == ':' ) { // check we got correct IFO association
XLAL_CHECK ( (buffer[0] == Tseries->name[0]) && (buffer[1] == Tseries->name[1]), XLAL_EINVAL,
"Possible IFO mismatch: outFrChannel[%d] = '%s', IFO = '%c%c': be careful about --outFrChannel ordering\n", X, buffer, Tseries->name[0], Tseries->name[1] );
} // if buffer[2]==':'
} else if ( XLALUserVarWasSet ( &uvar.inFrChannels ) ) { // otherwise: if input frame channel names given, use them for output, append "-<outLabel>"
written = snprintf ( buffer, sizeof(buffer), "%s-%s", uvar.inFrChannels->data[X], uvar.outLabel );
} else { // otherwise: fall back to <IFO>:<outLabel> channel name
written = snprintf ( buffer, sizeof(buffer), "%c%c:%s", Tseries->name[0], Tseries->name[1], uvar.outLabel );
}
XLAL_CHECK ( written < LALNameLength, XLAL_ESIZE, "Output frame name exceeded max length (%d): '%s'\n", LALNameLength, buffer );
strcpy ( Tseries->name, buffer );
XLAL_CHECK ( (XLALFrameAddREAL8TimeSeriesProcData ( outFrame, Tseries ) == XLAL_SUCCESS ) , XLAL_EFUNC );
/* Here's where we add extra information into the frame - first we add the command line args used to generate it */
XLALFrameAddFrHistory ( outFrame, __FILE__, hist );
/* then we add the version string */
XLALFrameAddFrHistory ( outFrame, __FILE__, GV.VCSInfoString );
/* output the frame to file - compression level 1 (higher values make no difference) */
XLAL_CHECK ( XLALFrameWrite ( outFrame, fname ) == XLAL_SUCCESS , XLAL_EFUNC );
/* free the frame, frame file name and history memory */
XLALFrameFree ( outFrame );
XLALFree ( fname );
} // for X < numDetectors
XLALFree ( hist );
} /* if GV.outFrameDir: outputting time-series to frames */
#endif // HAVE_LIBLALFRAME
/* ---------- free memory ---------- */
XLALDestroyMultiREAL8TimeSeries ( mTseries );
XLALDestroyMultiSFTVector ( mSFTs );
XLALFreeMem ( &GV ); /* free the config-struct */
LALCheckMemoryLeaks();
return 0;
} /* main */
/**
* some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,
* but should be enough to catch big obvious malfunctions
*/
int
main(int argc, char *argv[])
{
int i, my_argc = 8;
char **my_argv;
const char *argv_in[] = { "progname", "--argNum=1", "--argStr=xyz", "--argBool=true", "-a", "1", "-b", "@" TEST_DATA_DIR "ConfigFileSample.cfg" };
UserInput_t XLAL_INIT_DECL(my_uvars);
XLAL_CHECK ( argc == 1, XLAL_EINVAL, "No input arguments allowed.\n");
my_argv = XLALCalloc ( my_argc, sizeof(char*) );
for (i=0; i < my_argc; i ++ )
{
my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);
strcpy ( my_argv[i], argv_in[i] );
}
/* ---------- Register all test user-variables ---------- */
UserInput_t *uvar = &my_uvars;
XLAL_CHECK ( XLALregREALUserStruct( argNum, 0, UVAR_REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregSTRINGUserStruct( argStr, 0, UVAR_REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregBOOLUserStruct( argBool, 0, UVAR_REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregINTUserStruct( argInt, 'a', UVAR_REQUIRED, "Testing INT argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregINTUserStruct( dummy, 'c', UVAR_OPTIONAL, "Testing INT argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregBOOLUserStruct( argB2, 'b', UVAR_REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregSTRINGUserStruct( string2, 0, UVAR_REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregEPOCHUserStruct( epochGPS, 0, UVAR_REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregEPOCHUserStruct( epochMJDTT, 0, UVAR_REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregRAJUserStruct( longHMS, 0, UVAR_REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregRAJUserStruct( longRad, 0, UVAR_REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregDECJUserStruct( latDMS, 0, UVAR_REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregDECJUserStruct( latRad, 0, UVAR_REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- now read all input from commandline and config-file ---------- */
XLAL_CHECK ( XLALUserVarReadAllInput ( my_argc, my_argv ) == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- test help-string generation */
CHAR *helpstr;
XLAL_CHECK ( (helpstr = XLALUserVarHelpString ( argv[0])) != NULL, XLAL_EFUNC );
XLALFree ( helpstr );
/* ---------- test log-generation */
CHAR *logstr;
XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE )) != NULL, XLAL_EFUNC );
XLALFree ( logstr );
/* ---------- test values were read in correctly ---------- */
XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );
XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );
XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );
XLAL_CHECK ( uvar->argInt == 1, XLAL_EFAILED, "Failed to read in argInt\n" );
XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );
XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );
char buf1[256], buf2[256];
XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",
XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );
REAL8 diff, tol = 3e-15;
XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > tolerance\n", uvar->longHMS, uvar->longRad, diff, tol );
XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > tolerance\n", uvar->latDMS, uvar->latRad, diff, tol );
/* ----- cleanup ---------- */
XLALDestroyUserVars();
for (i=0; i < my_argc; i ++ ) {
XLALFree ( my_argv[i] );
}
XLALFree ( my_argv );
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 REAL8Vector foft;
static PulsarSignalParams params;
static SFTParams sftParams;
static UCHARPeakGram pg1;
static COMPLEX8SFTData1 sft1;
static REAL8PeriodoPSD periPSD;
REAL4TimeSeries *signalTseries = NULL;
SFTVector *inputSFTs = NULL;
SFTVector *outputSFTs = NULL;
/* data about injected signal */
static PulsarData pulsarInject;
/* the template */
static HoughTemplate pulsarTemplate, pulsarTemplate1;
/*FILE *fpOUT = NULL; output file pointer */
FILE *fpLog = NULL; /* log file pointer */
CHAR *logstr=NULL; /* log string containing user input variables */
CHAR *fnamelog=NULL; /* name of log file */
INT4 nfSizeCylinder;
EphemerisData *edat = NULL;
INT4 mObsCoh, numberCount;
REAL8 sftBand;
REAL8 timeBase, deltaF, normalizeThr, threshold;
UINT4 sftlength;
INT4 sftFminBin;
REAL8 fHeterodyne;
REAL8 tSamplingRate;
/* grid spacings */
REAL8 deltaTheta;
INT4 mmP, mmT; /* for loop over mismatched templates */
/* user input variables */
INT4 uvar_ifo, uvar_blocksRngMed;
REAL8 uvar_peakThreshold;
REAL8 uvar_alpha, uvar_delta, uvar_h0, uvar_f0;
REAL8 uvar_psi, uvar_phi0, uvar_fdot, uvar_cosiota;
CHAR *uvar_earthEphemeris=NULL;
CHAR *uvar_sunEphemeris=NULL;
CHAR *uvar_sftDir=NULL;
CHAR *uvar_fnameout=NULL;
/* set up the default parameters */
nfSizeCylinder = NFSIZE;
/* set other user input variables */
uvar_peakThreshold = THRESHOLD;
uvar_ifo = IFO;
uvar_blocksRngMed = BLOCKSRNGMED;
/* set default pulsar parameters */
uvar_h0 = H0;
uvar_alpha = ALPHA;
uvar_delta = DELTA;
uvar_f0 = F0;
uvar_fdot = FDOT;
uvar_psi = PSI;
uvar_cosiota = COSIOTA;
uvar_phi0 = PHI0;
/* now set the default filenames */
uvar_earthEphemeris = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
uvar_fnameout = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_fnameout, FILEOUT);
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", INT4, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == 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);
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_fnameout, "fnameout", STRING, 'o', OPTIONAL, "Output file prefix") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_alpha, "alpha", REAL8, 'r', OPTIONAL, "Right ascension") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_delta, "delta", REAL8, 'l', OPTIONAL, "Declination") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_h0, "h0", REAL8, 'm', OPTIONAL, "h0 to inject") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_f0, "f0", REAL8, 'f', OPTIONAL, "Start search frequency") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_psi, "psi", REAL8, 'p', OPTIONAL, "Polarization angle") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_phi0, "phi0", REAL8, 'P', OPTIONAL, "Initial phase") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_cosiota, "cosiota", REAL8, 'c', OPTIONAL, "Cosine of iota") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fdot, "fdot", REAL8, 'd', OPTIONAL, "Spindown parameter") == 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);
/* write the log file */
fnamelog = (CHAR *)LALMalloc( 512*sizeof(CHAR));
strcpy(fnamelog, uvar_fnameout);
strcat(fnamelog, "_log");
/* open the log file for writing */
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 HoughMismatch\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);
}
/* set peak selection threshold */
SUB( LALRngMedBias( &status, &normalizeThr, uvar_blocksRngMed ), &status );
threshold = uvar_peakThreshold/normalizeThr;
/* set detector */
if (uvar_ifo ==1) detector=lalCachedDetectors[LALDetectorIndexGEO600DIFF];
if (uvar_ifo ==2) detector=lalCachedDetectors[LALDetectorIndexLLODIFF];
if (uvar_ifo ==3) detector=lalCachedDetectors[LALDetectorIndexLHODIFF];
/* copy user input values */
pulsarInject.f0 = uvar_f0;
pulsarInject.latitude = uvar_delta;
pulsarInject.longitude = uvar_alpha;
pulsarInject.aPlus = 0.5 * uvar_h0 * ( 1.0 + uvar_cosiota * uvar_cosiota );
pulsarInject.aCross = uvar_h0 * uvar_cosiota;
pulsarInject.psi = uvar_psi;
pulsarInject.phi0 = uvar_phi0;
pulsarInject.spindown.length = 1;
pulsarInject.spindown.data = NULL;
pulsarInject.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8));
pulsarInject.spindown.data[0] = uvar_fdot;
/* copy these values also to the pulsar template */
/* template is complately matched at this point */
pulsarTemplate.f0 = uvar_f0;
pulsarTemplate.latitude = uvar_delta;
pulsarTemplate.longitude = uvar_alpha;
pulsarTemplate.spindown.length = 1;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8));
pulsarTemplate.spindown.data[0] = uvar_fdot;
/* allocate memory for mismatched spindown template */
pulsarTemplate1.spindown.length = 1;
pulsarTemplate1.spindown.data = NULL;
pulsarTemplate1.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8));
/* read sfts */
{
CHAR *tempDir;
tempDir = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
sftBand = 0.5;
SUB( LALReadSFTfiles ( &status, &inputSFTs, uvar_f0 - sftBand, uvar_f0 + sftBand, nfSizeCylinder + uvar_blocksRngMed , tempDir), &status);
LALFree(tempDir);
}
/* get sft parameters */
mObsCoh = inputSFTs->length;
sftlength = inputSFTs->data->data->length;
deltaF = inputSFTs->data->deltaF;
timeBase = 1.0/deltaF;
sftFminBin = floor( timeBase * inputSFTs->data->f0 + 0.5);
fHeterodyne = sftFminBin*deltaF;
tSamplingRate = 2.0*deltaF*(sftlength -1.);
/* create timestamp vector */
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
/* read timestamps */
{
INT4 i;
SFTtype *sft= NULL;
sft = inputSFTs->data;
for (i=0; i < mObsCoh; i++){
timeV.data[i].gpsSeconds = sft->epoch.gpsSeconds;
timeV.data[i].gpsNanoSeconds = sft->epoch.gpsNanoSeconds;
++sft;
}
}
/* compute the time difference relative to startTime for all SFT */
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
{
REAL8 t0, ts, tn, midTimeBase;
INT4 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 = 0.0; /* irrelevant */
velPar.edat = NULL;
/* read in ephemeris data */
XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC);
velPar.edat = edat;
/* calculate detector velocity */
for(j=0; j< velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
SUB( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
}
/* set grid spacings */
{
deltaTheta = 1.0 / ( VTOT * uvar_f0 * timeBase );
/* currently unused: REAL8 deltaFdot = deltaF / timeBase; */
}
/* allocate memory for f(t) pattern */
foft.length = mObsCoh;
foft.data = NULL;
foft.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
/* allocate memory for Hough peripsd structure */
periPSD.periodogram.length = sftlength;
periPSD.periodogram.data = NULL;
periPSD.periodogram.data = (REAL8 *)LALMalloc(sftlength* sizeof(REAL8));
periPSD.psd.length = sftlength;
periPSD.psd.data = NULL;
periPSD.psd.data = (REAL8 *)LALMalloc(sftlength* sizeof(REAL8));
/* allocate memory for peakgram */
pg1.length = sftlength;
pg1.data = NULL;
pg1.data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR));
/* generate signal and add to input sfts */
/* parameters for output sfts */
sftParams.Tsft = timeBase;
sftParams.timestamps = &(timeV);
sftParams.noiseSFTs = inputSFTs;
/* signal generation parameters */
params.orbit.asini = 0 /* isolated pulsar */;
/* params.transferFunction = NULL; */
params.site = &(detector);
params.ephemerides = edat;
params.startTimeGPS.gpsSeconds = timeV.data[0].gpsSeconds; /* start time of output time series */
params.startTimeGPS.gpsNanoSeconds = timeV.data[0].gpsNanoSeconds; /* start time of output time series */
params.duration = timeDiffV.data[mObsCoh-1] + 0.5 * timeBase; /* length of time series in seconds */
params.samplingRate = tSamplingRate;
params.fHeterodyne = fHeterodyne;
/* reference time for frequency and spindown is first timestamp */
params.pulsar.refTime.gpsSeconds = timeV.data[0].gpsSeconds;
params.pulsar.refTime.gpsNanoSeconds = timeV.data[0].gpsNanoSeconds;
params.pulsar.position.longitude = pulsarInject.longitude;
params.pulsar.position.latitude = pulsarInject.latitude ;
params.pulsar.position.system = COORDINATESYSTEM_EQUATORIAL;
params.pulsar.psi = pulsarInject.psi;
params.pulsar.aPlus = pulsarInject.aPlus;
params.pulsar.aCross = pulsarInject.aCross;
params.pulsar.phi0 = pulsarInject.phi0;
params.pulsar.f0 = pulsarInject.f0;
params.pulsar.spindown = &pulsarInject.spindown ;
SUB( LALGeneratePulsarSignal(&status, &signalTseries, ¶ms ), &status);
SUB( LALSignalToSFTs(&status, &outputSFTs, signalTseries, &sftParams), &status);
/* fill in elements of sft structure sft1 used in peak selection */
sft1.length = sftlength;
sft1.fminBinIndex = sftFminBin;
sft1.timeBase = timeBase;
/* loop over mismatched templates */
for (mmT = -2; mmT <= 2; mmT++)
{
for (mmP = -2; mmP <= 2; mmP++)
{
INT4 mmFactor;
/* displace the template */
mmFactor = 1.0;
pulsarTemplate1.f0 = pulsarTemplate.f0 /*+ mmFactor * mm * deltaF*/;
pulsarTemplate1.latitude = pulsarTemplate.latitude + mmFactor * mmT * deltaTheta;
pulsarTemplate1.longitude = pulsarTemplate.longitude + mmFactor * mmP * deltaTheta;
pulsarTemplate1.spindown.data[0] = pulsarTemplate.spindown.data[0] /*+ mmFactor * mm * deltaFdot*/;
numberCount = 0;
/* now calculate the number count for the template */
INT4 j;
for (j=0; j < mObsCoh; j++)
{
INT4 ind;
sft1.epoch.gpsSeconds = timeV.data[j].gpsSeconds;
sft1.epoch.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
sft1.data = outputSFTs->data[j].data->data;
SUB( COMPLEX8SFT2Periodogram1(&status, &periPSD.periodogram, &sft1), &status );
SUB( LALPeriodo2PSDrng( &status,
&periPSD.psd, &periPSD.periodogram, &uvar_blocksRngMed), &status );
SUB( LALSelectPeakColorNoise(&status,&pg1,&threshold,&periPSD), &status);
SUB( ComputeFoft(&status, &foft, &pulsarTemplate1, &timeDiffV, &velV, timeBase), &status);
ind = floor( foft.data[j]*timeBase - sftFminBin + 0.5);
numberCount += pg1.data[ind];
}
/* print the number count */
fprintf(stdout, "%d %d %d\n", mmT, mmP, numberCount);
}
}
/* free structures created by signal generation routines */
LALFree(signalTseries->data->data);
LALFree(signalTseries->data);
LALFree(signalTseries);
signalTseries =NULL;
XLALDestroySFTVector( outputSFTs);
/* destroy input sfts */
XLALDestroySFTVector( inputSFTs);
/* free other structures */
LALFree(foft.data);
LALFree(pulsarInject.spindown.data);
LALFree(pulsarTemplate.spindown.data);
LALFree(pulsarTemplate1.spindown.data);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(velV.data);
XLALDestroyEphemerisData(edat);
LALFree(periPSD.periodogram.data);
LALFree(periPSD.psd.data);
LALFree(pg1.data);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
INFO( DRIVEHOUGHCOLOR_MSGENORM );
return DRIVEHOUGHCOLOR_ENORM;
}
