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;
}
/**
* Unit-Test for function XLALSFTVectorToLFT().
* Generates random data (timeseries + corresponding SFTs),
* then feeds the SFTs into XLALSFTVectorToLFT()
* and checks correctness of output Fourier transform by
* comparing to FT of original real-valued timeseries.
*
* \note This indirectly also checks XLALSFTVectorToCOMPLEX8TimeSeries()
* which is used by XLALSFTVectorToLFT().
*
* returns XLAL_SUCCESS on success, XLAL-error otherwise
*/
int
test_XLALSFTVectorToLFT ( void )
{
// ----- generate real-valued random timeseries and corresponding SFTs
REAL4TimeSeries *tsR4 = NULL;
SFTVector *sfts0 = NULL;
XLAL_CHECK ( XLALgenerateRandomData ( &tsR4, &sfts0 ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numSamplesR4 = tsR4->data->length;
REAL8 dt_R4 = tsR4->deltaT;
REAL8 TspanR4 = numSamplesR4 * dt_R4;
// ----- consider only the frequency band [3Hz, 4Hz]
REAL8 out_fMin = 3;
REAL8 out_Band = 1;
SFTVector *sftsBand;
XLAL_CHECK ( (sftsBand = XLALExtractBandFromSFTVector ( sfts0, out_fMin, out_Band )) != NULL, XLAL_EFUNC );
XLALDestroySFTVector ( sfts0 );
// ----- 1) compute FFT on original REAL4 timeseries -----
REAL4FFTPlan *planR4;
XLAL_CHECK ( (planR4 = XLALCreateForwardREAL4FFTPlan ( numSamplesR4, 0 )) != NULL, XLAL_EFUNC );
SFTtype *lft0;
XLAL_CHECK ( (lft0 = XLALCreateSFT ( numSamplesR4/2+1 )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( XLALREAL4ForwardFFT ( lft0->data, tsR4->data, planR4 ) == XLAL_SUCCESS, XLAL_EFUNC );
strcpy ( lft0->name, tsR4->name );
lft0->f0 = 0;
lft0->epoch = tsR4->epoch;
REAL8 dfLFT = 1.0 / TspanR4;
lft0->deltaF = dfLFT;
// ----- extract frequency band of interest
SFTtype *lftR4 = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &lftR4, lft0, out_fMin, out_Band ) == XLAL_SUCCESS, XLAL_EFUNC );
for ( UINT4 k=0; k < lftR4->data->length; k ++ ) {
lftR4->data->data[k] *= dt_R4;
}
// ----- 2) compute LFT directly from SFTs ----------
SFTtype *lftSFTs0;
XLAL_CHECK ( (lftSFTs0 = XLALSFTVectorToLFT ( sftsBand, 1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTVector ( sftsBand );
// ----- re-extract frequency band of interest
SFTtype *lftSFTs = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &lftSFTs, lftSFTs0, out_fMin, out_Band ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( lalDebugLevel & LALINFO )
{ // ----- write debug output
XLAL_CHECK ( XLALdumpREAL4TimeSeries ( "TS_R4.dat", tsR4 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ("LFT_R4T.dat", lftR4 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ("LFT_SFTs.dat", lftSFTs ) == XLAL_SUCCESS, XLAL_EFUNC );
} // end: debug output
// ========== compare resulting LFTs ==========
VectorComparison XLAL_INIT_DECL(tol0);
XLALPrintInfo ("Comparing LFT with itself: should give 0 for all measures\n");
XLAL_CHECK ( XLALCompareSFTs ( lftR4, lftR4, &tol0 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALCompareSFTs ( lftSFTs, lftSFTs, &tol0 ) == XLAL_SUCCESS, XLAL_EFUNC );
VectorComparison XLAL_INIT_DECL(tol);
tol.relErr_L1 = 4e-2;
tol.relErr_L2 = 5e-2;
tol.angleV = 5e-2; // rad
tol.relErr_atMaxAbsx = 1.2e-2;
tol.relErr_atMaxAbsy = 1.2e-2;
XLALPrintInfo ("Comparing LFT from REAL4-timeseries, to LFT from heterodyned COMPLEX8-timeseries:\n");
XLAL_CHECK ( XLALCompareSFTs ( lftR4, lftSFTs, &tol ) == XLAL_SUCCESS, XLAL_EFUNC );
// ---------- free memory ----------
XLALDestroyREAL4TimeSeries ( tsR4 );
XLALDestroyREAL4FFTPlan ( planR4 );
XLALDestroySFT ( lft0 );
XLALDestroySFT ( lftR4 );
XLALDestroySFT ( lftSFTs );
XLALDestroySFT ( lftSFTs0 );
return XLAL_SUCCESS;
} // test_XLALSFTVectorToLFT()
/** 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;
}
REAL4Vector * readInSFTs(inputParamsStruct *input, REAL8 *normalization)
{
INT4 ii, jj;
SFTCatalog *catalog = NULL;
//Set the start and end times in the LIGO GPS format
LIGOTimeGPS start = LIGOTIMEGPSZERO, end = LIGOTIMEGPSZERO;
XLALGPSSetREAL8(&start, input->searchstarttime);
if (xlalErrno != 0) {
fprintf(stderr, "%s: XLALGPSSetREAL8() failed on start time = %.9f.\n", __func__, input->searchstarttime);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
XLALGPSSetREAL8(&end, input->searchstarttime+input->Tobs);
if (xlalErrno != 0) {
fprintf(stderr, "%s: XLALGPSSetREAL8() failed on end time = %.9f.\n", __func__, input->searchstarttime+input->Tobs);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Setup the constraints
SFTConstraints constraints;
constraints.detector = NULL;
constraints.minStartTime = constraints.maxStartTime = NULL;
constraints.timestamps = NULL;
constraints.detector = input->det[0].frDetector.prefix;
constraints.minStartTime = &start;
constraints.maxStartTime = &end;
//Find SFT files
catalog = XLALSFTdataFind(sft_dir_file, &constraints);
if (catalog==NULL) {
fprintf(stderr,"%s: XLALSFTdataFind() failed.\n", __func__);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Determine band size (remember to get extra bins because of the running median and the bin shifts due to detector velocity)
REAL8 minfbin = round(input->fmin*input->Tcoh - input->dfmax*input->Tcoh - 0.5*(input->blksize-1) - (REAL8)(input->maxbinshift) - 6.0)/input->Tcoh;
REAL8 maxfbin = round((input->fmin + input->fspan)*input->Tcoh + input->dfmax*input->Tcoh + 0.5*(input->blksize-1) + (REAL8)(input->maxbinshift) + 6.0)/input->Tcoh;
//Now extract the data
SFTVector *sfts = XLALLoadSFTs(catalog, minfbin+0.1/input->Tcoh, maxfbin-0.1/input->Tcoh);
if (sfts == NULL) {
fprintf(stderr,"%s: XLALLoadSFTs() failed to load SFTs with given input parameters.\n", __func__);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Now put the power data into the TF plane, looping through each SFT
//If an SFT doesn't exit, fill the TF pixels of the SFT with zeros
INT4 numffts = (INT4)floor(input->Tobs/(input->Tcoh-input->SFToverlap)-1);
INT4 sftlength;
if (sfts->length == 0) sftlength = (INT4)round(maxfbin*input->Tcoh - minfbin*input->Tcoh + 1);
else {
sftlength = sfts->data->data->length;
//Check the length is what we expect
if (sftlength!=(INT4)round(maxfbin*input->Tcoh - minfbin*input->Tcoh + 1)) {
fprintf(stderr, "%s: sftlength (%d) is not matching expected length (%d).\n", __func__, sftlength, (INT4)round(maxfbin*input->Tcoh - minfbin*input->Tcoh + 1));
XLAL_ERROR_NULL(XLAL_EFPINEXCT);
}
}
INT4 nonexistantsft = 0;
REAL4Vector *tfdata = XLALCreateREAL4Vector(numffts*sftlength);
if (tfdata==NULL) {
fprintf(stderr,"%s: XLALCreateREAL4Vector(%d) failed.\n", __func__, numffts*sftlength);
XLAL_ERROR_NULL(XLAL_EFUNC);
}
//Load the data into the output vector, roughly normalizing as we go along from the input value
REAL8 sqrtnorm = sqrt(*(normalization));
for (ii=0; ii<numffts; ii++) {
SFTDescriptor *sftdescription = &(catalog->data[ii - nonexistantsft]);
if (sftdescription->header.epoch.gpsSeconds == (INT4)round(ii*(input->Tcoh-input->SFToverlap)+input->searchstarttime)) {
SFTtype *sft = &(sfts->data[ii - nonexistantsft]);
for (jj=0; jj<sftlength; jj++) {
COMPLEX8 sftcoeff = sft->data->data[jj];
tfdata->data[ii*sftlength + jj] = (REAL4)((sqrtnorm*crealf(sftcoeff))*(sqrtnorm*crealf(sftcoeff)) + (sqrtnorm*cimagf(sftcoeff))*(sqrtnorm*cimagf(sftcoeff))); //power, normalized
}
} else {
for (jj=0; jj<sftlength; jj++) tfdata->data[ii*sftlength + jj] = 0.0; //Set values to be zero
nonexistantsft++; //increment the nonexistantsft counter
}
} /* for ii < numffts */
//Vladimir's code uses a different SFT normalization factor than MFD
if (strcmp(input->sftType, "vladimir") == 0) {
REAL4 vladimirfactor = (REAL4)(0.25*(8.0/3.0));
for (ii=0; ii<(INT4)tfdata->length; ii++) tfdata->data[ii] *= vladimirfactor;
}
//Destroy stuff
XLALDestroySFTCatalog(catalog);
XLALDestroySFTVector(sfts);
fprintf(stderr, "Duty factor = %f\n", 1.0-(REAL4)nonexistantsft/(REAL4)numffts);
return tfdata;
} /* readInSFTs() */
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
SFTConstraints XLAL_INIT_DECL(constraints);
LIGOTimeGPS XLAL_INIT_DECL(minStartTimeGPS);
LIGOTimeGPS XLAL_INIT_DECL(maxStartTimeGPS);
SFTCatalog *FullCatalog = NULL;
CHAR *add_comment = NULL;
UINT4 i;
REAL8 fMin, fMax;
UserInput_t XLAL_INIT_DECL(uvar);
/* register all user-variables */
XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK_MAIN ( XLALUserVarReadAllInput (argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit (0);
}
/* ----- make sure output directory exists ---------- */
if ( uvar.outputDir )
{
int ret;
ret = mkdir ( uvar.outputDir, 0777);
if ( (ret == -1) && ( errno != EEXIST ) )
{
int errsv = errno;
LogPrintf (LOG_CRITICAL, "Failed to create directory '%s': %s\n", uvar.outputDir, strerror(errsv) );
return -1;
}
}
LIGOTimeGPSVector *timestamps = NULL;
if ( uvar.timestampsFile )
{
if ( (timestamps = XLALReadTimestampsFile ( uvar.timestampsFile )) == NULL ) {
XLALPrintError ("XLALReadTimestampsFile() failed to load timestamps from file '%s'\n", uvar.timestampsFile );
return -1;
}
}
/* use IFO-contraint if one given by the user */
if ( LALUserVarWasSet ( &uvar.IFO ) ) {
XLAL_CHECK_MAIN ( (constraints.detector = XLALGetChannelPrefix ( uvar.IFO )) != NULL, XLAL_EINVAL );
}
minStartTimeGPS.gpsSeconds = uvar.minStartTime;
maxStartTimeGPS.gpsSeconds = uvar.maxStartTime;
constraints.minStartTime = &minStartTimeGPS;
constraints.maxStartTime = &maxStartTimeGPS;
constraints.timestamps = timestamps;
/* get full SFT-catalog of all matching (multi-IFO) SFTs */
XLAL_CHECK_MAIN ( (FullCatalog = XLALSFTdataFind ( uvar.inputSFTs, &constraints )) != NULL, XLAL_EFUNC );
if ( constraints.detector ) {
XLALFree ( constraints.detector );
}
XLAL_CHECK_MAIN ( (FullCatalog != NULL) && (FullCatalog->length > 0), XLAL_EINVAL, "\nSorry, didn't find any matching SFTs with pattern '%s'!\n\n", uvar.inputSFTs );
/* build up full comment-string to be added to SFTs: 1) converted by ConvertToSFTv2, VCS ID 2) user extraComment */
{
UINT4 len = 128;
len += strlen ( uvar.inputSFTs );
if ( uvar.extraComment )
len += strlen ( uvar.extraComment );
XLAL_CHECK_MAIN ( ( add_comment = LALCalloc ( 1, len )) != NULL, XLAL_ENOMEM );
/** \deprecated FIXME: the following code uses obsolete CVS ID tags.
* It should be modified to use git version information. */
sprintf ( add_comment, "Converted by $Id$, inputSFTs = '%s';", uvar.inputSFTs );
if ( uvar.extraComment )
{
strcat ( add_comment, "\n");
strcat ( add_comment, uvar.extraComment );
}
} /* construct comment-string */
/* which frequency-band to extract? */
fMin = -1; /* default: all */
fMax = -1;
if ( LALUserVarWasSet ( &uvar.fmin ) )
fMin = uvar.fmin;
if ( LALUserVarWasSet ( &uvar.fmax ) )
fMax = uvar.fmax;
FILE *fpSingleSFT = NULL;
if ( uvar.outputSingleSFT )
XLAL_CHECK ( ( fpSingleSFT = fopen ( uvar.outputSingleSFT, "wb" )) != NULL,
XLAL_EIO, "Failed to open singleSFT file '%s' for writing\n", uvar.outputSingleSFT );
/* loop over all SFTs in SFTCatalog */
for ( i=0; i < FullCatalog->length; i ++ )
{
SFTCatalog oneSFTCatalog;
SFTVector *thisSFT = NULL;
const CHAR *sft_comment;
CHAR *new_comment;
UINT4 comment_len = 0;
/* set catalog containing only one SFT */
oneSFTCatalog.length = 1;
oneSFTCatalog.data = &(FullCatalog->data[i]);
comment_len = strlen ( add_comment ) + 10;
sft_comment = oneSFTCatalog.data->comment;
if ( sft_comment )
comment_len += strlen ( sft_comment );
XLAL_CHECK_MAIN ( ( new_comment = LALCalloc (1, comment_len )) != NULL, XLAL_ENOMEM );
if ( sft_comment ) {
strcpy ( new_comment, sft_comment );
strcat ( new_comment, ";\n");
}
strcat ( new_comment, add_comment );
XLAL_CHECK_MAIN ( (thisSFT = XLALLoadSFTs ( &oneSFTCatalog, fMin, fMax )) != NULL, XLAL_EFUNC );
if ( uvar.mysteryFactor != 1.0 ) {
XLAL_CHECK_MAIN ( applyFactor2SFTs ( thisSFT, uvar.mysteryFactor ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// if user asked for single-SFT output, add this SFT to the open file
if ( uvar.outputSingleSFT )
XLAL_CHECK ( XLAL_SUCCESS == XLALWriteSFT2fp( &(thisSFT->data[0]), fpSingleSFT, new_comment ),
XLAL_EFUNC, "XLALWriteSFT2fp() failed to write SFT to '%s'!\n", uvar.outputSingleSFT );
// if user asked for directory output, write this SFT into that directory
if ( uvar.outputDir ) {
XLAL_CHECK_MAIN ( XLALWriteSFTVector2Dir ( thisSFT, uvar.outputDir, new_comment, uvar.descriptionMisc ) == XLAL_SUCCESS, XLAL_EFUNC );
}
XLALDestroySFTVector ( thisSFT );
XLALFree ( new_comment );
} /* for i < numSFTs */
if ( fpSingleSFT ) {
fclose ( fpSingleSFT );
}
/* free memory */
XLALFree ( add_comment );
XLALDestroySFTCatalog ( FullCatalog );
XLALDestroyUserVars();
XLALDestroyTimestampVector ( timestamps );
LALCheckMemoryLeaks();
return 0;
} /* main */
/** The main function of Intermittent.c
*
*/
int main( int argc, char *argv[] )
{
UserInput_t uvar = empty_UserInput; /* user input variables */
INT4 i, k, m; /* counter */
CHAR newtemp[LONGSTRINGLENGTH];
FILE *ifp = NULL;
CHAR *clargs = NULL; /* store the command line args */
/**********************************************************************************/
/* 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;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : read in uservars\n", __func__ );
}
/**********************************************************************************/
/* make temporary directory */
if ( uvar.tempdir ) {
/* initialise the random number generator - use the clock */
gsl_rng *q;
if ( XLALInitgslrand( &q, 0 ) ) {
LogPrintf( LOG_CRITICAL, "%s: XLALinitgslrand() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFAULT );
}
INT4 id = ( INT4 )( 1e9 * gsl_rng_uniform( q ) );
sprintf( newtemp, "%s/%09d", uvar.tempdir, id );
fprintf( stdout, "temp dir = %s\n", newtemp );
if ( mkdir( newtemp, 0755 ) ) {
if ( uvar.verbose ) {
fprintf( stdout, "%s : Unable to make temporary directory %s. Might be a problem.\n", __func__, newtemp );
}
return 1;
}
}
/**********************************************************************************/
/* read in the cache file and find the correct entry for the binary 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;
INT4 idx = -1;
CHAR filename[LONGSTRINGLENGTH];
CHAR dummy[LONGSTRINGLENGTH];
LIGOTimeGPS fileStart;
INT4 dummysec = 0;
INT4 dummynan = 0;
while ( fscanf( cachefp, "%s %d %d", dummy, &dummysec, &dummynan ) != EOF ) {
if ( strstr( dummy, uvar.binfile ) ) {
idx = i;
strcpy( filename, dummy );
fileStart.gpsSeconds = dummysec;
fileStart.gpsNanoSeconds = ( INT4 )1e9 * ( floor( 1e-9 * dummynan / uvar.tsamp + 0.5 ) * uvar.tsamp ); /* round to make sure we get samples at GPS seconds */
}
i++;
}
if ( idx < 0 ) {
LogPrintf( LOG_CRITICAL, "%s : failed to find binary input file %s in cache file %s\n", __func__, filename, uvar.cachefile );
return 1;
}
fclose( cachefp );
if ( uvar.verbose ) {
fprintf( stdout, "%s : found the requested binary file entry in the cache file.\n", __func__ );
}
/***********************************************************************************/
/* setup the fixed binaryToSFT parameters */
BinaryToSFTparams par;
par.tsamp = uvar.tsamp;
par.highpassf = uvar.highpassf;
par.amp_inj = 0.0;
par.f_inj = 0.0;
par.asini_inj = 0.0;
XLALGPSSetREAL8( &( par.tasc_inj ), 0 );
par.tref = fileStart;
par.P_inj = 0;
par.phi_inj = 0;
par.r = NULL;
/* setup the gridding over coherent times - which we make sure are integers */
INT4 dummyT = uvar.Tmin;
INT4 NT = 0;
while ( dummyT < uvar.Tmax ) {
dummyT = ( INT4 )( ( REAL8 )dummyT * ( 1.0 + uvar.mismatch ) );
NT++;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : Going to do %d different coherent lengths.\n", __func__, NT );
}
/**********************************************************************************/
/* OPEN INTERMEDIATE RESULTS FILE */
/**********************************************************************************/
CHAR intname[LONGSTRINGLENGTH];
if ( XLALOpenIntermittentResultsFile( &ifp, intname, newtemp, clargs, &uvar, &fileStart ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALOpenCoherentResultsFile() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : opened coherent results file %s.\n", __func__, intname );
}
/**********************************************************************************/
/* loop over the different coherent lengths */
INT4 currentT = uvar.Tmin;
for ( i = 0; i < NT; i++ ) {
if ( uvar.verbose ) {
fprintf( stdout, "%s : working on segment length %d/%d using a segment time of %d sec\n", __func__, i, NT, currentT );
}
/* define SFT frequency bounds */
REAL8 wings = LAL_TWOPI * uvar.maxasini / uvar.minorbperiod;
REAL8 fmin_read = MINBAND * floor( ( uvar.freq - WINGS_FACTOR * uvar.freq * wings - ( REAL8 )uvar.blocksize / ( REAL8 )uvar.Tmin ) / MINBAND );
REAL8 fmax_read = MINBAND * ceil( ( uvar.freq + ( REAL8 )uvar.blocksize / ( REAL8 )uvar.Tmin + uvar.freqband + WINGS_FACTOR * ( uvar.freq + uvar.freqband ) * wings ) / MINBAND );
REAL8 fband_read = fmax_read - fmin_read;
if ( uvar.verbose ) {
fprintf( stdout, "%s : reading in SFT frequency band [%f -> %f]\n", __func__, fmin_read, fmax_read );
}
/* define the number of different start times */
INT4 Ns = ceil( 1.0 / uvar.mismatch );
INT4 Tstep = ( INT4 )floor( currentT / ( REAL8 )Ns );
if ( Tstep == 0 ) {
Ns = 1;
} else {
Ns = ( INT4 )ceil( ( REAL8 )currentT / ( REAL8 )Tstep );
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : number of start times is %d and time step is %d sec\n", __func__, Ns, Tstep );
}
par.tsft = currentT;
par.freq = fmin_read;
par.freqband = fband_read;
/* loop over different start times - make sure they are integer GPS time for simplicity */
LIGOTimeGPS currentStart;
currentStart.gpsSeconds = ( INT4 )ceil( ( REAL8 )fileStart.gpsSeconds + 1e-9 * ( REAL8 )fileStart.gpsNanoSeconds );
currentStart.gpsNanoSeconds = 0;
for ( k = 0; k < Ns; k++ ) {
if ( uvar.verbose ) {
fprintf( stdout, "%s : working on offset start %d/%d using a start time of %d %d sec\n", __func__, k, Ns, currentStart.gpsSeconds, currentStart.gpsNanoSeconds );
}
memcpy( &( par.tstart ), ¤tStart, sizeof( LIGOTimeGPS ) );
ParameterSpace pspace = empty_ParameterSpace; /* the search parameter space */
COMPLEX8TimeSeriesArray *dstimevec = NULL; /* contains the downsampled inverse FFT'd SFTs */
REAL4DemodulatedPowerVector *dmpower = NULL; /* contains the demodulated power for all SFTs */
GridParametersVector *freqgridparams = NULL; /* the coherent grid on the frequency derivitive parameter space */
SFTVector *sftvec = NULL;
INT8Vector *np = NULL;
REAL8Vector *R = NULL;
/**********************************************************************************/
/* GENERATE SFTS FROM BINARY INPUT FILE */
/**********************************************************************************/
/* converts a binary input file into sfts */
if ( XLALBinaryToSFTVector( &sftvec, filename, &fileStart, &par, &np, &R ) ) {
LogPrintf( LOG_CRITICAL, "%s : failed to convert binary input file %s to sfts\n", __func__, uvar.binfile );
return 1;
}
XLALDestroyINT8Vector( np );
XLALDestroyREAL8Vector( R );
if ( uvar.verbose ) {
fprintf( stdout, "%s : generated SFTs for file %s\n", __func__, filename );
}
/* if we have any SFTs */
if ( sftvec->length > 0 ) {
/* define SFT length and the start and span of the observations plus the definitive segment time */
pspace.tseg = 1.0 / sftvec->data[0].deltaF;
memcpy( &( pspace.epoch ), &( sftvec->data[0].epoch ), sizeof( LIGOTimeGPS ) );
pspace.span = XLALGPSDiff( &( sftvec->data[sftvec->length - 1].epoch ), &( sftvec->data[0].epoch ) ) + pspace.tseg;
if ( uvar.verbose ) {
fprintf( stdout, "%s : SFT length = %f seconds\n", __func__, pspace.tseg );
fprintf( stdout, "%s : entire dataset starts at GPS time %d contains %d SFTS and spans %.0f seconds\n", __func__, pspace.epoch.gpsSeconds, sftvec->length, pspace.span );
}
/**********************************************************************************/
/* NORMALISE THE SFTS */
/**********************************************************************************/
/* compute the background noise using the sfts - this routine uses the running median at the edges to normalise the wings */
if ( XLALNormalizeSFTVect( sftvec, uvar.blocksize, 0 ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALNormaliseSFTVect() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : normalised the SFTs\n", __func__ );
}
/**********************************************************************************/
/* DEFINE THE BINARY PARAMETER SPACE */
/**********************************************************************************/
/* define the binary parameter space */
if ( XLALDefineBinaryParameterSpace( &( pspace.space ), pspace.epoch, pspace.span, &uvar ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALDefineBinaryParameterSpace() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : defined binary parameter prior space\n", __func__ );
}
/**********************************************************************************/
/* COMPUTE THE COARSE GRID ON FREQUENCY DERIVITIVES */
/**********************************************************************************/
/* compute the grid parameters for all SFTs */
INT4 ndim = -1;
if ( XLALComputeFreqGridParamsVector( &freqgridparams, pspace.space, sftvec, uvar.mismatch, &ndim, BINS_FACTOR ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALComputeFreqGridParams() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : computed the grid parameters for the sfts\n", __func__ );
}
/**********************************************************************************/
/* CONVERT ALL SFTS TO DOWNSAMPLED TIMESERIES */
/**********************************************************************************/
if ( XLALSFTVectorToCOMPLEX8TimeSeriesArray( &dstimevec, sftvec ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALSFTVectorToCOMPLEX8TimeSeriesArray() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : converted SFTs to downsampled timeseries\n", __func__ );
}
/**********************************************************************************/
/* COMPUTE THE STATISTICS ON THE COARSE GRID */
/**********************************************************************************/
/* compute the demodulated power on the frequency derivitive grid */
if ( XLALCOMPLEX8TimeSeriesArrayToDemodPowerVector( &dmpower, dstimevec, freqgridparams, ifp ) ) {
LogPrintf( LOG_CRITICAL, "%s : XLALCOMPLEX8TimeSeriesArrayToDemodPowerVector() failed with error = %d\n", __func__, xlalErrno );
return 1;
}
if ( uvar.verbose ) {
fprintf( stdout, "%s : computed the demodulated power\n", __func__ );
}
/**********************************************************************************/
/* FREE MEMORY */
/**********************************************************************************/
/* free memory inside the loop */
XLALFreeParameterSpace( &pspace );
XLALFreeREAL4DemodulatedPowerVector( dmpower );
for ( m = 0; m < ( INT4 )dstimevec->length; m++ ) {
XLALDestroyCOMPLEX8TimeSeries( dstimevec->data[m] );
}
XLALFree( dstimevec->data );
XLALFree( dstimevec );
for ( m = 0; m < ( INT4 )freqgridparams->length; m++ ) {
XLALFree( freqgridparams->segment[m]->grid );
XLALFree( freqgridparams->segment[m]->prod );
XLALFree( freqgridparams->segment[m] );
}
XLALFree( freqgridparams->segment );
XLALFree( freqgridparams );
if ( uvar.verbose ) {
fprintf( stdout, "%s : freed memory\n", __func__ );
}
XLALDestroySFTVector( sftvec );
} /* end if statement on whether we have SFTs */
/* update the start time of the segment */
XLALGPSAdd( ¤tStart, ( REAL8 )Tstep );
} /* end loop over start times */
/* update segment length */
currentT = ( INT4 )( ( REAL8 )currentT * ( 1.0 + uvar.mismatch ) );
} /* end loop over segment lengths */
/* move the temporary directory to the final location */
if ( uvar.tempdir ) {
CHAR newoutputfile[LONGSTRINGLENGTH];
snprintf( newoutputfile, LONGSTRINGLENGTH, "%s/IntermittentResults-%s-%d.txt", uvar.outputdir, uvar.outLabel, fileStart.gpsSeconds );
if ( rename( intname, newoutputfile ) ) {
LogPrintf( LOG_CRITICAL, "%s : unable to move final results file %s -> %s. Exiting.\n", __func__, intname, newoutputfile );
return 1;
}
}
/**********************************************************************************/
/* FREE MEMORY */
/**********************************************************************************/
fclose( ifp );
LALCheckMemoryLeaks();
return 0;
}
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
/* register all our user-variable */
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( XLALReadUserInput ( argc, argv, &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
SFTConstraints XLAL_INIT_DECL(constraints);
CHAR detector[2] = "??"; /* allow reading v1-SFTs without detector-info */
constraints.detector = detector;
SFTCatalog *catalog;
XLAL_CHECK ( (catalog = XLALSFTdataFind ( uvar.SFTfiles, &constraints )) != NULL, XLAL_EFUNC, "No SFTs matched your --SFTfiles query\n" );
if ( uvar.headerOnly )
{
for ( UINT4 i=0; i < catalog->length; i ++ )
{
SFTDescriptor *ptr = &(catalog->data[i]);
XLALprintHeader ( &(ptr->header) );
XLALprintDescriptor ( ptr );
} // for i < catalog->length
} // if header
else
{
SFTVector *sfts;
XLAL_CHECK ( (sfts = XLALLoadSFTs ( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
BOOLEAN segmentedSFTs = 0;
if ( sfts->length < catalog->length ) {
segmentedSFTs = 1;
printf ("\n");
printf ("%%%% Frequency-segmented SFTs: len(catalog) = %d, len(sft-vector) = %d\n", catalog->length, sfts->length );
if ( !uvar.noHeader ) {
printf ("%%%% For segmented SFTS we can't output SFT 'descriptors' + data. Use --headerOnly if you need the descriptor fields\n\n");
}
} // if we're dealing with 'segmented SFTs': currently can't map them to catalog-descriptors
for ( UINT4 i=0; i < sfts->length; i ++ )
{
SFTtype *sft_i = &(sfts->data[i]);;
if ( !uvar.noHeader ) {
XLALprintHeader ( sft_i );
if ( !segmentedSFTs ) { // skip descriptor fields for segmented SFTs (as we can't map them to SFTs)
XLALprintDescriptor ( &(catalog->data[i]) );
}
} // output header info
XLALprintData ( sft_i );
} // for i < num_sfts
XLALDestroySFTVector ( sfts );
} /* if !headerOnly */
/* free memory */
XLALDestroySFTCatalog (catalog);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return 0;
} /* main */
/** The main function of semicoherentbinary.c
*
*/
int main( int argc, char *argv[] ) {
UserInput_t uvar = empty_UserInput; /* user input variables */
CHAR *clargs = NULL; /* store the command line args */
SFTVector *sftvec = NULL; /* stores the input SFTs */
/* REAL4VectorArray *background = NULL; /\* running median estimates of the background for each SFT *\/ */
ParameterSpace pspace = empty_ParameterSpace; /* the search parameter space */
COMPLEX8TimeSeriesArray *dstimevec = NULL; /* contains the downsampled inverse FFT'd SFTs */
REAL4DemodulatedPowerVector *dmpower = NULL; /* contains the demodulated power for all SFTs */
GridParametersVector *freqgridparams = NULL; /* the coherent grid on the frequency derivitive parameter space */
GridParameters *bingridparams = NULL;
CHAR newnewtemp[LONGSTRINGLENGTH];
/* REAL8Vector *SemiCo = NULL; /\* the semi-coherent statistic results *\/ */
REAL8 fmin_read,fmax_read,fband_read; /* the range of frequencies to be read from SFTs */
UINT4 i; /* counters */
FILE *sfp = NULL;
/* FILE *cfp = NULL; */
vrbflg = 0; /* verbose error-messages */
/* turn off default GSL error handler */
gsl_set_error_handler_off();
/* register and read all user-variables */
if (XLALReadUserVars(argc,argv,&uvar,&clargs)) {
LogPrintf(LOG_CRITICAL,"%s : XLALReadUserVars() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : read in uservars\n",__func__);
/* initialise sin-cosine lookup table */
XLALSinCosLUTInit();
/* initialise the random number generator */
if (XLALInitgslrand(&r,uvar.seed)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
/* make output directory */
{
struct stat st;
if (stat(uvar.outputdir, &st)) {
if (mkdir(uvar.outputdir,0755) != 0 && errno != EEXIST) {
LogPrintf(LOG_DEBUG,"%s : Unable to make output directory %s. Might be a problem.\n",__func__,uvar.outputdir);
}
}
}
/* make temporary directory */
if (uvar.tempdir) {
struct stat st;
if (stat(uvar.tempdir, &st)) {
if (mkdir(uvar.tempdir,0755) != 0 && errno != EEXIST) {
LogPrintf(LOG_DEBUG,"%s : Unable to make temporary directory %s. Might be a problem.\n",__func__,uvar.tempdir);
}
}
/* initialise the random number generator - use the clock */
gsl_rng * q;
if (XLALInitgslrand(&q,0)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
CHAR newtemp[LONGSTRINGLENGTH];
INT4 id = (INT4)(1e9*gsl_rng_uniform(q));
sprintf(newtemp,"%s/%09d",uvar.tempdir,id);
if (mkdir(newtemp,0755) != 0 && errno != EEXIST) {
LogPrintf(LOG_DEBUG,"%s : Unable to make temporary directory %s. Might be a problem.\n",__func__,newtemp);
}
sprintf(newnewtemp,"%s/%.3f-%.3f",newtemp,uvar.freq,uvar.freq+uvar.freqband);
} else {
sprintf(newnewtemp,"%s/%.3f-%.3f",uvar.outputdir,uvar.freq,uvar.freq+uvar.freqband);
}
/* make frequency+band directory inside output/temporary directory */
if (mkdir(newnewtemp,0755) != 0 && errno != EEXIST) {
LogPrintf(LOG_CRITICAL,"%s : Unable to make frequency+band directory %s\n",__func__,newnewtemp);
return 1;
}
/* initialise the random number generator */
if (XLALInitgslrand(&r,uvar.seed)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
/* make crude but safe estimate of the bandwidth required for the source - now includes running median wings */
{
REAL8 wings = LAL_TWOPI*uvar.maxasini/uvar.minorbperiod;
fmin_read = MINBAND*floor((uvar.freq - WINGS_FACTOR*uvar.freq*wings - (REAL8)uvar.blocksize/(REAL8)uvar.tsft)/MINBAND);
fmax_read = MINBAND*ceil((uvar.freq + (REAL8)uvar.blocksize/(REAL8)uvar.tsft + uvar.freqband + WINGS_FACTOR*(uvar.freq + uvar.freqband)*wings)/MINBAND);
fband_read = fmax_read - fmin_read;
LogPrintf(LOG_NORMAL,"%s : reading in SFT frequency band [%f -> %f]\n",__func__,fmin_read,fmax_read);
}
/* initialise the random number generator */
if (XLALInitgslrand(&r,uvar.seed)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
/**********************************************************************************/
/* READ THE SFT DATA */
/**********************************************************************************/
/* load in the SFTs - also fill in the segment parameters structure */
if (XLALReadSFTs(&sftvec,uvar.sftbasename,fmin_read,fband_read,uvar.gpsstart,uvar.gpsend,uvar.tsft,uvar.bins_factor)) {
LogPrintf(LOG_CRITICAL,"%s : XLALReadSFTs() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : read in SFTs\n",__func__);
/* define SFT length and the start and span of the observations plus the definitive segment time */
pspace.tseg = 1.0/sftvec->data[0].deltaF;
memcpy(&(pspace.epoch),&(sftvec->data[0].epoch),sizeof(LIGOTimeGPS));
pspace.span = XLALGPSDiff(&(sftvec->data[sftvec->length-1].epoch),&(sftvec->data[0].epoch)) + pspace.tseg;
LogPrintf(LOG_NORMAL,"%s : SFT length = %f seconds\n",__func__,pspace.tseg);
LogPrintf(LOG_NORMAL,"%s : entire dataset starts at GPS time %d contains %d SFTS and spans %.0f seconds\n",__func__,pspace.epoch.gpsSeconds,sftvec->length,pspace.span);
/**********************************************************************************/
/* NORMALISE THE SFTS */
/**********************************************************************************/
if (uvar.blocksize>0) {
/* compute the background noise using the sfts - this routine uses the running median at the edges to normalise the wings */
if (XLALNormalizeSFTVect(sftvec,uvar.blocksize,0)) {
LogPrintf(LOG_CRITICAL,"%s : XLALNormaliseSFTVect() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
}
else {
REAL8Vector *means = XLALCreateREAL8Vector(sftvec->length);
if (uvar.blocksize==0) {
/* compute the background noise using the sfts - this routine simply divides by the median */
if (XLALNormalizeSFTVectMedian(sftvec,means,1)) {
LogPrintf(LOG_CRITICAL,"%s : XLALNormaliseSFTVectMedian() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
}
else {
/* compute the background noise using the sfts - this routine simply divides by the mean */
if (XLALNormalizeSFTVectMean(sftvec,means,1)) {
LogPrintf(LOG_CRITICAL,"%s : XLALNormaliseSFTVectMean() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
}
XLALDestroyREAL8Vector(means);
}
LogPrintf(LOG_NORMAL,"%s : normalised the SFTs\n",__func__);
/* for (i=0;i<sftvec->length;i++) {
for (j=0;j<sftvec->data[i].data->length;j++) {
if (isnan(crealf(sftvec->data[i].data->data[j]))||isinf(crealf(sftvec->data[i].data->data[j]))||isnan(cimagf(sftvec->data[i].data->data[j]))||isinf(cimagf(sftvec->data[i].data->data[j]))) {
LogPrintf(LOG_DEBUG,"SFT %d : %f %e %e\n",i,sftvec->data[i].f0 + j*sftvec->data[i].deltaF,crealf(sftvec->data[i].data->data[j]),cimagf(sftvec->data[i].data->data[j]));
}
}
} */
/**********************************************************************************/
/* DEFINE THE BINARY PARAMETER SPACE */
/**********************************************************************************/
/* define the binary parameter space */
if (XLALDefineBinaryParameterSpace(&(pspace.space),pspace.epoch,pspace.span,&uvar)) {
LogPrintf(LOG_CRITICAL,"%s : XLALDefineBinaryParameterSpace() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : defined binary parameter prior space\n",__func__);
/**********************************************************************************/
/* COMPUTE THE COARSE GRID ON FREQUENCY DERIVITIVES */
/**********************************************************************************/
/* compute the grid parameters for all SFTs */
if (XLALComputeFreqGridParamsVector(&freqgridparams,pspace.space,sftvec,uvar.mismatch,&uvar.ndim,uvar.bins_factor)) {
LogPrintf(LOG_CRITICAL,"%s : XLALComputeFreqGridParams() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
/**********************************************************************************/
/* COMPUTE THE FINE GRID PARAMETERS */
/**********************************************************************************/
/* compute the fine grid on the binary parameters */
if (XLALComputeBinaryGridParams(&bingridparams,pspace.space,pspace.span,pspace.tseg,uvar.mismatch,uvar.coverage)) {
LogPrintf(LOG_CRITICAL,"%s : XLALComputeBinaryGridParams() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : computed the binary parameter space grid\n",__func__);
/**********************************************************************************/
/* CONVERT ALL SFTS TO DOWNSAMPLED TIMESERIES */
/**********************************************************************************/
/* convert sfts to downsample dtimeseries */
if (XLALSFTVectorToCOMPLEX8TimeSeriesArray(&dstimevec,sftvec)) {
LogPrintf(LOG_CRITICAL,"%s : XLALSFTVectorToCOMPLEX8TimeSeriesArray() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : converted SFTs to downsampled timeseries\n",__func__);
/**********************************************************************************/
/* OPEN INTERMEDIATE RESULTS FILE */
/**********************************************************************************/
/* if (XLALOpenSemiCoherentResultsFile(&cfp,newnewtemp,&pspace,clargs,&uvar,1)) {
LogPrintf(LOG_CRITICAL,"%s : XLALOpenCoherentResultsFile() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : opened coherent results file.\n",__func__); */
/**********************************************************************************/
/* COMPUTE THE STATISTICS ON THE COARSE GRID */
/**********************************************************************************/
/* compute the demodulated power on the frequency derivitive grid */
if (XLALCOMPLEX8TimeSeriesArrayToDemodPowerVector(&dmpower,dstimevec,freqgridparams,NULL)) {
LogPrintf(LOG_CRITICAL,"%s : XLALCOMPLEX8TimeSeriesArrayToDemodPowerVector() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
/* fclose(cfp); */
LogPrintf(LOG_NORMAL,"%s : computed the demodulated power\n",__func__);
/**********************************************************************************/
/* OPEN RESULTS FILE */
/**********************************************************************************/
if (XLALOpenSemiCoherentResultsFile(&sfp,newnewtemp,&pspace,clargs,&uvar)) {
LogPrintf(LOG_CRITICAL,"%s : XLALOutputBayesResults() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_NORMAL,"%s : output results to file.\n",__func__);
/**********************************************************************************/
/* COMPUTE THE STATISTICS ON THE FINE GRID */
/**********************************************************************************/
/* compute the semi-coherent detection statistic on the fine grid */
if (XLALComputeSemiCoherentStat(sfp,dmpower,&pspace,freqgridparams,bingridparams,uvar.ntoplist,uvar.with_xbins)) {
LogPrintf(LOG_CRITICAL,"%s : XLALComputeSemiCoherentStat() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
fclose(sfp);
LogPrintf(LOG_NORMAL,"%s : computed the semi-coherent statistic\n",__func__);
/**********************************************************************************/
/* CLEAN UP */
/**********************************************************************************/
/* move the temporary directory to the final location */
if (uvar.tempdir) {
CHAR newoutputdir[LONGSTRINGLENGTH];
sprintf(newoutputdir,"%s/%.3f-%.3f",uvar.outputdir,uvar.freq,uvar.freq+uvar.freqband);
if (rename(newnewtemp,newoutputdir)) {
LogPrintf(LOG_CRITICAL,"%s : unable to move final results directory %s -> %s. Exiting.\n",__func__,newnewtemp,newoutputdir);
return 1;
}
}
LogPrintf(LOG_DEBUG,"%s : moved the results from the temp space.\n",__func__);
/* clean up the parameter space */
if (XLALFreeParameterSpace(&pspace)) {
LogPrintf(LOG_CRITICAL,"%s : XLALFreeParameterSpace() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_DEBUG,"%s : freed the parameter space\n",__func__);
/* clean up the demodulated power */
if (XLALFreeREAL4DemodulatedPowerVector(dmpower)) {
LogPrintf(LOG_CRITICAL,"%s : XLALFreeREAL4DemodulatedPowerVector() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_DEBUG,"%s : freed the demodulated power\n",__func__);
/* free un-needed downsampled timeseries */
for (i=0;i<dstimevec->length;i++) {
XLALDestroyCOMPLEX8TimeSeries(dstimevec->data[i]);
}
XLALFree(dstimevec->data);
XLALFree(dstimevec);
LogPrintf(LOG_DEBUG,"%s : freed the downsampled timeseries memory\n",__func__);
/* free frequency grid - the contents of each segment have been moved to the power structure and are freed later */
XLALFree(freqgridparams->segment);
XLALFree(freqgridparams);
/* free un-needed original SFT vector */
XLALDestroySFTVector(sftvec);
LogPrintf(LOG_DEBUG,"%s : Freed the SFT memory\n",__func__);
/* free semi-coherent results */
/* XLALDestroyREAL8Vector(SemiCo); */
/* LogPrintf(LOG_DEBUG,"%s : Freed the semi-coherent results memory\n",__func__); */
/* Free config-Variables and userInput stuff */
XLALDestroyUserVars();
XLALFree(clargs);
/* did we forget anything ? */
LALCheckMemoryLeaks();
LogPrintf(LOG_DEBUG,"%s : successfully checked memory leaks.\n",__func__);
LogPrintf(LOG_NORMAL,"%s : successfully completed.\n",__func__);
return 0;
} /* end of main */
/*----------------------------------------------------------------------
* main function
*----------------------------------------------------------------------*/
int
main(int argc, char *argv[])
{
SFTConstraints XLAL_INIT_DECL(constraints);
CHAR detector[2] = "??"; /* allow reading v1-SFTs without detector-info */
SFTVector *diffs = NULL;
REAL8 maxd = 0;
/* register all user-variables */
UserInput_t XLAL_INIT_DECL(uvar);
XLAL_CHECK_MAIN ( initUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
XLAL_CHECK_MAIN ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar.help) { /* help requested: we're done */
exit (0);
}
/* now read in the two complete sft-vectors */
constraints.detector = detector;
SFTCatalog *catalog;
XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname1, &constraints )) != NULL, XLAL_EFUNC );
SFTVector *SFTs1;
XLAL_CHECK_MAIN ( (SFTs1 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTCatalog ( catalog );
XLAL_CHECK_MAIN ( (catalog = XLALSFTdataFind ( uvar.sftBname2, &constraints )) != NULL, XLAL_EFUNC );
SFTVector *SFTs2;
XLAL_CHECK_MAIN ( (SFTs2 = XLALLoadSFTs( catalog, -1, -1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTCatalog ( catalog );
/* ---------- do some sanity checks of consistency of SFTs ----------*/
XLAL_CHECK_MAIN ( SFTs1->length == SFTs2->length, XLAL_EINVAL, "Number of SFTs differ for SFTbname1 and SFTbname2!\n");
for ( UINT4 i=0; i < SFTs1->length; i++ )
{
SFTtype *sft1 = &(SFTs1->data[i]);
SFTtype *sft2 = &(SFTs2->data[i]);
if( strcmp( sft1->name, sft2->name ) )
{
if ( lalDebugLevel ) { XLALPrintError("WARNING SFT %d: detector-prefix differ! '%s' != '%s'\n", i, sft1->name, sft2->name ); }
/* exit (1); */ /* can't be too strict here, as we also allow v1-SFTs, which don't have detector-name */
}
XLAL_CHECK_MAIN ( sft1->data->length == sft2->data->length, XLAL_EINVAL, "\nERROR SFT %d: lengths differ! %d != %d\n", i, sft1->data->length, sft2->data->length );
REAL8 Tdiff = XLALGPSDiff(&(sft1->epoch), &(sft2->epoch));
CHAR buf1[32], buf2[32];;
XLAL_CHECK_MAIN ( Tdiff == 0.0, XLAL_EINVAL, "SFT %d: epochs differ: %s vs %s\n", i, XLALGPSToStr(buf1,&sft1->epoch), XLALGPSToStr(buf2,&sft2->epoch) );
XLAL_CHECK_MAIN ( sft1->f0 == sft2->f0, XLAL_EINVAL, "ERROR SFT %d: fmin differ: %fHz vs %fHz\n", i, sft1->f0, sft2->f0 );
XLAL_CHECK_MAIN ( sft1->deltaF == sft2->deltaF, XLAL_EINVAL, "ERROR SFT %d: deltaF differs: %fHz vs %fHz\n", i, sft1->deltaF, sft2->deltaF );
} /* for i < numSFTs */
/*---------- now do some actual comparisons ----------*/
XLAL_CHECK_MAIN ( (diffs = subtractSFTVectors ( SFTs1, SFTs2)) != NULL, XLAL_EFUNC );
if ( uvar.verbose)
{
for ( UINT4 i=0; i < SFTs1->length; i++)
{
SFTtype *sft1 = &(SFTs1->data[i]);
SFTtype *sft2 = &(SFTs2->data[i]);
XLALPrintInfo ("i=%02d: ", i);
REAL4 norm1 = scalarProductSFT ( sft1, sft1 );
norm1 = sqrt(norm1);
REAL4 norm2 = scalarProductSFT ( sft2, sft2 );
norm2 = sqrt(norm2);
REAL4 scalar = scalarProductSFT ( sft1, sft2 );
REAL4 normdiff = scalarProductSFT ( &(diffs->data[i]), &(diffs->data[i]) );
REAL4 d1 = (norm1 - norm2)/norm1;
REAL4 d2 = 1.0 - scalar / (norm1*norm2);
REAL4 d3 = normdiff / (norm1*norm1 + norm2*norm2 );
REAL4 d4 = getMaxErrSFT (sft1, sft2);
XLALPrintInfo ("(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2))=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4);
} /* for i < SFTs->length */
} /* if verbose */
/* ---------- COMBINED measures ---------- */
{
REAL4 ret;
ret = scalarProductSFTVector ( SFTs1, SFTs1 );
REAL8 norm1 = sqrt( (REAL8)ret );
ret = scalarProductSFTVector ( SFTs2, SFTs2 );
REAL8 norm2 = sqrt( (REAL8)ret );
ret = scalarProductSFTVector ( SFTs1, SFTs2 );
REAL8 scalar = (REAL8) ret;
ret = scalarProductSFTVector ( diffs, diffs );
REAL8 normdiff = (REAL8) ret;
REAL8 d1 = (norm1 - norm2)/norm1;
maxd = fmax ( maxd, d1 );
REAL8 d2 = 1.0 - scalar / (norm1*norm2);
maxd = fmax ( maxd, d2 );
REAL8 d3 = normdiff / ( norm1*norm1 + norm2*norm2);
maxd = fmax ( maxd, d3 );
REAL8 d4 = getMaxErrSFTVector (SFTs1, SFTs2);
maxd = fmax ( maxd, d4 );
if ( uvar.verbose ) {
printf ("\nTOTAL:(|x|-|y|)/|x|=%10.3e, 1-x.y/(|x||y|)=%10.3e, |x-y|^2/(|x|^2+|y|^2)=%10.3e, maxErr=%10.3e\n", d1, d2, d3, d4);
}
else
{
printf ("%10.3e %10.3e\n", d3, d4);
}
} /* combined total measures */
/* free memory */
XLALDestroySFTVector ( SFTs1 );
XLALDestroySFTVector ( SFTs2 );
XLALDestroySFTVector ( diffs );
XLALDestroyUserVars();
LALCheckMemoryLeaks();
if ( maxd <= uvar.relErrorMax ) {
return 0;
}
else {
return 1;
}
} /* main */
/**
* Turn the given SFTvector into one long time-series, properly dealing with gaps.
*/
COMPLEX8TimeSeries *
XLALSFTVectorToCOMPLEX8TimeSeries ( const SFTVector *sftsIn /**< [in] SFT vector */
)
{
// check input sanity
XLAL_CHECK_NULL ( (sftsIn !=NULL) && (sftsIn->length > 0), XLAL_EINVAL );
// create a local copy of the input SFTs, as they will be locally modified!
SFTVector *sfts;
XLAL_CHECK_NULL ( (sfts = XLALDuplicateSFTVector ( sftsIn )) != NULL, XLAL_EFUNC );
/* define some useful shorthands */
UINT4 numSFTs = sfts->length;
SFTtype *firstSFT = &(sfts->data[0]);
SFTtype *lastSFT = &(sfts->data[numSFTs-1]);
UINT4 numFreqBinsSFT = firstSFT->data->length;
REAL8 dfSFT = firstSFT->deltaF;
REAL8 Tsft = 1.0 / dfSFT;
REAL8 deltaT = Tsft / numFreqBinsSFT; // complex FFT: numSamplesSFT = numFreqBinsSFT
REAL8 f0SFT = firstSFT->f0;
/* if the start and end input pointers are NOT NULL then determine start and time-span of the final long time-series */
LIGOTimeGPS start = firstSFT->epoch;
LIGOTimeGPS end = lastSFT->epoch;
XLALGPSAdd ( &end, Tsft );
/* determine output time span */
REAL8 Tspan;
XLAL_CHECK_NULL ( (Tspan = XLALGPSDiff ( &end, &start ) ) > 0, XLAL_EINVAL );
UINT4 numSamples = lround ( Tspan / deltaT );
/* determine the heterodyning frequency */
/* fHet = DC of our internal DFTs */
UINT4 NnegSFT = NhalfNeg ( numFreqBinsSFT );
REAL8 fHet = f0SFT + 1.0 * NnegSFT * dfSFT;
/* ----- Prepare invFFT of SFTs: compute plan for FFTW */
COMPLEX8FFTPlan *SFTplan;
XLAL_CHECK_NULL ( (SFTplan = XLALCreateReverseCOMPLEX8FFTPlan( numFreqBinsSFT, 0 )) != NULL, XLAL_EFUNC );
/* ----- Prepare short time-series holding ONE invFFT of a single SFT */
LIGOTimeGPS XLAL_INIT_DECL(epoch);
COMPLEX8TimeSeries *sTS;
XLAL_CHECK_NULL ( (sTS = XLALCreateCOMPLEX8TimeSeries ( "short timeseries", &epoch, 0, deltaT, &emptyLALUnit, numFreqBinsSFT )) != NULL, XLAL_EFUNC );
/* ----- prepare long TimeSeries container ---------- */
COMPLEX8TimeSeries *lTS;
XLAL_CHECK_NULL ( (lTS = XLALCreateCOMPLEX8TimeSeries ( firstSFT->name, &start, fHet, deltaT, &emptyLALUnit, numSamples )) != NULL, XLAL_EFUNC );
memset ( lTS->data->data, 0, numSamples * sizeof(*lTS->data->data)); /* set all time-samples to zero (in case there are gaps) */
/* ---------- loop over all SFTs and inverse-FFT them ---------- */
for ( UINT4 n = 0; n < numSFTs; n ++ )
{
SFTtype *thisSFT = &(sfts->data[n]);
/* find bin in long timeseries corresponding to starttime of *this* SFT */
REAL8 offset_n = XLALGPSDiff ( &(thisSFT->epoch), &start );
UINT4 bin0_n = lround ( offset_n / deltaT ); /* round to closest bin */
REAL8 nudge_n = bin0_n * deltaT - offset_n; /* rounding error */
nudge_n = 1e-9 * round ( nudge_n * 1e9 ); /* round to closest nanosecond */
/* nudge SFT into integer timestep bin if necessary */
XLAL_CHECK_NULL ( XLALTimeShiftSFT ( thisSFT, nudge_n ) == XLAL_SUCCESS, XLAL_EFUNC );
/* determine heterodyning phase-correction for this SFT */
REAL8 offset = XLALGPSDiff ( &thisSFT->epoch, &start ); // updated value after time-shift
// fHet * Tsft is an integer by construction, because fHet was chosen as a frequency-bin of the input SFTs
// therefore we only need the remainder (offset % Tsft)
REAL8 offsetEff = fmod ( offset, Tsft );
REAL8 hetCycles = fmod ( fHet * offsetEff, 1); // heterodyning phase-correction for this SFT
if ( nudge_n != 0 ){
XLALPrintInfo("n = %d, offset_n = %g, nudge_n = %g, offset = %g, offsetEff = %g, hetCycles = %g\n",
n, offset_n, nudge_n, offset, offsetEff, hetCycles );
}
REAL4 hetCorrection_re, hetCorrection_im;
XLAL_CHECK_NULL ( XLALSinCos2PiLUT ( &hetCorrection_im, &hetCorrection_re, -hetCycles ) == XLAL_SUCCESS, XLAL_EFUNC );
COMPLEX8 hetCorrection = crectf( hetCorrection_re, hetCorrection_im );
/* Note: we also bundle the overall normalization of 'df' into the het-correction.
* This ensures that the resulting timeseries will have the correct normalization, according to
* x_l = invFT[sft]_l = df * sum_{k=0}^{N-1} xt_k * e^(i 2pi k l / N )
* where x_l is the l-th timestamp, and xt_k is the k-th frequency bin of the SFT.
* See the LAL-conventions on FFTs: http://www.ligo.caltech.edu/docs/T/T010095-00.pdf
* (the FFTw convention does not contain the factor of 'df', which is why we need to
* apply it ourselves)
*
*/
hetCorrection *= dfSFT;
XLAL_CHECK_NULL ( XLALReorderSFTtoFFTW (thisSFT->data) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_NULL ( XLALCOMPLEX8VectorFFT( sTS->data, thisSFT->data, SFTplan ) == XLAL_SUCCESS, XLAL_EFUNC );
for ( UINT4 j=0; j < sTS->data->length; j++) {
sTS->data->data[j] *= hetCorrection;
} // for j < numFreqBinsSFT
// copy the short (shifted) heterodyned timeseries into correct location within long timeseries
UINT4 binsLeft = numSamples - bin0_n;
UINT4 copyLen = MYMIN ( numFreqBinsSFT, binsLeft ); /* make sure not to write past the end of the long TS */
memcpy ( &lTS->data->data[bin0_n], sTS->data->data, copyLen * sizeof(lTS->data->data[0]) );
} /* for n < numSFTs */
// cleanup memory
XLALDestroySFTVector ( sfts );
XLALDestroyCOMPLEX8TimeSeries ( sTS );
XLALDestroyCOMPLEX8FFTPlan ( SFTplan );
return lTS;
} // XLALSFTVectorToCOMPLEX8TimeSeries()
/**
* Single-IFO version of XLALCWMakeFakeMultiData(), handling the actual
* work, but same input API. The 'detectorIndex' has the index of the detector
* to be used from the multi-IFO arrays.
*/
int
XLALCWMakeFakeData ( SFTVector **SFTvect,
REAL8TimeSeries **Tseries,
const PulsarParamsVector *injectionSources,
const CWMFDataParams *dataParams,
UINT4 detectorIndex, /* index for current detector in dataParams */
const EphemerisData *edat
)
{
XLAL_CHECK ( (SFTvect == NULL) || ((*SFTvect) == NULL ), XLAL_EINVAL );
XLAL_CHECK ( (Tseries == NULL) || ((*Tseries) == NULL ), XLAL_EINVAL );
XLAL_CHECK ( (SFTvect != NULL) || (Tseries != NULL), XLAL_EINVAL );
XLAL_CHECK ( edat != NULL, XLAL_EINVAL );
XLAL_CHECK ( dataParams != NULL, XLAL_EINVAL );
XLAL_CHECK ( detectorIndex < dataParams->multiIFO.length, XLAL_EINVAL );
XLAL_CHECK ( detectorIndex < dataParams->multiNoiseFloor.length, XLAL_EINVAL );
XLAL_CHECK ( detectorIndex < dataParams->multiTimestamps.length, XLAL_EINVAL );
XLAL_CHECK ( (dataParams->inputMultiTS == NULL) || (detectorIndex < dataParams->inputMultiTS->length), XLAL_EINVAL );
XLAL_CHECK ( (dataParams->inputMultiTS == NULL) || (dataParams->fMin == 0 && dataParams->Band == 0), XLAL_EINVAL, "If given time-series, must have fMin=Band=0\n");
// initial default values fMin, sampling rate from caller input or timeseries
REAL8 fMin = dataParams->fMin;
REAL8 fBand = dataParams->Band;
REAL8 fSamp = 2.0 * fBand;
if ( dataParams->inputMultiTS != NULL )
{
XLAL_CHECK ( (fMin == 0) && (fBand == 0), XLAL_EINVAL, "fMin and fBand must be 0 if input timeseries is given\n");
const REAL8TimeSeries *ts = dataParams->inputMultiTS->data[detectorIndex];
XLAL_CHECK ( ts != NULL, XLAL_EINVAL );
REAL8 dt = ts->deltaT;
fMin = ts->f0;
fSamp = 1.0 / dt;
fBand = 0.5 * fSamp;
}
const LIGOTimeGPSVector *timestamps = dataParams->multiTimestamps.data[detectorIndex];
const LALDetector *site = &dataParams->multiIFO.sites[detectorIndex];
REAL8 Tsft = timestamps->deltaT;
// if SFT output requested: need *effective* fMin and Band consistent with SFT bins
if ( SFTvect )
{
UINT4 firstBinEff, numBinsEff;
XLAL_CHECK ( XLALFindCoveringSFTBins ( &firstBinEff, &numBinsEff, fMin, fBand, Tsft ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 fBand_eff = (numBinsEff - 1.0) / Tsft;
REAL8 fMin_eff = firstBinEff / Tsft;
REAL8 fMax = fMin + dataParams->Band;
REAL8 fMax_eff = fMin_eff + fBand_eff;
if ( (fMin_eff != fMin) || (fBand_eff != fBand ) ) {
XLALPrintWarning("Caller asked for Band [%.16g, %.16g] Hz, effective SFT-Band produced is [%.16g, %.16g] Hz\n",
fMin, fMax, fMin_eff, fMax_eff );
XLAL_CHECK ( dataParams->inputMultiTS == NULL, XLAL_EINVAL, "Cannot expand effective frequency band with input timeseries given. Timeseries seems inconsistent with SFTs\n");
fMin = fMin_eff; // (potentially) lower minimal frequency to fit SFT bins
fBand = fBand_eff;
fSamp = 2.0 * fBand_eff; // (potentially) higher sampling rate required to fit SFT bins
} // if (fMin_eff != fMin) || (fBand_eff != fBand)
} // if SFT-output requested
// characterize the output time-series
UINT4 n0_fSamp = (UINT4) round ( Tsft * fSamp );
// by construction, fSamp * Tsft = integer, but if there are gaps between SFTs,
// then we might have to sample at higher rates in order for all SFT-boundaries to
// fall on exact timesteps of the timeseries.
// ie we start from fsamp0 = n0_fSamp/Tsft, and then try to find the smallest
// n1_fSamp >= n0_fSamp, such that for fsamp1 = n1_fSamp/Tsft, for all gaps i: Dt_i * fsamp1 = int
UINT4 n1_fSamp;
XLAL_CHECK ( XLALFindSmallestValidSamplingRate ( &n1_fSamp, n0_fSamp, timestamps ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( n1_fSamp != n0_fSamp )
{
REAL8 fSamp1 = n1_fSamp / Tsft; // increased sampling rate to fit all gaps
XLALPrintWarning ( "GAPS: Initial SFT sampling frequency fSamp0= %d/%.0f = %g had to be increased to fSamp1 = %d/%.0f = %g\n",
n0_fSamp, Tsft, fSamp, n1_fSamp, Tsft, fSamp1 );
XLAL_CHECK ( dataParams->inputMultiTS == NULL, XLAL_EINVAL, "Cannot expand effective frequency band with input timeseries given. Timeseries seems inconsistent with SFT timestamps\n");
fSamp = fSamp1;
} // if higher effective sampling rate required
// ----- start-time and duration -----
LIGOTimeGPS firstGPS = timestamps->data[0];
REAL8 firstGPS_REAL8 = XLALGPSGetREAL8 ( &firstGPS );
LIGOTimeGPS lastGPS = timestamps->data [ timestamps->length - 1 ];
REAL8 lastGPS_REAL8 = XLALGPSGetREAL8 ( &lastGPS );
XLALGPSAdd( &lastGPS, Tsft );
REAL8 duration = XLALGPSDiff ( &lastGPS, &firstGPS );
// start with an empty output time-series
REAL4TimeSeries *Tseries_sum;
{
REAL8 numSteps = ceil ( fSamp * duration );
XLAL_CHECK ( numSteps < (REAL8)LAL_UINT4_MAX, XLAL_EDOM, "Sorry, time-series of %g samples too long to fit into REAL4TimeSeries (maxLen = %g)\n", numSteps, (REAL8)LAL_UINT4_MAX );
REAL8 dt = 1.0 / fSamp;
REAL8 fHeterodyne = fMin; // heterodyne signals at lower end of frequency-band
CHAR *detPrefix = XLALGetChannelPrefix ( site->frDetector.name );
XLAL_CHECK ( (Tseries_sum = XLALCreateREAL4TimeSeries ( detPrefix, &firstGPS, fHeterodyne, dt, &lalStrainUnit, (UINT4)numSteps )) != NULL, XLAL_EFUNC );
memset ( Tseries_sum->data->data, 0, Tseries_sum->data->length * sizeof(Tseries_sum->data->data[0]) );
XLALFree ( detPrefix );
} // generate empty timeseries
// add CW signals, if any
UINT4 numPulsars = injectionSources ? injectionSources->length : 0;
for ( UINT4 iInj = 0; iInj < numPulsars; iInj ++ )
{
// truncate any transient-CW timeseries to the actual support of the transient signal,
// in order to make the generation more efficient, these 'partial timeseries'
// will then be added to the full timeseries
const PulsarParams *pulsarParams = &( injectionSources->data[iInj] );
UINT4 t0, t1;
XLAL_CHECK ( XLALGetTransientWindowTimespan ( &t0, &t1, pulsarParams->Transient ) == XLAL_SUCCESS, XLAL_EFUNC );
// use latest possible start-time: max(t0,firstGPS), but not later than than lastGPS
LIGOTimeGPS XLAL_INIT_DECL(signalStartGPS);
if ( t0 <= firstGPS_REAL8 ) {
signalStartGPS = firstGPS;
} else if ( t0 >= lastGPS_REAL8 ) {
signalStartGPS = lastGPS;
}
else {
signalStartGPS.gpsSeconds = t0;
}
// use earliest possible end-time: min(t1,lastGPS), but not earlier than firstGPS
LIGOTimeGPS XLAL_INIT_DECL(signalEndGPS);
if ( t1 >= lastGPS_REAL8 ) {
signalEndGPS = lastGPS;
} else if ( t1 <= firstGPS_REAL8 ) {
signalEndGPS = firstGPS;
} else {
signalEndGPS.gpsSeconds = t1;
}
REAL8 signalDuration = XLALGPSDiff ( &signalEndGPS, &signalStartGPS );
XLAL_CHECK ( signalDuration >= 0, XLAL_EFAILED, "Something went wrong, got negative signal duration = %g\n", signalDuration );
if ( signalDuration > 0 ) // only need to do sth if transient-window had finite overlap with output TS
{
REAL4TimeSeries *Tseries_i = NULL;
XLAL_CHECK ( (Tseries_i = XLALGenerateCWSignalTS ( pulsarParams, site, signalStartGPS, signalDuration, fSamp, fMin, edat )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (Tseries_sum = XLALAddREAL4TimeSeries ( Tseries_sum, Tseries_i )) != NULL, XLAL_EFUNC );
XLALDestroyREAL4TimeSeries ( Tseries_i );
}
} // for iInj < numSources
/* add Gaussian noise if requested */
REAL8 sqrtSn = dataParams->multiNoiseFloor.sqrtSn[detectorIndex];
if ( sqrtSn > 0)
{
REAL8 noiseSigma = sqrtSn * sqrt ( 0.5 * fSamp );
INT4 randSeed = (dataParams->randSeed == 0) ? 0 : (dataParams->randSeed + detectorIndex); // seed=0 means to use /dev/urandom, so don't touch it
XLAL_CHECK ( XLALAddGaussianNoise ( Tseries_sum, noiseSigma, randSeed ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// convert final signal+Gaussian-noise timeseries into REAL8 precision:
REAL8TimeSeries *outTS;
XLAL_CHECK ( (outTS = XLALConvertREAL4TimeSeriesToREAL8 ( Tseries_sum )) != NULL, XLAL_EFUNC );
XLALDestroyREAL4TimeSeries ( Tseries_sum );
// add input noise time-series here if given
if ( dataParams->inputMultiTS != NULL ) {
XLAL_CHECK ( (outTS = XLALAddREAL8TimeSeries ( outTS, dataParams->inputMultiTS->data[detectorIndex] )) != NULL, XLAL_EFUNC );
}
// turn final timeseries into SFTs, if requested
if ( SFTvect != NULL )
{
// compute SFTs from timeseries
SFTVector *sftVect;
XLAL_CHECK ( (sftVect = XLALMakeSFTsFromREAL8TimeSeries ( outTS, timestamps, dataParams->SFTWindowType, dataParams->SFTWindowBeta)) != NULL, XLAL_EFUNC );
// extract effective band from this, if neccessary (ie if faster-sampled output SFTs)
if ( n1_fSamp != n0_fSamp )
{
XLAL_CHECK ( ((*SFTvect) = XLALExtractBandFromSFTVector ( sftVect, fMin, fBand )) != NULL, XLAL_EFUNC );
XLALDestroySFTVector ( sftVect );
}
else
{
(*SFTvect) = sftVect;
}
} // if SFTvect
// return timeseries if requested
if ( Tseries != NULL ) {
(*Tseries) = outTS;
} else {
XLALDestroyREAL8TimeSeries ( outTS );
}
return XLAL_SUCCESS;
} // XLALCWMakeFakeData()
/* void RunGeneratePulsarSignalTest(LALStatus *status, int argc, char **argv) */ /* 02/02/05 gam */
void RunGeneratePulsarSignalTest(LALStatus *status)
{
INT4 i, j, k; /* all purpose indices */
INT4 iSky = 0; /* for loop over sky positions */
INT4 jDeriv = 0; /* for loop over spindowns */
INT4 testNumber = 0; /* which test is being run */
/* The input and output structs used by the functions being tested */
PulsarSignalParams *pPulsarSignalParams = NULL;
REAL4TimeSeries *signalvec = NULL;
SFTParams *pSFTParams = NULL;
SkyConstAndZeroPsiAMResponse *pSkyConstAndZeroPsiAMResponse;
SFTandSignalParams *pSFTandSignalParams;
SFTVector *outputSFTs = NULL;
SFTVector *fastOutputSFTs = NULL;
REAL4 renorm; /* to renormalize SFTs to account for different effective sample rates */
/* containers for detector and ephemeris data */
LALDetector cachedDetector;
CHAR IFO[6] = "LHO";
EphemerisData *edat = NULL;
char earthFile[] = TEST_DATA_DIR "earth00-19-DE405.dat.gz";
char sunFile[] = TEST_DATA_DIR "sun00-19-DE405.dat.gz";
/* containers for sky position and spindown data */
REAL8 **skyPosData;
REAL8 **freqDerivData;
INT4 numSkyPosTotal = 8;
INT4 numSpinDown = 1;
INT4 numFreqDerivTotal = 2;
INT4 numFreqDerivIncludingNoSpinDown; /* set below */
INT4 iFreq = 0;
REAL8 cosTmpDEC;
REAL8 tmpDeltaRA;
REAL8 DeltaRA = 0.01;
REAL8 DeltaDec = 0.01;
REAL8 DeltaFDeriv1 = -1.0e-10;
REAL8 DeltaFDeriv2 = 0.0;
REAL8 DeltaFDeriv3 = 0.0;
REAL8 DeltaFDeriv4 = 0.0;
REAL8 DeltaFDeriv5 = 0.0;
/* containers for number of SFTs, times to generate SFTs, reference time, and gap */
INT4 numSFTs = 4;
REAL8 f0SFT = 943.12;
REAL8 bandSFT = 0.5;
UINT4 gpsStartTimeSec = 765432109; /* GPS start time of data requested seconds; example = Apr 08 2004 04:01:36 UTC */
UINT4 gpsStartTimeNan = 0; /* GPS start time of data requested nanoseconds */
LIGOTimeGPSVector *timeStamps;
LIGOTimeGPS GPSin; /* holder for reference-time for pulsar parameters at the detector; will convert to SSB! */
REAL8 sftGap = 73.0; /* extra artificial gap between SFTs */
REAL8 tSFT = 1800.0;
REAL8 duration = tSFT + (numSFTs - 1)*(tSFT + sftGap);
INT4 nBinsSFT = (INT4)(bandSFT*tSFT + 0.5);
/* additional parameters that determine what signals to test; note f0SGNL and bandSGNL must be compatible with f0SFT and bandSFT */
REAL8 f0SGNL = f0SFT + bandSFT/2.0;
REAL8 dfSGNL = 1.0/tSFT;
REAL8 bandSGNL = 0.005;
INT4 nBinsSGNL = (INT4)(bandSGNL*tSFT + 0.5);
INT4 nsamples = 18000; /* nsamples from SFT header; 2 x this would be the effective number of time samples used to create an SFT from raw data */
INT4 Dterms = 3; /* 09/07/05 gam; use Dterms to fill in SFT bins with fake data as per LALDemod else fill in bin with zero */
REAL8 h_0 = 7.0e-22; /* Source amplitude; use arbitrary small number for default */
REAL8 cosIota; /* cosine of inclination angle iota of the source */
/* variables for comparing differences */
REAL4 maxDiffSFTMod, diffAtMaxPower;
REAL4 overallMaxDiffSFTMod;
REAL4 maxMod, fastMaxMod;
INT4 jMaxMod, jFastMaxMod;
REAL4 tmpDiffSFTMod, sftMod, fastSFTMod;
REAL4 smallMod = 1.e-30;
REAL4 epsDiffMod;
REAL4 epsBinErrorRate; /* 10/12/04 gam; Allowed bin error rate */
INT4 binErrorCount = 0; /* 10/12/04 gam; Count number of bin errors */
/* randval is always set to a default value or given a random value to generate certain signal parameters or mismatch */
REAL4 randval;
#ifdef INCLUDE_RANDVAL_MISMATCH
INT4 seed=0;
INT4 rndCount;
RandomParams *randPar=NULL;
FILE *fpRandom;
#endif
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* generate timeStamps */
timeStamps = (LIGOTimeGPSVector *)LALMalloc(sizeof(LIGOTimeGPSVector));
timeStamps->data =(LIGOTimeGPS *)LALMalloc (numSFTs*sizeof(LIGOTimeGPS));
timeStamps->length = numSFTs;
for (i = 0; i < numSFTs; i++) {
timeStamps->data[i].gpsSeconds = gpsStartTimeSec + (UINT4)(i*(tSFT + sftGap));
timeStamps->data[i].gpsNanoSeconds = 0;
} /* for i < numSFTs */
/* generate skyPosData */
skyPosData=(REAL8 **)LALMalloc(numSkyPosTotal*sizeof(REAL8 *));
for(iSky=0;iSky<numSkyPosTotal;iSky++)
{
skyPosData[iSky] = (REAL8 *)LALMalloc(2*sizeof(REAL8));
/* Try fairly random sky positions skyPosData[iSky][0] = RA, skyPosData[iSky][1] = DEC */
if (iSky == 0) {
skyPosData[iSky][0] = 0.02*LAL_TWOPI;
skyPosData[iSky][1] = 0.03*LAL_PI/2.0;
} else if (iSky == 1) {
skyPosData[iSky][0] = 0.23*LAL_TWOPI;
skyPosData[iSky][1] = -0.57*LAL_PI/2.0;
} else if (iSky == 2) {
skyPosData[iSky][0] = 0.47*LAL_TWOPI;
skyPosData[iSky][1] = 0.86*LAL_PI/2.0;
} else if (iSky == 3) {
skyPosData[iSky][0] = 0.38*LAL_TWOPI;
skyPosData[iSky][1] = -0.07*LAL_PI/2.0;
} else if (iSky == 4) {
skyPosData[iSky][0] = 0.65*LAL_TWOPI;
skyPosData[iSky][1] = 0.99*LAL_PI/2.0;
} else if (iSky == 5) {
skyPosData[iSky][0] = 0.72*LAL_TWOPI;
skyPosData[iSky][1] = -0.99*LAL_PI/2.0;
} else if (iSky == 6) {
skyPosData[iSky][0] = 0.81*LAL_TWOPI;
skyPosData[iSky][1] = 0.19*LAL_PI/2.0;
} else if (iSky == 7) {
skyPosData[iSky][0] = 0.99*LAL_TWOPI;
skyPosData[iSky][1] = 0.01*LAL_PI/2.0;
} else {
skyPosData[iSky][0] = 0.0;
skyPosData[iSky][1] = 0.0;
} /* END if (k == 0) ELSE ... */
} /* END for(iSky=0;iSky<numSkyPosTotal;iSky++) */
freqDerivData = NULL; /* 02/02/05 gam */
if (numSpinDown > 0) {
freqDerivData=(REAL8 **)LALMalloc(numFreqDerivTotal*sizeof(REAL8 *));
for(jDeriv=0;jDeriv<numFreqDerivTotal;jDeriv++) {
freqDerivData[jDeriv] = (REAL8 *)LALMalloc(numSpinDown*sizeof(REAL8));
if (jDeriv == 0) {
for(k=0;k<numSpinDown;k++) {
freqDerivData[jDeriv][k] = 0.0;
}
} else if (jDeriv == 1) {
for(k=0;k<numSpinDown;k++) {
freqDerivData[jDeriv][k] = 1.e-9; /* REALLY THIS IS ONLY GOOD FOR numSpinDown = 1; */
}
} else {
for(k=0;k<numSpinDown;k++) {
freqDerivData[jDeriv][k] = 0.0;
}
} /* END if (k == 0) ELSE ... */
} /* END for(jDeriv=0;jDeriv<numFreqDerivTotal;jDeriv++) */
numFreqDerivIncludingNoSpinDown = numFreqDerivTotal;
} else {
numFreqDerivIncludingNoSpinDown = 1; /* Even if numSpinDown = 0 still need to count case of zero spindown. */
} /* END if (numSpinDown > 0) ELSE ... */
/* Initialize ephemeris data */
XLAL_CHECK_LAL (status, ( edat = XLALInitBarycenter( earthFile, sunFile ) ) != NULL, XLAL_EFUNC);
/* Allocate memory for PulsarSignalParams and initialize */
pPulsarSignalParams = (PulsarSignalParams *)LALMalloc(sizeof(PulsarSignalParams));
pPulsarSignalParams->pulsar.position.system = COORDINATESYSTEM_EQUATORIAL;
pPulsarSignalParams->pulsar.spindown = NULL;
if (numSpinDown > 0) {
LALDCreateVector(status->statusPtr, &(pPulsarSignalParams->pulsar.spindown),((UINT4)numSpinDown));
CHECKSTATUSPTR (status);
}
pPulsarSignalParams->orbit.asini = 0 /* isolated pulsar */;
pPulsarSignalParams->transfer = NULL;
pPulsarSignalParams->dtDelayBy2 = 0;
pPulsarSignalParams->dtPolBy2 = 0;
/* Set up pulsar site */
if (strstr(IFO, "LHO")) {
cachedDetector = lalCachedDetectors[LALDetectorIndexLHODIFF];
} else if (strstr(IFO, "LLO")) {
cachedDetector = lalCachedDetectors[LALDetectorIndexLLODIFF];
} else if (strstr(IFO, "GEO")) {
cachedDetector = lalCachedDetectors[LALDetectorIndexGEO600DIFF];
} else if (strstr(IFO, "VIRGO")) {
cachedDetector = lalCachedDetectors[LALDetectorIndexVIRGODIFF];
} else if (strstr(IFO, "TAMA")) {
cachedDetector = lalCachedDetectors[LALDetectorIndexTAMA300DIFF];
} else {
/* "Invalid or null IFO" */
ABORT( status, GENERATEPULSARSIGNALTESTC_EIFO, GENERATEPULSARSIGNALTESTC_MSGEIFO);
}
pPulsarSignalParams->site = &cachedDetector;
pPulsarSignalParams->ephemerides = edat;
pPulsarSignalParams->startTimeGPS.gpsSeconds = (INT4)gpsStartTimeSec;
pPulsarSignalParams->startTimeGPS.gpsNanoSeconds = (INT4)gpsStartTimeNan;
pPulsarSignalParams->duration = (UINT4)duration;
pPulsarSignalParams->samplingRate = (REAL8)ceil(2.0*bandSFT); /* Make sampleRate an integer so that T*samplingRate = integer for integer T */
pPulsarSignalParams->fHeterodyne = f0SFT;
GPSin.gpsSeconds = timeStamps->data[0].gpsSeconds;
GPSin.gpsNanoSeconds = timeStamps->data[0].gpsNanoSeconds;
/* Allocate memory for SFTParams and initialize */
pSFTParams = (SFTParams *)LALCalloc(1, sizeof(SFTParams));
pSFTParams->Tsft = tSFT;
pSFTParams->timestamps = timeStamps;
pSFTParams->noiseSFTs = NULL;
#ifdef INCLUDE_RANDVAL_MISMATCH
/* Initial seed and randPar to use LALUniformDeviate to generate random mismatch during Monte Carlo. */
fpRandom = fopen("/dev/urandom","r");
rndCount = fread(&seed, sizeof(INT4),1, fpRandom);
fclose(fpRandom);
/* seed = 1234; */ /* Test value */
LALCreateRandomParams(status->statusPtr, &randPar, seed);
CHECKSTATUSPTR (status);
#endif
/* allocate memory for structs needed by LALComputeSkyAndZeroPsiAMResponse and LALFastGeneratePulsarSFTs */
pSkyConstAndZeroPsiAMResponse = (SkyConstAndZeroPsiAMResponse *)LALMalloc(sizeof(SkyConstAndZeroPsiAMResponse));
pSkyConstAndZeroPsiAMResponse->skyConst = (REAL8 *)LALMalloc((2*numSpinDown*(numSFTs+1)+2*numSFTs+3)*sizeof(REAL8));
pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi = (REAL4 *)LALMalloc(numSFTs*sizeof(REAL4));
pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi = (REAL4 *)LALMalloc(numSFTs*sizeof(REAL4));
pSFTandSignalParams = (SFTandSignalParams *)LALMalloc(sizeof(SFTandSignalParams));
/* create lookup table (LUT) values for doing trig */
/* pSFTandSignalParams->resTrig = 64; */ /* length sinVal and cosVal; resolution of trig functions = 2pi/resTrig */
/* pSFTandSignalParams->resTrig = 128; */ /* 10/08/04 gam; length sinVal and cosVal; domain = -2pi to 2pi inclusive; resolution = 4pi/resTrig */
pSFTandSignalParams->resTrig = 0; /* 10/12/04 gam; turn off using LUTs since this is more typical. */
/* 02/02/05 gam; if NOT pSFTandSignalParams->resTrig > 0 should not create trigArg etc... */
if (pSFTandSignalParams->resTrig > 0) {
pSFTandSignalParams->trigArg = (REAL8 *)LALMalloc((pSFTandSignalParams->resTrig+1)*sizeof(REAL8));
pSFTandSignalParams->sinVal = (REAL8 *)LALMalloc((pSFTandSignalParams->resTrig+1)*sizeof(REAL8));
pSFTandSignalParams->cosVal = (REAL8 *)LALMalloc((pSFTandSignalParams->resTrig+1)*sizeof(REAL8));
for (k=0; k<=pSFTandSignalParams->resTrig; k++) {
/* pSFTandSignalParams->trigArg[k]= ((REAL8)LAL_TWOPI) * ((REAL8)k) / ((REAL8)pSFTandSignalParams->resTrig); */ /* 10/08/04 gam */
pSFTandSignalParams->trigArg[k]= -1.0*((REAL8)LAL_TWOPI) + 2.0 * ((REAL8)LAL_TWOPI) * ((REAL8)k) / ((REAL8)pSFTandSignalParams->resTrig);
pSFTandSignalParams->sinVal[k]=sin( pSFTandSignalParams->trigArg[k] );
pSFTandSignalParams->cosVal[k]=cos( pSFTandSignalParams->trigArg[k] );
}
}
pSFTandSignalParams->pSigParams = pPulsarSignalParams;
pSFTandSignalParams->pSFTParams = pSFTParams;
pSFTandSignalParams->nSamples = nsamples;
pSFTandSignalParams->Dterms = Dterms; /* 09/07/05 gam */
/* ********************************************************/
/* */
/* START SECTION: LOOP OVER SKY POSITIONS */
/* */
/* ********************************************************/
for(iSky=0;iSky<numSkyPosTotal;iSky++) {
/* set source sky position declination (DEC) */
randval = 0.5; /* Gives default value */
#ifdef INCLUDE_SEQUENTIAL_MISMATCH
randval = ( (REAL4)(iSky) )/( (REAL4)(numSkyPosTotal) );
#endif
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
pPulsarSignalParams->pulsar.position.latitude = skyPosData[iSky][1] + (((REAL8)randval) - 0.5)*DeltaDec;
cosTmpDEC = cos(skyPosData[iSky][1]);
if (cosTmpDEC != 0.0) {
tmpDeltaRA = DeltaRA/cosTmpDEC;
} else {
tmpDeltaRA = 0.0; /* We are at a celestial pole */
}
/* set source sky position right ascension (RA) */
randval = 0.5; /* Gives default value */
#ifdef INCLUDE_SEQUENTIAL_MISMATCH
randval = ( (REAL4)(iSky) )/( (REAL4)(numSkyPosTotal) );
#endif
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
pPulsarSignalParams->pulsar.position.longitude = skyPosData[iSky][0] + (((REAL8)randval) - 0.5)*tmpDeltaRA;
/* Find reference time in SSB for this sky positions */
int ret = XLALConvertGPS2SSB ( &(pPulsarSignalParams->pulsar.refTime), GPSin, pPulsarSignalParams );
if ( ret != XLAL_SUCCESS ) {
XLALPrintError ("XLALConvertGPS2SSB() failed with xlalErrno = %d\n", xlalErrno );
ABORTXLAL (status);
}
/* one per sky position fill in SkyConstAndZeroPsiAMResponse for use with LALFastGeneratePulsarSFTs */
LALComputeSkyAndZeroPsiAMResponse (status->statusPtr, pSkyConstAndZeroPsiAMResponse, pSFTandSignalParams);
CHECKSTATUSPTR (status);
/* ********************************************************/
/* */
/* START SECTION: LOOP OVER SPINDOWN */
/* */
/* ********************************************************/
for(jDeriv=0;jDeriv<numFreqDerivIncludingNoSpinDown;jDeriv++) {
/* source spindown parameters */
if (numSpinDown > 0) {
for(k=0;k<numSpinDown;k++) {
randval = 0.5; /* Gives default value */
#ifdef INCLUDE_SEQUENTIAL_MISMATCH
if (freqDerivData[jDeriv][k] < 0.0) {
randval = ( (REAL4)(iSky) )/( (REAL4)(numSkyPosTotal) );
} else {
randval = 0.5; /* If derivative is not negative (i.e., it is zero) then do not add in mismatch; keep it zero. */
}
#endif
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
if (k == 0) {
pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv1;
} else if (k == 1) {
pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv2;
} else if (k == 2) {
pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv3;
} else if (k == 3) {
pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv4;
} else if (k == 4) {
pPulsarSignalParams->pulsar.spindown->data[k] = freqDerivData[jDeriv][k] + (((REAL8)randval) - 0.5)*DeltaFDeriv5;
} /* END if (k == 0) ELSE ... */
}
}
/* ***************************************************/
/* */
/* START SECTION: LOOP OVER FREQUENCIES */
/* */
/* ***************************************************/
for(iFreq=0;iFreq<nBinsSGNL;iFreq++) {
/* set source orientation psi */
randval = 0.5; /* Gives default value */
#ifdef INCLUDE_SEQUENTIAL_MISMATCH
randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) );
#endif
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
pPulsarSignalParams->pulsar.psi = (randval - 0.5) * ((REAL4)LAL_PI_2);
/* set angle between source spin axis and direction from source to SSB, cosIota */
randval = 1.0; /* Gives default value */
#ifdef INCLUDE_SEQUENTIAL_MISMATCH
randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) );
#endif
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
cosIota = 2.0*((REAL8)randval) - 1.0;
/* h_0 is fixed above; get A_+ and A_x from h_0 and cosIota */
pPulsarSignalParams->pulsar.aPlus = (REAL4)(0.5*h_0*(1.0 + cosIota*cosIota));
pPulsarSignalParams->pulsar.aCross = (REAL4)(h_0*cosIota);
/* get random value for phi0 */
randval = 0.125; /* Gives default value pi/4*/
#ifdef INCLUDE_SEQUENTIAL_MISMATCH
randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) );
#endif
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
pPulsarSignalParams->pulsar.phi0 = ((REAL8)randval) * ((REAL8)LAL_TWOPI);
/* randval steps through various mismatches to frequencies centered on a bin */
/* Note that iFreq = nBinsSGNL/2 gives randval = 0.5 gives no mismatch from frequency centered on a bin */
randval = ( (REAL4)(iFreq) )/( (REAL4)(nBinsSGNL) );
#ifdef INCLUDE_RANDVAL_MISMATCH
LALUniformDeviate(status->statusPtr, &randval, randPar); CHECKSTATUSPTR (status);
#endif
pPulsarSignalParams->pulsar.f0 = f0SGNL + iFreq*dfSGNL + (((REAL8)randval) - 0.5)*dfSGNL;
testNumber++; /* Update count of which test we about to do. */
/* FIRST: Use LALGeneratePulsarSignal and LALSignalToSFTs to generate outputSFTs */
signalvec = NULL;
LALGeneratePulsarSignal(status->statusPtr, &signalvec, pPulsarSignalParams);
CHECKSTATUSPTR (status);
outputSFTs = NULL;
LALSignalToSFTs(status->statusPtr, &outputSFTs, signalvec, pSFTParams);
CHECKSTATUSPTR (status);
#ifdef PRINT_OUTPUTSFT
if (testNumber == TESTNUMBER_TO_PRINT) {
i=SFTINDEX_TO_PRINT; /* index of which outputSFT to output */
fprintf(stdout,"iFreq = %i, inject h_0 = %23.10e \n",iFreq,h_0);
fprintf(stdout,"iFreq = %i, inject cosIota = %23.10e, A_+ = %23.10e, A_x = %23.10e \n",iFreq,cosIota,pPulsarSignalParams->pulsar.aPlus,pPulsarSignalParams->pulsar.aCross);
fprintf(stdout,"iFreq = %i, inject psi = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.psi);
fprintf(stdout,"iFreq = %i, inject phi0 = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.phi0);
fprintf(stdout,"iFreq = %i, search f0 = %23.10e, inject f0 = %23.10e \n",iFreq,f0SGNL + iFreq*dfSGNL,pPulsarSignalParams->pulsar.f0);
fprintf(stdout,"outputSFTs->data[%i].data->length = %i \n",i,outputSFTs->data[i].data->length);
renorm = ((REAL4)nsamples)/((REAL4)(outputSFTs->data[i].data->length - 1));
for(j=0;j<nBinsSFT;j++) {
/* fprintf(stdout,"%i %g %g \n", j, renorm*outputSFTs->data[i].data->data[j].re, renorm*outputSFTs->data[i].data->data[j].im); */
fprintf(stdout,"%i %g \n",j,renorm*renorm*outputSFTs->data[i].data->data[j].re*outputSFTs->data[i].data->data[j].re + renorm*renorm*outputSFTs->data[i].data->data[j].im*outputSFTs->data[i].data->data[j].im);
fflush(stdout);
}
}
#endif
/* SECOND: Use LALComputeSkyAndZeroPsiAMResponse and LALFastGeneratePulsarSFTs to generate outputSFTs */
LALFastGeneratePulsarSFTs (status->statusPtr, &fastOutputSFTs, pSkyConstAndZeroPsiAMResponse, pSFTandSignalParams);
CHECKSTATUSPTR (status);
#ifdef PRINT_FASTOUTPUTSFT
if (testNumber == TESTNUMBER_TO_PRINT) {
REAL4 fPlus;
REAL4 fCross;
i=SFTINDEX_TO_PRINT; /* index of which outputSFT to output */
fPlus = pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi[i]*cos(2.0*pPulsarSignalParams->pulsar.psi) + pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi[i]*sin(2.0*pPulsarSignalParams->pulsar.psi);
fCross = pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi[i]*cos(2.0*pPulsarSignalParams->pulsar.psi) - pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi[i]*sin(2.0*pPulsarSignalParams->pulsar.psi);
fprintf(stdout,"iFreq = %i, inject h_0 = %23.10e \n",iFreq,h_0);
fprintf(stdout,"iFreq = %i, inject cosIota = %23.10e, A_+ = %23.10e, A_x = %23.10e \n",iFreq,cosIota,pPulsarSignalParams->pulsar.aPlus,pPulsarSignalParams->pulsar.aCross);
fprintf(stdout,"iFreq = %i, inject psi = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.psi);
fprintf(stdout,"iFreq = %i, fPlus, fCross = %23.10e, %23.10e \n",iFreq,fPlus,fCross);
fprintf(stdout,"iFreq = %i, inject phi0 = %23.10e \n",iFreq,pPulsarSignalParams->pulsar.phi0);
fprintf(stdout,"iFreq = %i, search f0 = %23.10e, inject f0 = %23.10e \n",iFreq,f0SGNL + iFreq*dfSGNL,pPulsarSignalParams->pulsar.f0);
fprintf(stdout,"fastOutputSFTs->data[%i].data->length = %i \n",i,fastOutputSFTs->data[i].data->length);
fflush(stdout);
for(j=0;j<nBinsSFT;j++) {
/* fprintf(stdout,"%i %g %g \n",j,fastOutputSFTs->data[i].data->data[j].re,fastOutputSFTs->data[i].data->data[j].im); */
fprintf(stdout,"%i %g \n",j,fastOutputSFTs->data[i].data->data[j].re*fastOutputSFTs->data[i].data->data[j].re + fastOutputSFTs->data[i].data->data[j].im*fastOutputSFTs->data[i].data->data[j].im);
fflush(stdout);
}
}
#endif
/* find maximum difference in power */
epsDiffMod = 0.20; /* maximum allowed percent difference */ /* 10/12/04 gam */
overallMaxDiffSFTMod = 0.0;
for (i = 0; i < numSFTs; i++) {
renorm = ((REAL4)nsamples)/((REAL4)(outputSFTs->data[i].data->length - 1));
maxDiffSFTMod = 0.0;
diffAtMaxPower = 0.0;
maxMod = 0.0;
fastMaxMod = 0.0;
jMaxMod = -1;
jFastMaxMod = -1;
/* Since doppler shifts can move the signal by an unknown number of bins search the whole band for max modulus: */
for(j=0;j<nBinsSFT;j++) {
sftMod = renorm*renorm*crealf(outputSFTs->data[i].data->data[j])*crealf(outputSFTs->data[i].data->data[j]) + renorm*renorm*cimagf(outputSFTs->data[i].data->data[j])*cimagf(outputSFTs->data[i].data->data[j]);
sftMod = sqrt(sftMod);
fastSFTMod = crealf(fastOutputSFTs->data[i].data->data[j])*crealf(fastOutputSFTs->data[i].data->data[j]) + cimagf(fastOutputSFTs->data[i].data->data[j])*cimagf(fastOutputSFTs->data[i].data->data[j]);
fastSFTMod = sqrt(fastSFTMod);
if (fabs(sftMod) > smallMod) {
tmpDiffSFTMod = fabs((sftMod - fastSFTMod)/sftMod);
if (tmpDiffSFTMod > maxDiffSFTMod) {
maxDiffSFTMod = tmpDiffSFTMod;
}
if (tmpDiffSFTMod > overallMaxDiffSFTMod) {
overallMaxDiffSFTMod = tmpDiffSFTMod;
}
if (sftMod > maxMod) {
maxMod = sftMod;
jMaxMod = j;
}
if (fastSFTMod > fastMaxMod) {
fastMaxMod = fastSFTMod;
jFastMaxMod = j;
}
}
}
if (fabs(maxMod) > smallMod) {
diffAtMaxPower = fabs((maxMod - fastMaxMod)/maxMod);
}
#ifdef PRINT_MAXSFTPOWER
fprintf(stdout,"maxSFTMod, testNumber %i, SFT %i, bin %i = %g \n",testNumber,i,jMaxMod,maxMod);
fprintf(stdout,"maxFastSFTMod, testNumber %i, SFT %i, bin %i = %g \n",testNumber,i,jFastMaxMod,fastMaxMod);
fflush(stdout);
#endif
#ifdef PRINT_MAXDIFFSFTPOWER
fprintf(stdout,"maxDiffSFTMod, testNumber %i, SFT %i, bin %i = %g \n",testNumber,i,jMaxDiff,maxDiffSFTMod);
fflush(stdout);
#endif
#ifdef PRINT_DIFFATMAXPOWER
fprintf(stdout,"diffAtMaxPower, testNumber %i, SFT %i, bins %i and %i = %g \n",testNumber,i,jMaxMod,jFastMaxMod,diffAtMaxPower);
fflush(stdout);
#endif
#ifdef PRINT_ERRORATMAXPOWER
if (diffAtMaxPower > epsDiffMod) {
fprintf(stdout,"diffAtMaxPower, testNumber %i, SFT %i, bins %i and %i = %g exceeded epsDiffMod = %g \n",testNumber,i,jMaxMod,jFastMaxMod,diffAtMaxPower,epsDiffMod);
fflush(stdout);
/* break; */ /* only report 1 error per test */
}
if (jMaxMod != jFastMaxMod) {
fprintf(stdout,"MaxPower occurred in different bins: testNumber %i, SFT %i, bins %i and %i\n",testNumber,i,jMaxMod,jFastMaxMod);
fflush(stdout);
/* break; */ /* only report 1 error per test */
}
#endif
if (jMaxMod != jFastMaxMod) {
binErrorCount++; /* 10/12/04 gam; count up bin errors; if too ABORT at bottom of code */
}
if ( diffAtMaxPower > epsDiffMod ) {
ABORT( status, GENERATEPULSARSIGNALTESTC_EMOD, GENERATEPULSARSIGNALTESTC_MSGEMOD);
}
/* 10/12/04 gam; turn on test above and add test below */
if ( fabs(((REAL8)(jMaxMod - jFastMaxMod))) > 1.1 ) {
ABORT( status, GENERATEPULSARSIGNALTESTC_EBIN, GENERATEPULSARSIGNALTESTC_MSGEBIN);
}
} /* END for(i = 0; i < numSFTs; i++) */
#ifdef PRINT_OVERALLMAXDIFFSFTPOWER
fprintf(stdout,"overallMaxDiffSFTMod, testNumber = %i, SFT %i, bin %i = %g \n",testNumber,iOverallMaxDiffSFTMod,jOverallMaxDiff,overallMaxDiffSFTMod);
fflush(stdout);
#endif
/* 09/07/05 gam; Initialize fastOutputSFTs since only 2*Dterms bins are changed by LALFastGeneratePulsarSFTs */
for (i = 0; i < numSFTs; i++) {
for(j=0;j<nBinsSFT;j++) {
fastOutputSFTs->data[i].data->data[j] = 0.0;
}
}
XLALDestroySFTVector( outputSFTs);
LALFree(signalvec->data->data);
LALFree(signalvec->data);
LALFree(signalvec);
} /* END for(iFreq=0;iFreq<nBinsSGNL;iFreq++) */
/* ***************************************************/
/* */
/* END SECTION: LOOP OVER FREQUENCIES */
/* */
/* ***************************************************/
} /* END for(jDeriv=0;jDeriv<numFreqDerivIncludingNoSpinDown;jDeriv++) */
/* ********************************************************/
/* */
/* END SECTION: LOOP OVER SPINDOWN */
/* */
/* ********************************************************/
} /* END for(iSky=0;iSky<numSkyPosTotal;iSky++) */
/* ********************************************************/
/* */
/* END SECTION: LOOP OVER SKY POSITIONS */
/* */
/* ********************************************************/
/* 10/12/04 gam; check if too many bin errors */
epsBinErrorRate = 0.20; /* 10/12/04 gam; maximum allowed bin errors */
if ( (((REAL4)binErrorCount)/((REAL4)testNumber)) > epsBinErrorRate ) {
ABORT( status, GENERATEPULSARSIGNALTESTC_EBINS, GENERATEPULSARSIGNALTESTC_MSGEBINS);
}
#ifdef INCLUDE_RANDVAL_MISMATCH
LALDestroyRandomParams(status->statusPtr, &randPar);
CHECKSTATUSPTR (status);
#endif
/* fprintf(stdout,"Total number of tests completed = %i. \n", testNumber);
fflush(stdout); */
LALFree(pSFTParams);
if (numSpinDown > 0) {
LALDDestroyVector(status->statusPtr, &(pPulsarSignalParams->pulsar.spindown));
CHECKSTATUSPTR (status);
}
LALFree(pPulsarSignalParams);
/* deallocate memory for structs needed by LALComputeSkyAndZeroPsiAMResponse and LALFastGeneratePulsarSFTs */
XLALDestroySFTVector( fastOutputSFTs);
LALFree(pSkyConstAndZeroPsiAMResponse->fCrossZeroPsi);
LALFree(pSkyConstAndZeroPsiAMResponse->fPlusZeroPsi);
LALFree(pSkyConstAndZeroPsiAMResponse->skyConst);
LALFree(pSkyConstAndZeroPsiAMResponse);
/* 02/02/05 gam; if NOT pSFTandSignalParams->resTrig > 0 should not create trigArg etc... */
if (pSFTandSignalParams->resTrig > 0) {
LALFree(pSFTandSignalParams->trigArg);
LALFree(pSFTandSignalParams->sinVal);
LALFree(pSFTandSignalParams->cosVal);
}
LALFree(pSFTandSignalParams);
/* deallocate skyPosData */
for(i=0;i<numSkyPosTotal;i++)
{
LALFree(skyPosData[i]);
}
LALFree(skyPosData);
if (numSpinDown > 0) {
/* deallocate freqDerivData */
for(i=0;i<numFreqDerivTotal;i++)
{
LALFree(freqDerivData[i]);
}
LALFree(freqDerivData);
}
LALFree(timeStamps->data);
LALFree(timeStamps);
XLALDestroyEphemerisData(edat);
CHECKSTATUSPTR (status);
DETATCHSTATUSPTR (status);
}
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;
}
