/*---------- function definitions ---------- */
int main(int argc,char *argv[])
{
LALStatus status = blank_status; /* initialize status */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT; /* exit with returned status-code on error */
/* register all user-variables */
LAL_CALL (InitUserVars(&status, &CommandLineArgs), &status);
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN (XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
return EXIT_FAILURE;
LAL_CALL ( CheckUserInput (&status, &CommandLineArgs), &status);
LAL_CALL ( Initialize (&status, &CommandLineArgs), &status);
/*---------- central function: compute F-statistic ---------- */
LAL_CALL ( ComputeF(&status, CommandLineArgs), &status);
/* Free remaining memory */
LAL_CALL ( LALSDestroyVector(&status, &(amc.a) ), &status);
LAL_CALL ( LALSDestroyVector(&status, &(amc.b) ), &status);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return 0;
} /* main() */
/** \deprecated us XLALDestroyUserVars() instead */
void
LALDestroyUserVars (LALStatus *status)
{
INITSTATUS(status);
XLALDestroyUserVars();
RETURN (status);
} // LALDestroyUserVars()
/**
* This routine frees up all the memory.
*/
int
XLALFreeMem ( ConfigVars_t *cfg )
{
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL );
/* Free config-Variables and userInput stuff */
XLALDestroyUserVars();
/* free timestamps if any */
XLALDestroyMultiTimestamps ( cfg->multiTimestamps );
XLALFree ( cfg->VCSInfoString );
// free noise-SFT catalog
XLALDestroySFTCatalog ( cfg->noiseCatalog );
XLALDestroyMultiSFTCatalogView ( cfg->multiNoiseCatalogView );
// free noise time-series data
XLALDestroyMultiREAL8TimeSeries ( cfg->inputMultiTS );
/* Clean up earth/sun Ephemeris tables */
XLALDestroyEphemerisData ( cfg->edat );
return XLAL_SUCCESS;
} /* XLALFreeMem() */
/** Destructor for internal configuration struct */
int
XLALDestroyConfig ( ConfigVariables *cfg )
{
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL );
XLALDestroyUserVars ();
XLALDestroyTimestampVector ( cfg->timestamps );
XLALDestroyEphemerisData ( cfg->edat );
XLALFree ( cfg->det );
return XLAL_SUCCESS;
} /* XLALDestroyConfig() */
/** Destructor for internal configuration struct */
int
XLALDestroyConfig ( ConfigVariables *cfg )
{
if ( !cfg ) {
LogPrintf (LOG_CRITICAL, "%s: invalid NULL input!\n\n", __func__ );
XLAL_ERROR (XLAL_EINVAL );
}
XLALDestroyUserVars ();
XLALDestroyResultHistory ( cfg->history );
XLALDestroyEphemerisData ( cfg->edat );
XLALSegListClear ( &(cfg->segmentList) );
return XLAL_SUCCESS;
} /* XLALDestroyConfig() */
INT4 main(int argc, char *argv[])
{
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( InitUserVars2(&uvar, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
//Set vectormath
//if (uvar.vectorMath==1) XLAL_CHECK( XLALVectorDeviceSet(VECTORDEVICE_SSE) == XLAL_SUCCESS, XLAL_EFUNC );
//else if (uvar.vectorMath==2) XLAL_CHECK( XLALVectorDeviceSet(VECTORDEVICE_AVX) == XLAL_SUCCESS, XLAL_EFUNC );
//else XLAL_CHECK( XLALVectorDeviceSet(VECTORDEVICE_FPU) == XLAL_SUCCESS, XLAL_EFUNC );
TwoSpectTemplateVector *vector = NULL;
XLAL_CHECK( (vector = generateTwoSpectTemplateVector(uvar.Pmin, uvar.Pmax, uvar.dfmin, uvar.dfmax, uvar.Tsft, uvar.SFToverlap, uvar.Tobs, uvar.maxVectorLength, uvar.minTemplateLength, uvar.maxTemplateLength, uvar.vectorMath, uvar.exactflag)) != NULL, XLAL_EFUNC );
if (XLALUserVarWasSet(&uvar.filename)) XLAL_CHECK( writeTwoSpectTemplateVector(vector, uvar.filename) == XLAL_SUCCESS, XLAL_EFUNC );
destroyTwoSpectTemplateVector(vector);
XLALDestroyUserVars();
return 0;
}
/** Destructor for internal configuration struct */
int
XLALDestroyConfig ( ConfigVariables *cfg )
{
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL );
XLALDestroyUserVars ();
XLALDestroyREAL8Vector ( cfg->Alpha );
XLALDestroyREAL8Vector ( cfg->Delta );
XLALDestroyMultiTimestamps ( cfg->multiTimestamps );
XLALDestroyUINT4Vector ( cfg->numTimeStampsX );
XLALDestroyEphemerisData ( cfg->edat );
XLALDestroyMultiDetectorStateSeries ( cfg->multiDetStates );
XLALDestroyMultiNoiseWeights ( cfg->multiNoiseWeights );
return XLAL_SUCCESS;
} /* XLALDestroyConfig() */
/*----------------------------------------------------------------------
* 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 */
int
main(int argc, char *argv[])
{
FILE *fp = NULL;
BarycenterInput XLAL_INIT_DECL(baryinput);
INT4 leap0,leap;
LIGOTimeGPS epoch;
LIGOTimeGPS TstartSSB, TendSSB, TendGPS;
INT4 n;
LIGOTimeGPS *TSSB = NULL;
MJDTime TstartUTCMJD;
LIGOTimeGPS TDET;
REAL8 temp;
INT4 i;
MJDTime tempTOA;
REAL8 dt;
LIGOTimeGPS TstartGPS;
MJDTime *TOA = NULL;
CHAR tempstr[18];
CHAR *tempstr2;
CHAR TstartMJDstr[20],TfinishMJDstr[20],TOAstr[22];
PulsarSignalParams pulsarparams;
CHAR parfile[256];
CHAR timfile[256];
CHAR detcode[16];
REAL8 TstartUTCMJDtest;
REAL8 diff;
MJDTime MJDdiff, MJDtest;
MJDTime TrefTDBMJD;
LIGOTimeGPS TrefSSB_TDB_GPS;
// ----------------------------------------------------------------------
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( initUserVars (argc, argv, &uvar) == XLAL_SUCCESS, XLAL_EFUNC );
unsigned int seed = uvar.randSeed;
if ( uvar.randSeed == 0 ) {
seed = clock();
}
srand ( seed );
// ----- sky position: random or user-specified ----------
REAL8 alpha, delta;
CHAR *RAJ = NULL, *DECJ = NULL;
BOOLEAN have_RAJ = XLALUserVarWasSet ( &uvar.RAJ );
BOOLEAN have_DECJ = XLALUserVarWasSet ( &uvar.DECJ );
if ( have_RAJ )
{
XLAL_CHECK ( XLALTranslateHMStoRAD ( &alpha, uvar.RAJ ) == XLAL_SUCCESS, XLAL_EFUNC );
RAJ = XLALStringDuplicate ( uvar.RAJ );
}
else
{ // pick randomly
alpha = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // alpha uniform in [0, 2pi)
XLAL_CHECK ( (RAJ = XLALTranslateRADtoHMS ( alpha )) != NULL, XLAL_EFUNC );
}
if ( have_DECJ )
{
XLAL_CHECK ( XLALTranslateDMStoRAD ( &delta, uvar.DECJ ) == XLAL_SUCCESS, XLAL_EFUNC );
DECJ = XLALStringDuplicate ( uvar.DECJ );
}
else
{ // pick randomly
delta = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); // sin(delta) uniform in [-1,1]
XLAL_CHECK ( (DECJ = XLALTranslateRADtoDMS ( delta )) != NULL, XLAL_EFUNC );
}
/* define start time in an MJD structure */
REAL8toMJD ( &TstartUTCMJD, uvar.TstartUTCMJD );
XLALPrintInfo ( "TstartUTCMJD=%f converted to MJD days = %d fracdays = %6.12f\n", uvar.TstartUTCMJD, TstartUTCMJD.days, TstartUTCMJD.fracdays );
/* convert back to test conversions */
TstartUTCMJDtest = MJDtoREAL8 (TstartUTCMJD);
diff = uvar.TstartUTCMJD - TstartUTCMJDtest;
if ( fabs(diff) > 1e-9) {
fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff);
return(-1);
}
XLALPrintInfo ( "MJD conversion gives discrepancies of %e sec\n", diff);
/* use start time to define an epoch for the leap seconds */
/* Note that epochs are defined in TDB !!! but here we only need to be rough to get a leap second value */
TDBMJDtoGPS(&epoch,TstartUTCMJD);
XLALPrintInfo ( "leap second epoch = %d %d\n",epoch.gpsSeconds,epoch.gpsNanoSeconds);
/* deal with ephemeris files and compute leap seconds */
EphemerisData *edat;
XLAL_CHECK ( (edat = XLALInitBarycenter( uvar.ephemEarth, uvar.ephemSun )) != NULL, XLAL_EFUNC );
leap0 = XLALGPSLeapSeconds (epoch.gpsSeconds);
XLALPrintInfo ( "leap seconds = %d\n",leap0);
/* select detector location */
if (strcmp(uvar.Observatory,"GBT")==0) {
baryinput.site.location[0] = GBT_LOCATION_X;
baryinput.site.location[1] = GBT_LOCATION_Y;
baryinput.site.location[2] = GBT_LOCATION_Z;
sprintf(detcode,"gbt");
}
else if (strcmp(uvar.Observatory,"NARRABRI")==0) {
baryinput.site.location[0] = NARRABRI_LOCATION_X;
baryinput.site.location[1] = NARRABRI_LOCATION_Y;
baryinput.site.location[2] = NARRABRI_LOCATION_Z;
sprintf(detcode,"atca");
}
else if (strcmp(uvar.Observatory,"ARECIBO")==0) {
baryinput.site.location[0] = ARECIBO_LOCATION_X;
baryinput.site.location[1] = ARECIBO_LOCATION_Y;
baryinput.site.location[2] = ARECIBO_LOCATION_Z;
sprintf(detcode,"ao");
}
else if (strcmp(uvar.Observatory,"NANSHAN")==0) {
baryinput.site.location[0] = NANSHAN_LOCATION_X;
baryinput.site.location[1] = NANSHAN_LOCATION_Y;
baryinput.site.location[2] = NANSHAN_LOCATION_Z;
sprintf(detcode,"nanshan");
}
else if (strcmp(uvar.Observatory,"DSS_43")==0) {
baryinput.site.location[0] = DSS_43_LOCATION_X;
baryinput.site.location[1] = DSS_43_LOCATION_Y;
baryinput.site.location[2] = DSS_43_LOCATION_Z;
sprintf(detcode,"tid43");
}
else if (strcmp(uvar.Observatory,"PARKES")==0) {
baryinput.site.location[0] = PARKES_LOCATION_X;
baryinput.site.location[1] = PARKES_LOCATION_Y;
baryinput.site.location[2] = PARKES_LOCATION_Z;
sprintf(detcode,"pks");
}
else if (strcmp(uvar.Observatory,"JODRELL")==0) {
baryinput.site.location[0] = JODRELL_LOCATION_X;
baryinput.site.location[1] = JODRELL_LOCATION_Y;
baryinput.site.location[2] = JODRELL_LOCATION_Z;
sprintf(detcode,"jb");
}
else if (strcmp(uvar.Observatory,"VLA")==0) {
baryinput.site.location[0] = VLA_LOCATION_X;
baryinput.site.location[1] = VLA_LOCATION_Y;
baryinput.site.location[2] = VLA_LOCATION_Z;
sprintf(detcode,"vla");
}
else if (strcmp(uvar.Observatory,"NANCAY")==0) {
baryinput.site.location[0] = NANCAY_LOCATION_X;
baryinput.site.location[1] = NANCAY_LOCATION_Y;
baryinput.site.location[2] = NANCAY_LOCATION_Z;
sprintf(detcode,"ncy");
}
else if (strcmp(uvar.Observatory,"EFFELSBERG")==0) {
baryinput.site.location[0] = EFFELSBERG_LOCATION_X;
baryinput.site.location[1] = EFFELSBERG_LOCATION_Y;
baryinput.site.location[2] = EFFELSBERG_LOCATION_Z;
sprintf(detcode,"eff");
}
else if (strcmp(uvar.Observatory,"JODRELLM4")==0) {
baryinput.site.location[0] = JODRELLM4_LOCATION_X;
baryinput.site.location[1] = JODRELLM4_LOCATION_Y;
baryinput.site.location[2] = JODRELLM4_LOCATION_Z;
sprintf(detcode,"jbm4");
}
else if (strcmp(uvar.Observatory,"GB300")==0) {
baryinput.site.location[0] = GB300_LOCATION_X;
baryinput.site.location[1] = GB300_LOCATION_Y;
baryinput.site.location[2] = GB300_LOCATION_Z;
sprintf(detcode,"gb300");
}
else if (strcmp(uvar.Observatory,"GB140")==0) {
baryinput.site.location[0] = GB140_LOCATION_X;
baryinput.site.location[1] = GB140_LOCATION_Y;
baryinput.site.location[2] = GB140_LOCATION_Z;
sprintf(detcode,"gb140");
}
else if (strcmp(uvar.Observatory,"GB853")==0) {
baryinput.site.location[0] = GB853_LOCATION_X;
baryinput.site.location[1] = GB853_LOCATION_Y;
baryinput.site.location[2] = GB853_LOCATION_Z;
sprintf(detcode,"gb853");
}
else if (strcmp(uvar.Observatory,"LA_PALMA")==0) {
baryinput.site.location[0] = LA_PALMA_LOCATION_X;
baryinput.site.location[1] = LA_PALMA_LOCATION_Y;
baryinput.site.location[2] = LA_PALMA_LOCATION_Z;
sprintf(detcode,"lap");
}
else if (strcmp(uvar.Observatory,"Hobart")==0) {
baryinput.site.location[0] = Hobart_LOCATION_X;
baryinput.site.location[1] = Hobart_LOCATION_Y;
baryinput.site.location[2] = Hobart_LOCATION_Z;
sprintf(detcode,"hob");
}
else if (strcmp(uvar.Observatory,"Hartebeesthoek")==0) {
baryinput.site.location[0] = Hartebeesthoek_LOCATION_X;
baryinput.site.location[1] = Hartebeesthoek_LOCATION_Y;
baryinput.site.location[2] = Hartebeesthoek_LOCATION_Z;
sprintf(detcode,"hart");
}
else if (strcmp(uvar.Observatory,"WSRT")==0) {
baryinput.site.location[0] = WSRT_LOCATION_X;
baryinput.site.location[1] = WSRT_LOCATION_Y;
baryinput.site.location[2] = WSRT_LOCATION_Z;
sprintf(detcode,"wsrt");
}
else if (strcmp(uvar.Observatory,"COE")==0) {
baryinput.site.location[0] = COE_LOCATION_X;
baryinput.site.location[1] = COE_LOCATION_Y;
baryinput.site.location[2] = COE_LOCATION_Z;
sprintf(detcode,"coe");
}
else if (strcmp(uvar.Observatory,"SSB")!=0) {
fprintf(stderr,"ERROR. Unknown Observatory %s. Exiting.\n",uvar.Observatory);
return(-1);
}
XLALPrintInfo ( "selected observatory %s - observatoryt code = %s\n",uvar.Observatory,detcode);
XLALPrintInfo ( "baryinput location = %6.12f %6.12f %6.12f\n",baryinput.site.location[0],baryinput.site.location[1],baryinput.site.location[2]);
/* convert start time to UTC GPS */
UTCMJDtoGPS(&TstartGPS, TstartUTCMJD, leap0);
XLALPrintInfo ( "TstartGPS = %d %d\n",TstartGPS.gpsSeconds,TstartGPS.gpsNanoSeconds);
/* convert back to test conversion */
UTCGPStoMJD(&MJDtest,&TstartGPS,leap0);
deltaMJD ( &MJDdiff, &MJDtest, &TstartUTCMJD );
diff = (MJDdiff.days+MJDdiff.fracdays)*86400;
if ( fabs(diff) > 1e-9) {
fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff);
return(-1);
}
XLALPrintInfo ( "MJD conversion gives discrepancies of %e sec\n",diff);
/* define reference time in an MJD structure */
REAL8toMJD ( &TrefTDBMJD, uvar.TrefTDBMJD );
XLALPrintInfo ( "TrefTDBMJD converted to MJD days = %d fracdays = %6.12f\n",TrefTDBMJD.days,TrefTDBMJD.fracdays);
/* convert reference time to TDB GPS */
TDBMJDtoGPS(&TrefSSB_TDB_GPS,TrefTDBMJD);
XLALPrintInfo ( "TrefSSB_TDB_GPS = %d %d\n",TrefSSB_TDB_GPS.gpsSeconds,TrefSSB_TDB_GPS.gpsNanoSeconds);
/* convert back to test conversion */
TDBGPStoMJD ( &MJDtest, TrefSSB_TDB_GPS, leap0 );
deltaMJD ( &MJDdiff, &MJDtest, &TrefTDBMJD );
diff = (MJDdiff.days+MJDdiff.fracdays)*86400;
if ( fabs(diff) > 1e-9) {
fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff);
return(-1);
}
XLALPrintInfo ( "MJD conversion gives discrepancies of %e sec\n",diff);
/* fill in required pulsar params structure for Barycentering */
LALDetector *site = NULL;
site = (LALDetector *)LALMalloc(sizeof(LALDetector));
site->location[0] = baryinput.site.location[0];
site->location[1] = baryinput.site.location[1];
site->location[2] = baryinput.site.location[2];
pulsarparams.site = site;
pulsarparams.pulsar.position.longitude = alpha;
pulsarparams.pulsar.position.latitude = delta;
pulsarparams.pulsar.position.system = COORDINATESYSTEM_EQUATORIAL;
pulsarparams.ephemerides = edat;
/* generate SSB initial TOA in GPS */
XLALConvertGPS2SSB ( &TstartSSB, TstartGPS, &pulsarparams);
XLALPrintInfo ( "TstartSSB = %d %d\n",TstartSSB.gpsSeconds,TstartSSB.gpsNanoSeconds);
/* define TOA end time in GPS */
temp = uvar.DurationMJD*86400.0;
TendGPS = TstartGPS;
XLALGPSAdd(&TendGPS, temp);
XLALPrintInfo ( "GPS end time of TOAs = %d %d\n",TendGPS.gpsSeconds,TendGPS.gpsNanoSeconds);
/* generate SSB end time in GPS (force integer seconds) */
XLALConvertGPS2SSB (&TendSSB,TendGPS,&pulsarparams);
XLALPrintInfo ( "TendSSB = %d %d\n",TendSSB.gpsSeconds,TendSSB.gpsNanoSeconds);
/* define TOA seperation in the SSB */
dt = uvar.DeltaTMJD*86400.0;
n = (INT4)ceil(uvar.DurationMJD/uvar.DeltaTMJD);
XLALPrintInfo ( "TOA seperation at SSB = %g sec\n",dt);
XLALPrintInfo ( "number of TOAs to generate = %d\n",n);
/* allocate memory for artificial SSB TOAs */
TSSB = (LIGOTimeGPS *)LALMalloc(n*sizeof(LIGOTimeGPS));
TOA = (MJDTime *)LALMalloc(n*sizeof(MJDTime));
/* generate artificial SSB TOAs given the phase model phi = 2*pi*(f0*(t-tref) + 0.5*fdot*(t-tref)^2) */
for (i=0;i<n;i++)
{
REAL8 dtref,fnow,cyclefrac,dtcor;
LIGOTimeGPS tnow;
/* define current interval */
XLALPrintInfo ( "current (t-tstart) = %g sec\n", i * dt);
/* define current t */
tnow = TstartSSB;
XLALGPSAdd(&tnow, i * dt);
XLALPrintInfo ( "current t = %d %d\n",tnow.gpsSeconds,tnow.gpsNanoSeconds);
/* define current t-tref */
dtref = XLALGPSDiff(&tnow,&TrefSSB_TDB_GPS);
XLALPrintInfo ( "current (t - tref) = %9.12f\n",dtref);
dtcor = 1;
while (dtcor>1e-9)
{
/* define actual cycle fraction at requested time */
cyclefrac = fmod(uvar.f0*dtref + 0.5*uvar.fdot*dtref*dtref,1.0);
XLALPrintInfo ( "cyclefrac = %9.12f\n",cyclefrac);
/* define instantaneous frequency */
fnow = uvar.f0 + uvar.fdot*dtref;
XLALPrintInfo ( "instananeous frequency = %9.12f\n",fnow);
/* add correction to time */
dtcor = cyclefrac/fnow;
dtref -= dtcor;
XLALPrintInfo ( "timing correction = %9.12f\n",dtcor);
XLALPrintInfo ( "corrected dtref to = %9.12f\n",dtref);
} // while dtcor>1e-9
/* define time of zero phase */
TSSB[i] = TrefSSB_TDB_GPS;
XLALGPSAdd(&TSSB[i], dtref);
XLALPrintInfo ( "TSSB[%d] = %d %d\n",i,TSSB[i].gpsSeconds,TSSB[i].gpsNanoSeconds);
} // for i < n
/* loop over SSB time of arrivals and compute detector time of arrivals */
for (i=0;i<n;i++)
{
LIGOTimeGPS TSSBtest;
LIGOTimeGPS GPStest;
/* convert SSB to Detector time */
int ret = XLALConvertSSB2GPS ( &TDET, TSSB[i], &pulsarparams);
if ( ret != XLAL_SUCCESS ) {
XLALPrintError ("XLALConvertSSB2GPS() failed with xlalErrno = %d\n", xlalErrno );
return(-1);
}
XLALPrintInfo ( "converted SSB TOA %d %d -> Detector TOA %d %d\n",TSSB[i].gpsSeconds,TSSB[i].gpsNanoSeconds,TDET.gpsSeconds,TDET.gpsNanoSeconds);
/* convert back for testing conversion */
XLALConvertGPS2SSB (&TSSBtest,TDET,&pulsarparams);
diff = XLALGPSDiff(&TSSBtest,&TSSB[i]);
if ( fabs(diff) > 1e-9) {
fprintf(stderr,"ERROR : Time conversion gives discrepancy of %e sec. Exiting.\n",diff);
return(-1);
}
XLALPrintInfo ( "SSB -> detector conversion gives discrepancies of %e sec\n",diff);
/* recompute leap seconds incase they've changed */
leap = XLALGPSLeapSeconds (TDET.gpsSeconds);
/* must now convert to an MJD time for TEMPO */
/* Using UTC conversion as used by Matt in his successful comparison */
UTCGPStoMJD (&tempTOA,&TDET,leap);
XLALPrintInfo ( "output MJD time = %d %6.12f\n",tempTOA.days,tempTOA.fracdays);
/* convert back to test conversion */
UTCMJDtoGPS ( &GPStest, tempTOA, leap );
diff = XLALGPSDiff(&TDET,&GPStest);
if ( fabs(diff) > 1e-9) {
fprintf(stderr,"ERROR. Time conversion gives discrepancy of %e sec. Exiting.\n",diff);
return(-1);
}
XLALPrintInfo ( "MJD time conversion gives discrepancies of %e sec\n",diff);
/* fill in results */
TOA[i].days = tempTOA.days;
TOA[i].fracdays = tempTOA.fracdays;
} // for i < n
snprintf(tempstr,15,"%1.13f",TOA[0].fracdays);
tempstr2 = tempstr+2;
snprintf(TstartMJDstr,19,"%d.%s",TOA[0].days,tempstr2);
XLALPrintInfo ( "Converted initial TOA MJD %d %6.12f to the string %s\n",TOA[0].days,TOA[0].fracdays,TstartMJDstr);
snprintf(tempstr,15,"%1.13f",TOA[n-1].fracdays);
tempstr2 = tempstr+2;
snprintf(TfinishMJDstr,19,"%d.%s",TOA[n-1].days,tempstr2);
XLALPrintInfo ( "*** Converted MJD to a string %s\n",TfinishMJDstr);
XLALPrintInfo ( "Converted final TOA MJD %d %6.12f to the string %s\n",TOA[n-1].days,TOA[n-1].fracdays,TfinishMJDstr);
/* define output file names */
sprintf(parfile,"%s.par",uvar.PSRJ);
sprintf(timfile,"%s.tim",uvar.PSRJ);
/* output to par file in format required by TEMPO 2 */
if ((fp = fopen(parfile,"w")) == NULL) {
fprintf(stderr,"ERROR. Could not open file %s. Exiting.\n",parfile);
return(-1);
}
fprintf(fp,"PSRJ\t%s\n",uvar.PSRJ);
fprintf(fp,"RAJ\t%s\t1\n",RAJ);
fprintf(fp,"DECJ\t%s\t1\n",DECJ);
fprintf(fp,"PEPOCH\t%6.12f\n",uvar.TrefTDBMJD);
fprintf(fp,"POSEPOCH\t%6.12f\n",uvar.TrefTDBMJD);
fprintf(fp,"DMEPOCH\t%6.12f\n",uvar.TrefTDBMJD);
fprintf(fp,"DM\t0.0\n");
fprintf(fp,"F0\t%6.16f\t1\n",uvar.f0);
fprintf(fp,"F1\t%6.16f\t0\n",uvar.fdot);
fprintf(fp,"START\t%s\n",TstartMJDstr);
fprintf(fp,"FINISH\t%s\n",TfinishMJDstr);
fprintf(fp,"TZRSITE\t%s\n",detcode);
fprintf(fp,"CLK\tUTC(NIST)\n");
fprintf(fp,"EPHEM\tDE405\n");
fprintf(fp,"UNITS\tTDB\n");
fprintf(fp,"MODE\t0\n");
/* close par file */
fclose(fp);
/* output to tim file in format required by TEMPO 2 */
if ((fp = fopen(timfile,"w")) == NULL) {
fprintf(stderr,"ERROR. Could not open file %s. Exiting.\n",timfile);
return(-1);
}
fprintf(fp,"FORMAT 1\n");
for (i=0;i<n;i++)
{
/* convert each TOA to a string for output */
snprintf(tempstr,18,"%1.16f",TOA[i].fracdays);
tempstr2 = tempstr+2;
snprintf(TOAstr,22,"%d.%s",TOA[i].days,tempstr2);
fprintf(fp,"blank.dat\t1000.0\t%s\t1.0\t%s\n",TOAstr,detcode);
XLALPrintInfo ( "Converting MJD time %d %6.16f to string %s\n",TOA[i].days,TOA[i].fracdays,TOAstr);
} // for i < n
/* close tim file */
fclose(fp);
/* free memory */
XLALFree ( TSSB );
XLALFree ( TOA );
XLALFree ( site );
XLALDestroyEphemerisData ( edat );
XLALDestroyUserVars ();
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} /* 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 */
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;
}
/* vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv------------------------------------ */
int main(int argc, char *argv[]){
static LALStatus status; /* LALStatus pointer */
static LineNoiseInfo lines, lines2;
static LineHarmonicsInfo harmonics;
INT4 nLines=0, count1, nHarmonicSets;
INT4 j, r;
FILE *fpNstar=NULL;
FILE *fpOut=NULL;
INT4 *nstarVec=NULL;
REAL8 *freqVec=NULL;
INT4 nstarNum=0, minBin, maxBin;
REAL8 timeBase=1800.0, minFreq, maxFreq;
INT4 flag= 0;
/* user input variables */
CHAR *uvar_nstarfile=NULL;
CHAR *uvar_harmonicsfile=NULL;
CHAR *uvar_cleannstar=NULL;
/* set defaults */
uvar_nstarfile = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_nstarfile, NSTARFILE);
uvar_harmonicsfile = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_harmonicsfile, HARMONICSFILE);
uvar_cleannstar = (CHAR *)LALMalloc(512*sizeof(CHAR));
strcpy(uvar_cleannstar, CLEANNSTARFILE);
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_nstarfile, "nstarfile", STRING, 'n', OPTIONAL, "File with max number counts") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_harmonicsfile, "harmonicsfile", STRING, 'l', OPTIONAL, "File with line information") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_cleannstar, "cleannstarfile", STRING, 'o', OPTIONAL, "Output file") == XLAL_SUCCESS, XLAL_EFUNC);
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
exit(1);
/* find number of harmonics */
SUB( LALFindNumberHarmonics (&status, &harmonics, uvar_harmonicsfile), &status);
nHarmonicSets = harmonics.nHarmonicSets;
/* convert harmonics to explicit lines */
if (nHarmonicSets > 0)
{
harmonics.startFreq = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8));
harmonics.gapFreq = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8));
harmonics.numHarmonics = (INT4 *)LALMalloc(harmonics.nHarmonicSets * sizeof(INT4));
harmonics.leftWing = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8));
harmonics.rightWing = (REAL8 *)LALMalloc(harmonics.nHarmonicSets * sizeof(REAL8));
SUB( LALReadHarmonicsInfo( &status, &harmonics, uvar_harmonicsfile ), &status);
nLines = 0;
for (count1=0; count1 < nHarmonicSets; count1++)
{
nLines += *(harmonics.numHarmonics + count1);
}
lines.nLines = nLines;
lines.lineFreq = (REAL8 *)LALMalloc(nLines * sizeof(REAL8));
lines.leftWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8));
lines.rightWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8));
SUB( LALHarmonics2Lines( &status, &lines, &harmonics), &status);
}
/* read file with nstar information */
fpNstar = fopen( uvar_nstarfile, "r");
if (fpNstar == NULL)
{
fprintf(stderr, "nstar file %s not found\n", uvar_nstarfile);
exit(0);
}
/* first find number of nstar values */
nstarNum = 0;
do {
REAL8 temp1, temp2, temp3, temp4, temp5;
r=fscanf(fpNstar,"%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) nstarNum++;
} while ( r != EOF);
rewind(fpNstar);
/* allocate memory for vector of nstar and freqstar */
nstarVec = (INT4 *)LALMalloc(nstarNum*sizeof(INT4));
freqVec = (REAL8 *)LALMalloc(nstarNum*sizeof(REAL8));
/* read nstarfile again */
for (j=0; j<nstarNum; j++)
{
REAL8 temp1, temp2, temp3, temp4, temp5;
r=fscanf(fpNstar,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5);
if (r==5)
{
nstarVec[j] = temp1;
freqVec[j] = temp2;
}
}
/* now we are done with nstarfile */
fclose(fpNstar);
/* calculate min and max frequency bins in nstarfile */
/* this assumes frequencies are ordered */
minBin = floor(freqVec[0]*timeBase + 0.5);
maxBin = floor(freqVec[nstarNum-1]*timeBase + 0.5);
minFreq = freqVec[0];
maxFreq = freqVec[nstarNum-1];
/* choose lines affecting frequency range */
lines2.nLines = nLines;
lines2.lineFreq = (REAL8 *)LALMalloc(nLines * sizeof(REAL8));
lines2.leftWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8));
lines2.rightWing = (REAL8 *)LALMalloc(nLines * sizeof(REAL8));
SUB( LALChooseLines (&status, &lines2, &lines, minFreq, maxFreq), &status);
SUB( LALCheckLines (&status, &flag, &lines2, 202.0), &status);
/* clean the nstarVec */
if ( nstarNum > 0 )
{
/* loop over lines and clean nstarVec*/
for (j=0; j<nLines; j++)
{
REAL8 lineFreq, leftWing, rightWing;
INT4 lineBin, leftWingBins, rightWingBins;
INT4 leftCount, rightCount;
lineFreq = lines.lineFreq[j];
leftWing = lines.leftWing[j] + lineFreq*VTOT;
rightWing = lines.rightWing[j] + lineFreq*VTOT;
lineBin = floor( lineFreq*timeBase + 0.5);
leftWingBins = floor( leftWing*timeBase + 0.5);
rightWingBins = floor( rightWing*timeBase + 0.5);
if ( (lineBin >= minBin) && (lineBin <= maxBin) )
{
/* clean lineBin */
nstarVec[lineBin-minBin] = 0;
/* now go left */
for (leftCount=0; leftCount < leftWingBins; leftCount++)
{
if (lineBin-minBin-leftCount > 0)
{
nstarVec[lineBin-minBin-leftCount-1] = 0;
}
} /* end of loop over leftwing */
/* now go right */
for (rightCount = 0; rightCount < rightWingBins; rightCount++)
{
if (maxBin - lineBin - rightCount > 0)
{
nstarVec[lineBin-minBin+rightCount+1]=0;
}
} /* end of loop over rightwing */
} /* end of if statement */
} /* end of loop over lines */
} /* end of cleaning */
/* now write the result */
fpOut = fopen(uvar_cleannstar, "w");
if (fpOut == NULL)
{
fprintf(stderr, "unable to open file %s for writing \n", uvar_cleannstar);
exit(0);
}
for (j=0; j<nstarNum; j++)
{
fprintf(fpOut, "%d %f \n", nstarVec[j], freqVec[j]);
}
fclose(fpOut);
/* Free memory */
LALFree(nstarVec);
LALFree(freqVec);
if (nLines > 0)
{
LALFree(lines.lineFreq);
LALFree(lines.leftWing);
LALFree(lines.rightWing);
LALFree(lines2.lineFreq);
LALFree(lines2.leftWing);
LALFree(lines2.rightWing);
}
if (nHarmonicSets > 0)
{
LALFree(harmonics.startFreq);
LALFree(harmonics.gapFreq);
LALFree(harmonics.numHarmonics);
LALFree(harmonics.leftWing);
LALFree(harmonics.rightWing);
}
XLALDestroyUserVars();
LALCheckMemoryLeaks();
INFO( SFTCLEANC_MSGENORM );
return SFTCLEANC_ENORM;
}
/**
* MAIN function
* Generates samples of B-stat and F-stat according to their pdfs for given signal-params.
*/
int main(int argc,char *argv[])
{
UserInput_t XLAL_INIT_DECL(uvar);
ConfigVariables XLAL_INIT_DECL(cfg);
vrbflg = 1; /* verbose error-messages */
/* turn off default GSL error handler */
gsl_set_error_handler_off ();
/* ----- register and read all user-variables ----- */
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if ( XLALUserVarReadAllInput ( &should_exit, argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
if ( should_exit )
return EXIT_FAILURE;
if ( uvar.version ) {
/* output verbose VCS version string if requested */
CHAR *vcs;
if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) {
LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno );
return 1;
}
printf ( "%s\n", vcs );
XLALFree ( vcs );
return 0;
}
/* ---------- Initialize code-setup ---------- */
if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* compare IFO name for line injection with IFO list, find the corresponding index, or throw an error if not found */
UINT4 numDetectors = cfg.multiDetStates->length;
INT4 lineX = -1;
if ( uvar.lineIFO ) {
for ( UINT4 X=0; X < numDetectors; X++ ) {
if ( strcmp( uvar.lineIFO, uvar.IFOs->data[X] ) == 0 )
lineX = X;
}
if ( lineX == -1 ) {
XLALPrintError ("\nError in function %s, line %d : Could not match detector ID \"%s\" for line injection to any detector.\n\n", __func__, __LINE__, uvar.lineIFO);
XLAL_ERROR ( XLAL_EFAILED );
}
}
/* ----- prepare stats output ----- */
FILE *fpStats = NULL;
if ( uvar.outputStats )
{
if ( (fpStats = fopen (uvar.outputStats, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpStats, "%s", cfg.logString ); /* write search log comment */
if ( write_BSGL_candidate_to_fp ( fpStats, NULL, uvar.IFOs, NULL, uvar.computeBSGL ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputStats */
/* ----- prepare injection params output ----- */
FILE *fpInjParams = NULL;
if ( uvar.outputInjParams )
{
if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */
if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, uvar.outputMmunuX, numDetectors ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputInjParams */
multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */
/* ----- prepare BSGL computation */
BSGLSetup *BSGLsetup = NULL;
if ( uvar.computeBSGL )
{
BOOLEAN useLogCorrection = TRUE;
REAL4 *oLGX_p = NULL;
REAL4 oLGX[PULSAR_MAX_DETECTORS];
if ( uvar.oLGX != NULL )
{
XLAL_CHECK ( uvar.oLGX->length == numDetectors, XLAL_EINVAL, "Invalid input: length(oLGX) = %d differs from number of detectors (%d)'\n", uvar.oLGX->length, numDetectors );
XLAL_CHECK ( XLALParseLinePriors ( &oLGX[0], uvar.oLGX ) == XLAL_SUCCESS, XLAL_EFUNC );
oLGX_p = &oLGX[0];
}
XLAL_CHECK ( ( BSGLsetup = XLALCreateBSGLSetup ( numDetectors, uvar.Fstar0, oLGX_p, useLogCorrection ) ) != NULL, XLAL_EFUNC );
} // if computeBSGL
/* ----- main MC loop over numDraws trials ---------- */
INT4 i;
for ( i=0; i < uvar.numDraws; i ++ )
{
InjParams_t XLAL_INIT_DECL(injParamsDrawn);
/* ----- generate signal random draws from ranges and generate Fstat atoms */
MultiFstatAtomVector *multiAtoms;
multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, lineX, cfg.multiNoiseWeights );
XLAL_CHECK ( multiAtoms != NULL, XLAL_EFUNC );
/* ----- if requested, output signal injection parameters into file */
if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, uvar.outputMmunuX, numDetectors ) != XLAL_SUCCESS ) ) {
XLAL_ERROR ( XLAL_EFUNC );
} /* if fpInjParams & failure*/
/* initialise BSGLComponents structure and allocate memory */
BSGLComponents XLAL_INIT_DECL(synthStats); /* struct containing multi-detector Fstat, single-detector Fstats, line-robust stat */
synthStats.numDetectors = numDetectors;
/* compute F- and BSGListics from atoms */
UINT4 X;
for ( X=0; X < numDetectors; X++ ) {
synthStats.TwoFX[X] = XLALComputeFstatFromAtoms ( multiAtoms, X );
if ( xlalErrno != 0 ) {
XLALPrintError ("\nError in function %s, line %d : Failed call to XLALComputeFstatFromAtoms().\n\n", __func__, __LINE__);
XLAL_ERROR ( XLAL_EFUNC );
}
}
synthStats.TwoF = XLALComputeFstatFromAtoms ( multiAtoms, -1 );
if ( xlalErrno != 0 ) {
XLALPrintError ("\nError in function %s, line %d : Failed call to XLALComputeFstatFromAtoms().\n\n", __func__, __LINE__);
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar.computeBSGL ) {
synthStats.log10BSGL = XLALComputeBSGL ( synthStats.TwoF, synthStats.TwoFX, BSGLsetup );
XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALComputeBSGL() failed with xlalErrno = %d\n", xlalErrno );
}
/* ----- if requested, output atoms-vector into file */
if ( uvar.outputAtoms )
{
FILE *fpAtoms;
char *fnameAtoms;
UINT4 len = strlen ( uvar.outputAtoms ) + 20;
if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws );
if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */
if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameAtoms );
fclose (fpAtoms);
} /* if outputAtoms */
/* ----- if requested, output transient-cand statistics */
if ( fpStats && write_BSGL_candidate_to_fp ( fpStats, &synthStats, uvar.IFOs, &injParamsDrawn, uvar.computeBSGL ) != XLAL_SUCCESS ) {
XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- free Memory */
XLALDestroyMultiFstatAtomVector ( multiAtoms );
} /* for i < numDraws */
/* ----- close files ----- */
if ( fpStats ) fclose ( fpStats );
if ( fpInjParams ) fclose ( fpInjParams );
/* ----- free memory ---------- */
XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates );
XLALDestroyMultiNoiseWeights ( cfg.multiNoiseWeights );
XLALDestroyExpLUT();
XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM );
/* ----- free amplitude prior pdfs ----- */
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 );
XLALFree ( BSGLsetup );
BSGLsetup = NULL;
if ( cfg.logString ) {
XLALFree ( cfg.logString );
}
gsl_rng_free ( cfg.rng );
XLALDestroyUserVars();
/* did we forget anything ? (doesn't cover gsl-memory!) */
LALCheckMemoryLeaks();
return 0;
} /* main() */
/**
* MAIN function
* Generates samples of B-stat and F-stat according to their pdfs for given signal-params.
*/
int main(int argc,char *argv[])
{
UserInput_t XLAL_INIT_DECL(uvar);
ConfigVariables XLAL_INIT_DECL(cfg); /**< various derived configuration settings */
vrbflg = 1; /* verbose error-messages */
LogSetLevel(lalDebugLevel);
/* turn off default GSL error handler */
gsl_set_error_handler_off ();
/* ----- register and read all user-variables ----- */
LogSetLevel(lalDebugLevel);
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
/* do ALL cmdline and cfgfile handling */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
if (uvar.help) /* if help was requested, we're done here */
return 0;
if ( uvar.version ) {
/* output verbose VCS version string if requested */
CHAR *vcs;
if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) {
LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno );
return 1;
}
printf ( "%s\n", vcs );
XLALFree ( vcs );
return 0;
}
/* ---------- Initialize code-setup ---------- */
if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- prepare stats output ----- */
FILE *fpTransientStats = NULL;
if ( uvar.outputStats )
{
if ( (fpTransientStats = fopen (uvar.outputStats, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpTransientStats, "%s", cfg.logString ); /* write search log comment */
if ( write_transientCandidate_to_fp ( fpTransientStats, NULL ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputStats */
/* ----- prepare injection params output ----- */
FILE *fpInjParams = NULL;
if ( uvar.outputInjParams )
{
if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */
if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, 0, 0 ) != XLAL_SUCCESS ) { /* write header-line comment - options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputInjParams */
/* ----- main MC loop over numDraws trials ---------- */
multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */
INT4 i;
for ( i=0; i < uvar.numDraws; i ++ )
{
InjParams_t XLAL_INIT_DECL(injParamsDrawn);
/* ----- generate signal random draws from ranges and generate Fstat atoms */
MultiFstatAtomVector *multiAtoms;
multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, -1, NULL ); // options lineX and noise_weights not supported here, so pass defaults to deactivate them
if ( multiAtoms ==NULL ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALSynthesizeTransientAtoms() failed with xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- if requested, output signal injection parameters into file */
if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, 0, 0 ) ) != XLAL_SUCCESS ) { // options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them
XLAL_ERROR ( XLAL_EFUNC );
} /* if fpInjParams & failure*/
/* ----- add meta-info on current transient-CW candidate */
transientCandidate_t XLAL_INIT_DECL(cand);
cand.doppler.Alpha = multiAMBuffer.skypos.longitude;
cand.doppler.Delta = multiAMBuffer.skypos.latitude;
cand.windowRange = cfg.transientSearchRange;
/* ----- if needed: compute transient-Bstat search statistic on these atoms */
if ( fpTransientStats || uvar.outputFstatMap || uvar.outputPosteriors )
{
/* compute Fstat map F_mn over {t0, tau} */
if ( (cand.FstatMap = XLALComputeTransientFstatMap ( multiAtoms, cand.windowRange, uvar.useFReg)) == NULL ) {
XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if we'll need the Fstat-map F_mn */
/* ----- if requested compute marginalized Bayes factor */
if ( fpTransientStats )
{
cand.logBstat = XLALComputeTransientBstat ( cand.windowRange, cand.FstatMap );
UINT4 err = xlalErrno;
if ( err ) {
XLALPrintError ("%s: XLALComputeTransientBstat() failed with xlalErrno = %d\n", __func__, err );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar.SignalOnly )
{
cand.FstatMap->maxF += 2;
cand.logBstat += 2;
}
} /* if Bstat requested */
/* ----- if requested, compute parameter posteriors for {t0, tau} */
pdf1D_t *pdf_t0 = NULL;
pdf1D_t *pdf_tau = NULL;
if ( fpTransientStats || uvar.outputPosteriors )
{
if ( (pdf_t0 = XLALComputeTransientPosterior_t0 ( cand.windowRange, cand.FstatMap )) == NULL ) {
XLALPrintError ("%s: failed to compute t0-posterior\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( (pdf_tau = XLALComputeTransientPosterior_tau ( cand.windowRange, cand.FstatMap )) == NULL ) {
XLALPrintError ("%s: failed to compute tau-posterior\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* get maximum-posterior estimate (MP) from the modes of these pdfs */
cand.t0_MP = XLALFindModeOfPDF1D ( pdf_t0 );
if ( xlalErrno ) {
XLALPrintError ("%s: mode-estimation failed for pdf_t0. xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
cand.tau_MP = XLALFindModeOfPDF1D ( pdf_tau );
if ( xlalErrno ) {
XLALPrintError ("%s: mode-estimation failed for pdf_tau. xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
} // if posteriors required
/* ----- if requested, compute Ftotal over full data-span */
if ( uvar.computeFtotal )
{
transientFstatMap_t *FtotalMap;
/* prepare special window to cover all the data with one F-stat calculation == Ftotal */
transientWindowRange_t XLAL_INIT_DECL(winRangeAll);
winRangeAll.type = TRANSIENT_NONE;
BOOLEAN useFReg = false;
if ( (FtotalMap = XLALComputeTransientFstatMap ( multiAtoms, winRangeAll, useFReg)) == NULL ) {
XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* we only use twoFtotal = 2 * maxF from this single-Fstat calculation */
REAL8 twoFtotal = 2.0 * FtotalMap->maxF;
if ( uvar.SignalOnly )
twoFtotal += 4;
/* ugly hack: lacking a good container for twoFtotal, we borrow fkdot[3] for this here ;) [only used for paper-MCs] */
cand.doppler.fkdot[3] = twoFtotal;
/* good riddance .. */
XLALDestroyTransientFstatMap ( FtotalMap );
} /* if computeFtotal */
/* ----- if requested, output atoms-vector into file */
if ( uvar.outputAtoms )
{
FILE *fpAtoms;
char *fnameAtoms;
UINT4 len = strlen ( uvar.outputAtoms ) + 20;
if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws );
if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */
if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameAtoms );
fclose (fpAtoms);
} /* if outputAtoms */
/* ----- if requested, output Fstat-map over {t0, tau} */
if ( uvar.outputFstatMap )
{
FILE *fpFstatMap;
char *fnameFstatMap;
UINT4 len = strlen ( uvar.outputFstatMap ) + 20;
if ( (fnameFstatMap = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameFstatMap, "%s_%04d_of_%04d.dat", uvar.outputFstatMap, i + 1, uvar.numDraws );
if ( ( fpFstatMap = fopen ( fnameFstatMap, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open Fstat-map output file '%s' for writing.\n", __func__, fnameFstatMap );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpFstatMap, "%s", cfg.logString ); /* output header info */
fprintf (fpFstatMap, "\nFstat_mn = \\\n" );
if ( XLALfprintfGSLmatrix ( fpFstatMap, "%.9g", cand.FstatMap->F_mn ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALfprintfGSLmatrix() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameFstatMap );
fclose (fpFstatMap);
} /* if outputFstatMap */
/* ----- if requested, output posterior pdfs on transient params {t0, tau} into a file */
if ( uvar.outputPosteriors )
{
FILE *fpPosteriors;
char *fnamePosteriors;
UINT4 len = strlen ( uvar.outputPosteriors ) + 20;
if ( (fnamePosteriors = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnamePosteriors, "%s_%04d_of_%04d.dat", uvar.outputPosteriors, i + 1, uvar.numDraws );
if ( ( fpPosteriors = fopen ( fnamePosteriors, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open posteriors-output file '%s' for writing.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpPosteriors, "%s", cfg.logString ); /* output header info */
/* write them to file, using pdf-method */
if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_t0, "pdf_t0" ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to output t0-posterior to file '%s'.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_tau, "pdf_tau" ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to output tau-posterior to file '%s'.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
/* free mem, close file */
XLALFree ( fnamePosteriors );
fclose (fpPosteriors);
} /* if outputPosteriors */
/* ----- if requested, output transient-cand statistics */
if ( fpTransientStats && write_transientCandidate_to_fp ( fpTransientStats, &cand ) != XLAL_SUCCESS ) {
XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- free Memory */
XLALDestroyTransientFstatMap ( cand.FstatMap );
XLALDestroyMultiFstatAtomVector ( multiAtoms );
XLALDestroyPDF1D ( pdf_t0 );
XLALDestroyPDF1D ( pdf_tau );
} /* for i < numDraws */
/* ----- close files ----- */
if ( fpTransientStats) fclose ( fpTransientStats );
if ( fpInjParams ) fclose ( fpInjParams );
/* ----- free memory ---------- */
XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates );
XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM );
XLALDestroyExpLUT();
/* ----- free amplitude prior pdfs ----- */
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 );
if ( cfg.logString ) XLALFree ( cfg.logString );
gsl_rng_free ( cfg.rng );
XLALDestroyUserVars();
/* did we forget anything ? (doesn't cover gsl-memory!) */
LALCheckMemoryLeaks();
return 0;
} /* main() */
int main(int argc, char *argv[])
{
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( InitUserVars(&uvar, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
MultiLALDetector *detectors = NULL;
XLAL_CHECK( (detectors = XLALMalloc(sizeof(MultiLALDetector))) != NULL, XLAL_ENOMEM );
detectors->length = uvar.IFO->length;
for (UINT4 ii=0; ii<detectors->length; ii++) {
if (strcmp("H1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_4K_DETECTOR]; //H1
} else if (strcmp("L1",uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LLO_4K_DETECTOR]; //L1
} else if (strcmp("V1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_VIRGO_DETECTOR]; //V1
} else if (strcmp("H2", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2
} else if (strcmp("H2r", uvar.IFO->data[ii])==0) {
LALDetector H2 = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2 rotated
H2.frDetector.xArmAzimuthRadians -= 0.25*LAL_PI;
H2.frDetector.yArmAzimuthRadians -= 0.25*LAL_PI;
memset(&(H2.frDetector.name), 0, sizeof(CHAR)*LALNameLength);
snprintf(H2.frDetector.name, LALNameLength, "%s", "LHO_2k_rotatedPiOver4");
XLAL_CHECK( (XLALCreateDetector(&(detectors->sites[ii]), &(H2.frDetector), LALDETECTORTYPE_IFODIFF)) != NULL, XLAL_EFUNC );
} else {
XLAL_ERROR(XLAL_EINVAL, "Not using valid interferometer! Expected 'H1', 'H2', 'H2r' (rotated H2), 'L1', or 'V1' not %s.\n", uvar.IFO->data[ii]);
}
}
EphemerisData *edat = NULL;
XLAL_CHECK( (edat = XLALInitBarycenter(uvar.ephemEarth, uvar.ephemSun)) != NULL, XLAL_EFUNC );
LIGOTimeGPS tStart;
XLALGPSSetREAL8 ( &tStart, uvar.t0 );
XLAL_CHECK( xlalErrno == 0, XLAL_EFUNC, "XLALGPSSetREAL8 failed\n" );
MultiLIGOTimeGPSVector *multiTimestamps = NULL;
XLAL_CHECK( (multiTimestamps = XLALMakeMultiTimestamps(tStart, uvar.Tobs, uvar.Tsft, uvar.SFToverlap, detectors->length)) != NULL, XLAL_EFUNC );
LIGOTimeGPS refTime = multiTimestamps->data[0]->data[0];
MultiDetectorStateSeries *multiStateSeries = NULL;
XLAL_CHECK( (multiStateSeries = XLALGetMultiDetectorStates(multiTimestamps, detectors, edat, uvar.SFToverlap)) != NULL, XLAL_EFUNC );
gsl_rng *rng = NULL;
XLAL_CHECK( (rng = gsl_rng_alloc(gsl_rng_mt19937)) != NULL, XLAL_EFUNC );
gsl_rng_set(rng, 0);
FILE *OUTPUT;
XLAL_CHECK( (OUTPUT = fopen(uvar.outfilename,"w")) != NULL, XLAL_EIO, "Output file %s could not be opened\n", uvar.outfilename );
for (INT4 n=0; n<uvar.skylocations; n++) {
SkyPosition skypos;
if (XLALUserVarWasSet(&(uvar.alpha)) && XLALUserVarWasSet(&(uvar.delta)) && n==0) {
skypos.longitude = uvar.alpha;
skypos.latitude = uvar.delta;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
} else {
skypos.longitude = LAL_TWOPI*gsl_rng_uniform(rng);
skypos.latitude = LAL_PI*gsl_rng_uniform(rng) - LAL_PI_2;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
}
REAL8 cosi0, psi0;
if (XLALUserVarWasSet(&(uvar.cosi)) && n==0) cosi0 = uvar.cosi;
else cosi0 = 2.0*gsl_rng_uniform(rng) - 1.0;
if (XLALUserVarWasSet(&(uvar.psi)) && n==0) psi0 = uvar.psi;
else psi0 = LAL_PI*gsl_rng_uniform(rng);
MultiAMCoeffs *multiAMcoefficients = NULL;
XLAL_CHECK( (multiAMcoefficients = XLALComputeMultiAMCoeffs(multiStateSeries, NULL, skypos)) != NULL, XLAL_EFUNC );
MultiSSBtimes *multissb = NULL;
XLAL_CHECK( (multissb = XLALGetMultiSSBtimes(multiStateSeries, skypos, refTime, SSBPREC_RELATIVISTICOPT)) != NULL, XLAL_EFUNC );
REAL8 frequency0 = 1000.0 + (gsl_rng_uniform(rng)-0.5)/uvar.Tsft;
REAL8 frequency = 1000.0;
for (UINT4 ii=0; ii<multiAMcoefficients->data[0]->a->length; ii++) {
REAL4 Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi0);
REAL4 Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi0);
COMPLEX16 RatioTerm0 = crect(0.5*Fplus1*(1.0+cosi0*cosi0), Fcross1*cosi0)/crect(0.5*Fplus0*(1.0+cosi0*cosi0), Fcross0*cosi0);
REAL4 detPhaseArg = 0.0, detPhaseMag = 0.0;
BOOLEAN loopbroken = 0;
for (INT4 jj=0; jj<50 && !loopbroken; jj++) {
REAL4 psi = 0.02*jj*LAL_PI;
Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi);
Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi);
Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi);
Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi);
for (INT4 kk=0; kk<51 && !loopbroken; kk++) {
//REAL4 cosi = 1.0 - 2.0*0.02*kk;
REAL4 cosi;
if (cosi0<0.0) cosi = -0.02*kk;
else cosi = 0.02*kk;
COMPLEX16 complexnumerator = crect(0.5*Fplus1*(1.0+cosi*cosi), Fcross1*cosi);
COMPLEX16 complexdenominator = crect(0.5*Fplus0*(1.0+cosi*cosi) , Fcross0*cosi);
if (cabs(complexdenominator)>1.0e-7) {
COMPLEX16 complexval = complexnumerator/complexdenominator;
detPhaseMag += fmin(cabs(complexval), 10.0);
detPhaseArg += gsl_sf_angle_restrict_pos(carg(complexval));
} else {
loopbroken = 1;
detPhaseMag = 0.0;
detPhaseArg = 0.0;
}
}
}
detPhaseMag /= 2550.0;
detPhaseArg /= 2550.0;
REAL8 timediff0 = multissb->data[0]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[0]->Tdot->data[ii];
REAL8 timediff1 = multissb->data[1]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[1]->Tdot->data[ii];
REAL8 tau = timediff1 - timediff0;
REAL8 freqshift0 = -LAL_TWOPI*tau*frequency0;
REAL8 freqshift = -LAL_TWOPI*tau*frequency;
REAL8 nearestFrequency = round(multissb->data[0]->Tdot->data[ii]*frequency*uvar.Tsft)/uvar.Tsft;
COMPLEX16 dirichlet0 = conj(DirichletKernelLargeNHann((multissb->data[1]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft)/DirichletKernelLargeNHann((multissb->data[0]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft));
COMPLEX16 dirichlet = conj(DirichletKernelLargeNHann((multissb->data[1]->Tdot->data[ii]*frequency-nearestFrequency)*uvar.Tsft)/DirichletKernelLargeNHann((multissb->data[0]->Tdot->data[ii]*frequency-nearestFrequency)*uvar.Tsft));
COMPLEX16 signal0 = 0.5*crect(0.5*Fplus0*(1.0+cosi0*cosi0), Fcross0*cosi0)*cpolar(1.0, LAL_TWOPI*frequency0*0.5*uvar.Tsft+LAL_TWOPI*frequency0*(multissb->data[0]->DeltaT->data[ii]+multissb->data[0]->Tdot->data[ii]*0.5*uvar.Tsft))*uvar.Tsft*DirichletKernelLargeNHann((multissb->data[0]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft);
COMPLEX16 signal1 = 0.5*crect(0.5*Fplus1*(1.0+cosi0*cosi0), Fcross1*cosi0)*cpolar(1.0, LAL_TWOPI*frequency0*0.5*uvar.Tsft+LAL_TWOPI*frequency0*(multissb->data[1]->DeltaT->data[ii]+multissb->data[1]->Tdot->data[ii]*0.5*uvar.Tsft))*uvar.Tsft*DirichletKernelLargeNHann((multissb->data[1]->Tdot->data[ii]*frequency0-nearestFrequency)*uvar.Tsft);
fprintf(OUTPUT, "%g %g %g %g %g %g %g %g %g %g %g %g %g %g\n", cabs(signal0), gsl_sf_angle_restrict_pos(carg(signal0)), cabs(signal1), gsl_sf_angle_restrict_pos(carg(signal1)), cabs(RatioTerm0), gsl_sf_angle_restrict_pos(carg(RatioTerm0)), detPhaseMag, detPhaseArg, freqshift0, freqshift, cabs(dirichlet0), gsl_sf_angle_restrict_pos(carg(dirichlet0)), cabs(dirichlet), gsl_sf_angle_restrict_pos(carg(dirichlet)));
//fprintf(OUTPUT, "%g %g %g %g\n", cabs(signal0), gsl_sf_angle_restrict_pos(carg(signal0)), cabs(signal1), gsl_sf_angle_restrict_pos(carg(signal1)));
}
XLALDestroyMultiAMCoeffs(multiAMcoefficients);
XLALDestroyMultiSSBtimes(multissb);
}
fclose(OUTPUT);
gsl_rng_free(rng);
XLALDestroyMultiDetectorStateSeries(multiStateSeries);
XLALDestroyMultiTimestamps(multiTimestamps);
XLALDestroyEphemerisData(edat);
XLALFree(detectors);
XLALDestroyUserVars();
}
int main(int argc, char *argv[])
{
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( InitUserVars(&uvar, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
MultiLALDetector *detectors = NULL;
XLAL_CHECK( (detectors = XLALMalloc(sizeof(MultiLALDetector))) != NULL, XLAL_ENOMEM );
detectors->length = uvar.IFO->length;
for (UINT4 ii=0; ii<detectors->length; ii++) {
if (strcmp("H1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_4K_DETECTOR]; //H1
} else if (strcmp("L1",uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LLO_4K_DETECTOR]; //L1
} else if (strcmp("V1", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_VIRGO_DETECTOR]; //V1
} else if (strcmp("H2", uvar.IFO->data[ii])==0) {
detectors->sites[ii] = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2
} else if (strcmp("H2r", uvar.IFO->data[ii])==0) {
LALDetector H2 = lalCachedDetectors[LAL_LHO_2K_DETECTOR]; //H2 rotated
H2.frDetector.xArmAzimuthRadians -= 0.25*LAL_PI;
H2.frDetector.yArmAzimuthRadians -= 0.25*LAL_PI;
memset(&(H2.frDetector.name), 0, sizeof(CHAR)*LALNameLength);
snprintf(H2.frDetector.name, LALNameLength, "%s", "LHO_2k_rotatedPiOver4");
XLAL_CHECK( (XLALCreateDetector(&(detectors->sites[ii]), &(H2.frDetector), LALDETECTORTYPE_IFODIFF)) != NULL, XLAL_EFUNC );
} else {
XLAL_ERROR(XLAL_EINVAL, "Not using valid interferometer! Expected 'H1', 'H2', 'H2r' (rotated H2), 'L1', or 'V1' not %s.\n", uvar.IFO->data[ii]);
}
}
EphemerisData *edat = NULL;
XLAL_CHECK( (edat = XLALInitBarycenter(uvar.ephemEarth, uvar.ephemSun)) != NULL, XLAL_EFUNC );
LIGOTimeGPS tStart;
XLALGPSSetREAL8 ( &tStart, uvar.t0 );
XLAL_CHECK( xlalErrno == 0, XLAL_EFUNC, "XLALGPSSetREAL8 failed\n" );
MultiLIGOTimeGPSVector *multiTimestamps = NULL;
XLAL_CHECK( (multiTimestamps = XLALMakeMultiTimestamps(tStart, uvar.Tobs, uvar.Tsft, uvar.SFToverlap, detectors->length)) != NULL, XLAL_EFUNC );
LIGOTimeGPS refTime = multiTimestamps->data[0]->data[0];
MultiDetectorStateSeries *multiStateSeries = NULL;
XLAL_CHECK( (multiStateSeries = XLALGetMultiDetectorStates(multiTimestamps, detectors, edat, uvar.SFToverlap)) != NULL, XLAL_EFUNC );
gsl_rng *rng = NULL;
XLAL_CHECK( (rng = gsl_rng_alloc(gsl_rng_mt19937)) != NULL, XLAL_EFUNC );
gsl_rng_set(rng, 0);
FILE *OUTPUT;
XLAL_CHECK( (OUTPUT = fopen(uvar.outfilename,"w")) != NULL, XLAL_EIO, "Output file %s could not be opened\n", uvar.outfilename );
for (INT4 n=0; n<uvar.skylocations; n++) {
SkyPosition skypos;
if (XLALUserVarWasSet(&(uvar.alpha)) && XLALUserVarWasSet(&(uvar.delta)) && n==0) {
skypos.longitude = uvar.alpha;
skypos.latitude = uvar.delta;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
} else {
skypos.longitude = LAL_TWOPI*gsl_rng_uniform(rng);
skypos.latitude = LAL_PI*gsl_rng_uniform(rng) - LAL_PI_2;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
}
REAL8 cosi0, psi0;
if (XLALUserVarWasSet(&(uvar.cosi)) && n==0) cosi0 = uvar.cosi;
else cosi0 = 2.0*gsl_rng_uniform(rng) - 1.0;
if (XLALUserVarWasSet(&(uvar.psi)) && n==0) psi0 = uvar.psi;
else psi0 = LAL_PI*gsl_rng_uniform(rng);
MultiAMCoeffs *multiAMcoefficients = NULL;
XLAL_CHECK( (multiAMcoefficients = XLALComputeMultiAMCoeffs(multiStateSeries, NULL, skypos)) != NULL, XLAL_EFUNC );
MultiSSBtimes *multissb = NULL;
XLAL_CHECK( (multissb = XLALGetMultiSSBtimes(multiStateSeries, skypos, refTime, SSBPREC_RELATIVISTICOPT)) != NULL, XLAL_EFUNC );
REAL8 frequency = 1000.0;
REAL8 frequency0 = frequency + (gsl_rng_uniform(rng)-0.5)/uvar.Tsft;
for (UINT4 ii=0; ii<multiAMcoefficients->data[0]->a->length; ii++) {
REAL4 Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi0);
REAL4 Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi0) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi0);
REAL4 Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi0) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi0);
COMPLEX16 RatioTerm0 = crect(0.5*Fplus1*(1.0+cosi0*cosi0), Fcross1*cosi0)/crect(0.5*Fplus0*(1.0+cosi0*cosi0), Fcross0*cosi0); //real det-sig ratio term
REAL4 detPhaseArg = 0.0, detPhaseMag = 0.0;
BOOLEAN loopbroken = 0;
for (INT4 jj=0; jj<16 && !loopbroken; jj++) {
REAL4 psi = 0.0625*jj*LAL_PI;
Fplus0 = multiAMcoefficients->data[0]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[0]->b->data[ii]*sin(2.0*psi);
Fcross0 = multiAMcoefficients->data[0]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[0]->a->data[ii]*sin(2.0*psi);
Fplus1 = multiAMcoefficients->data[1]->a->data[ii]*cos(2.0*psi) + multiAMcoefficients->data[1]->b->data[ii]*sin(2.0*psi);
Fcross1 = multiAMcoefficients->data[1]->b->data[ii]*cos(2.0*psi) - multiAMcoefficients->data[1]->a->data[ii]*sin(2.0*psi);
for (INT4 kk=0; kk<21 && !loopbroken; kk++) {
REAL4 cosi = 1.0 - 2.0*0.05*kk;
if (!uvar.unrestrictedCosi) {
if (cosi0<0.0) cosi = -0.05*kk;
else cosi = 0.05*kk;
}
COMPLEX16 complexnumerator = crect(0.5*Fplus1*(1.0+cosi*cosi), Fcross1*cosi);
COMPLEX16 complexdenominator = crect(0.5*Fplus0*(1.0+cosi*cosi) , Fcross0*cosi);
if (cabs(complexdenominator)>1.0e-6) {
COMPLEX16 complexval = complexnumerator/complexdenominator;
detPhaseMag += fmin(cabs(complexval), 10.0);
detPhaseArg += gsl_sf_angle_restrict_pos(carg(complexval));
} else {
loopbroken = 1;
detPhaseMag = 0.0;
detPhaseArg = 0.0;
}
}
}
detPhaseMag /= 336.0;
detPhaseArg /= 336.0;
COMPLEX16 RatioTerm = cpolar(detPhaseMag, detPhaseArg);
//Bin of interest
REAL8 signalFrequencyBin = round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft) - frequency*uvar.Tsft; //estimated nearest freq in ref IFO
REAL8 timediff0 = multissb->data[0]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[0]->Tdot->data[ii];
REAL8 timediff1 = multissb->data[1]->DeltaT->data[ii] - 0.5*uvar.Tsft*multissb->data[1]->Tdot->data[ii];
REAL8 tau = timediff1 - timediff0;
REAL8 freqshift0 = -LAL_TWOPI*tau*frequency0; //real freq shift
REAL8 freqshift = -LAL_TWOPI*tau*(round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft)/uvar.Tsft); //estimated freq shift
COMPLEX16 phaseshift0 = cpolar(1.0, freqshift0);
COMPLEX16 phaseshift = cpolar(1.0, freqshift);
REAL8 delta0_0 = (multissb->data[0]->Tdot->data[ii]*frequency0-frequency)*uvar.Tsft - signalFrequencyBin;
REAL8 delta1_0 = (multissb->data[1]->Tdot->data[ii]*frequency0-frequency)*uvar.Tsft - signalFrequencyBin;
REAL8 realSigBinDiff = round(delta0_0) - round(delta1_0);
delta1_0 += realSigBinDiff;
REAL8 delta0 = round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft)*(multissb->data[0]->Tdot->data[ii] - 1.0);
REAL8 delta1 = round(multissb->data[0]->Tdot->data[ii]*frequency0*uvar.Tsft)*(multissb->data[1]->Tdot->data[ii] - 1.0);
REAL8 estSigBinDiff = round(delta0) - round(delta1);
delta1 += estSigBinDiff;
COMPLEX16 dirichlet0;
if (!uvar.rectWindow) {
if (fabsf((REAL4)delta1_0)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0_0*delta0_0-1.0))<(REAL4)1.0e-6) dirichlet0 = crect(-2.0, 0.0);
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = -LAL_PI*crectf(cos(LAL_PI*delta0_0), -sin(LAL_PI*delta0_0))*delta0_0*(delta0_0*delta0_0 - 1.0)/sin(LAL_PI*delta0_0);
}
else if (fabsf((REAL4)(delta1_0*delta1_0-1.0))<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = crect(-0.5, 0.0);
else if (fabsf((REAL4)(delta0_0*delta0_0-1.0))<(REAL4)1.0e-6) dirichlet0 = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = -LAL_PI_2*crectf(-cos(LAL_PI*delta0_0), sin(LAL_PI*delta0_0))*delta0_0*(delta0_0*delta0_0 - 1.0)/sin(LAL_PI*delta0_0);
}
else if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = -LAL_1_PI*crectf(cos(LAL_PI*delta1_0), sin(LAL_PI*delta1_0))*sin(LAL_PI*delta1_0)/(delta1_0*(delta1_0*delta1_0-1.0));
else if (fabsf((REAL4)(delta0_0*delta0_0-1.0))<(REAL4)1.0e-6) dirichlet0 = LAL_2_PI*crectf(cos(LAL_PI*delta1_0), sin(LAL_PI*delta1_0))*sin(LAL_PI*delta1_0)/(delta1_0*(delta1_0*delta1_0-1.0));
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = sin(LAL_PI*delta1_0)/sin(LAL_PI*delta0_0)*(delta0_0*(delta0_0*delta0_0-1.0))/(delta1_0*(delta1_0*delta1_0-1.0))*cpolarf(1.0,LAL_PI*(delta1_0-delta0_0));
} else {
if (fabsf((REAL4)delta1_0)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = conj(1.0/((cpolar(1.0,LAL_TWOPI*delta0_0)-1.0)/crect(0.0,LAL_TWOPI*delta0_0)));
}
else if (fabsf((REAL4)delta0_0)<(REAL4)1.0e-6) dirichlet0 = conj((cpolar(1.0,LAL_TWOPI*delta1_0)-1.0)/crect(0.0,LAL_TWOPI*delta1_0));
else if (fabsf((REAL4)(delta0_0-roundf(delta0_0)))<(REAL4)1.0e-6) {
dirichlet0 = crect(0.0, 0.0);
continue;
}
else dirichlet0 = conj(((cpolar(1.0,LAL_TWOPI*delta1_0)-1.0)/crect(0.0,LAL_TWOPI*delta1_0))/((cpolar(1.0,LAL_TWOPI*delta0_0)-1.0)/crect(0.0,LAL_TWOPI*delta0_0)));
}
COMPLEX16 dirichlet;
if (!uvar.rectWindow) {
if (fabsf((REAL4)delta1)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0*delta0-1.0))<(REAL4)1.0e-6) dirichlet = crect(-2.0, 0.0);
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = -LAL_PI*crectf(cos(LAL_PI*delta0), -sin(LAL_PI*delta0))*delta0*(delta0*delta0 - 1.0)/sin(LAL_PI*delta0);
}
else if (fabsf((REAL4)(delta1*delta1-1.0))<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = crect(-0.5, 0.0);
else if (fabsf((REAL4)(delta0*delta0-1.0))<(REAL4)1.0e-6) dirichlet = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = -LAL_PI_2*crectf(-cos(LAL_PI*delta0), sin(LAL_PI*delta0))*delta0*(delta0*delta0 - 1.0)/sin(LAL_PI*delta0);
}
else if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = -LAL_1_PI*crectf(cos(LAL_PI*delta1), sin(LAL_PI*delta1))*sin(LAL_PI*delta1)/(delta1*(delta1*delta1-1.0));
else if (fabsf((REAL4)(delta0*delta0-1.0))<(REAL4)1.0e-6) dirichlet = LAL_2_PI*crectf(cos(LAL_PI*delta1), sin(LAL_PI*delta1))*sin(LAL_PI*delta1)/(delta1*(delta1*delta1-1.0));
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = sin(LAL_PI*delta1)/sin(LAL_PI*delta0)*(delta0*(delta0*delta0-1.0))/(delta1*(delta1*delta1-1.0))*cpolarf(1.0,LAL_PI*(delta1-delta0));
} else {
if (fabsf((REAL4)delta1)<(REAL4)1.0e-6) {
if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = crect(1.0, 0.0);
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = conj(1.0/((cpolar(1.0,LAL_TWOPI*delta0)-1.0)/crect(0.0,LAL_TWOPI*delta0)));
}
else if (fabsf((REAL4)delta0)<(REAL4)1.0e-6) dirichlet = conj((cpolar(1.0,LAL_TWOPI*delta1)-1.0)/crect(0.0,LAL_TWOPI*delta1));
else if (fabsf((REAL4)(delta0-roundf(delta0)))<(REAL4)1.0e-6) dirichlet = crect(0.0, 0.0);
else dirichlet = conj(((cpolar(1.0,LAL_TWOPI*delta1)-1.0)/crect(0.0,LAL_TWOPI*delta1))/((cpolar(1.0,LAL_TWOPI*delta0)-1.0)/crect(0.0,LAL_TWOPI*delta0)));
}
dirichlet = cpolar(1.0, carg(dirichlet));
if (fabs(floor(delta0)-floor(delta1))>=1.0) dirichlet *= -1.0;
COMPLEX16 realRatio = RatioTerm0*phaseshift0*conj(dirichlet0);
COMPLEX16 estRatio = RatioTerm*phaseshift*conj(dirichlet);
fprintf(OUTPUT, "%g %g %g %g\n", cabs(realRatio), gsl_sf_angle_restrict_pos(carg(realRatio)), cabs(estRatio), gsl_sf_angle_restrict_pos(carg(estRatio)));
}
XLALDestroyMultiAMCoeffs(multiAMcoefficients);
XLALDestroyMultiSSBtimes(multissb);
}
fclose(OUTPUT);
gsl_rng_free(rng);
XLALDestroyMultiDetectorStateSeries(multiStateSeries);
XLALDestroyMultiTimestamps(multiTimestamps);
XLALDestroyEphemerisData(edat);
XLALFree(detectors);
XLALDestroyUserVars();
}
//Main program
int main(int argc, char *argv[])
{
FILE *OUTPUT;
LALDetector det;
LALStatus XLAL_INIT_DECL(status);
UserVariables_t XLAL_INIT_DECL(uvar);
XLAL_CHECK ( InitUserVars(&uvar, argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK( (OUTPUT = fopen(uvar.outfilename,"w")) != NULL, XLAL_EIO, "Output file %s could not be opened\n", uvar.outfilename );
//Interferometer
if (strcmp("L1", uvar.IFO)==0) {
fprintf(stderr,"IFO = %s\n", uvar.IFO);
det = lalCachedDetectors[LAL_LLO_4K_DETECTOR]; //L1
} else if (strcmp("H1", uvar.IFO)==0) {
fprintf(stderr,"IFO = %s\n", uvar.IFO);
det = lalCachedDetectors[LAL_LHO_4K_DETECTOR]; //H1
} else if (strcmp("V1", uvar.IFO)==0) {
fprintf(stderr,"IFO = %s\n", uvar.IFO);
det = lalCachedDetectors[LAL_VIRGO_DETECTOR]; //V1
} else {
XLAL_ERROR( XLAL_EINVAL, "Not using valid interferometer! Expected 'H1', 'L1', or 'V1' not %s.\n", uvar.IFO);
}
//Parameters for the sky-grid
fprintf(stderr, "Sky region = %s\n", uvar.skyRegion);
DopplerSkyScanInit XLAL_INIT_DECL(scanInit);
DopplerSkyScanState XLAL_INIT_DECL(scan);
PulsarDopplerParams dopplerpos;
scanInit.gridType = GRID_ISOTROPIC; //Default value for an approximate-isotropic grid
scanInit.skyRegionString = uvar.skyRegion; //"allsky" = Default value for all-sky search
scanInit.numSkyPartitions = 1; //Default value so sky is not broken into chunks
scanInit.Freq = uvar.fmin+0.5*uvar.fspan; //Mid-point of the frequency band
//Initialize ephemeris data structure
EphemerisData *edat = NULL;
XLAL_CHECK( (edat = XLALInitBarycenter(uvar.ephemEarth, uvar.ephemSun)) != NULL, XLAL_EFUNC );
//v1: Maximum orbital earth speed in units of c from start of S6 TwoSpect data for 104 weeks total time
//else: maximum detector velocity around the time of observation
REAL4 detectorVmax = 0.0;
if (uvar.v1) detectorVmax = CompDetectorVmax(931081500.0+uvar.SFToverlap, uvar.Tsft, uvar.SFToverlap, 62899200.0-uvar.SFToverlap, det, edat);
else detectorVmax = CompDetectorVmax(uvar.t0-uvar.Tsft, uvar.Tsft, uvar.SFToverlap, uvar.Tobs+2.0*uvar.Tsft, det, edat);
XLAL_CHECK( xlalErrno == 0, XLAL_EFUNC, "CompDetectorVmax() failed\n" );
//Initialize the sky-grid
scanInit.dAlpha = 0.5/((uvar.fmin+0.5*uvar.fspan) * uvar.Tsft * detectorVmax);
scanInit.dDelta = scanInit.dAlpha;
InitDopplerSkyScan(&status, &scan, &scanInit);
XLAL_CHECK( status.statusCode == 0, XLAL_EFUNC );
//Start at first location
XLAL_CHECK( XLALNextDopplerSkyPos(&dopplerpos, &scan) == XLAL_SUCCESS, XLAL_EFUNC );
//loop through and output to the specified file
while (scan.state != STATE_FINISHED) {
fprintf(OUTPUT, "%.6f %.6f\n", dopplerpos.Alpha, dopplerpos.Delta);
//Iterate to next sky location
XLAL_CHECK( XLALNextDopplerSkyPos(&dopplerpos, &scan) == XLAL_SUCCESS, XLAL_EFUNC );
}
//Destroy
XLALDestroyUserVars();
XLALDestroyEphemerisData(edat);
fclose(OUTPUT);
return 0;
}
/**
* some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,
* but should be enough to catch big obvious malfunctions
*/
int
main(void)
{
int i, my_argc = 8;
char **my_argv;
const char *argv_in[] = { "progname", "--argNum=1", "--argStr=xyz", "--argBool=true", "-a", "1", "-b", "@" TEST_DATA_DIR "ConfigFileSample.cfg" };
UserInput_t XLAL_INIT_DECL(my_uvars);
my_argv = XLALCalloc ( my_argc, sizeof(char*) );
for (i=0; i < my_argc; i ++ )
{
my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);
strcpy ( my_argv[i], argv_in[i] );
}
/* ---------- Register all test user-variables ---------- */
UserInput_t *uvar = &my_uvars;
uvar->string2 = XLALStringDuplicate ( "this is the default value");
XLAL_CHECK ( XLALRegisterUvarMember( argNum, REAL8, 0, REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argStr, STRING, 0, REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argBool, BOOLEAN, 0, REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argInt, INT4, 'a', REQUIRED, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( dummy, INT4, 'c', OPTIONAL, "Testing INT4 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( argB2, BOOLEAN, 'b', REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( string2, STRING, 0, REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( epochGPS, EPOCH, 0, REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( epochMJDTT, EPOCH, 0, REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longHMS, RAJ, 0, REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longRad, RAJ, 0, REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( latDMS, DECJ, 0, REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( latRad, DECJ, 0, REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( longInt, INT8, 0, REQUIRED, "Testing INT8 argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember( long_help, BOOLEAN, 0, NODEFAULT,
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"This option is here to test the help page wrapping of long strings. "
"\n"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces.~"
"This~option~is~here~to~test~the~help~page~wrapping~of~long~strings~without~spaces."
) == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- now read all input from commandline and config-file ---------- */
BOOLEAN should_exit = 0;
XLAL_CHECK ( XLALUserVarReadAllInput ( &should_exit, my_argc, my_argv ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( should_exit == 0, XLAL_EFUNC );
/* ---------- test print usage and help page */
printf( "=== Begin usage string ===\n" );
fflush( stdout );
XLALUserVarPrintUsage( stdout );
printf( "--- End usage string ---\n" );
printf( "=== Begin help page ===\n" );
fflush( stdout );
XLALUserVarPrintHelp( stdout );
printf( "--- End help page ---\n" );
fflush( stdout );
/* ---------- test log-generation */
CHAR *logstr;
XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE )) != NULL, XLAL_EFUNC );
XLALFree ( logstr );
/* ---------- test values were read in correctly ---------- */
XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );
XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );
XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );
XLAL_CHECK ( uvar->argInt == 1, XLAL_EFAILED, "Failed to read in argInt\n" );
XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );
XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );
char buf1[256], buf2[256];
XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",
XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );
REAL8 diff, tol = 3e-15;
XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > %g\n", uvar->longHMS, uvar->longRad, diff, tol );
XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > %g\n", uvar->latDMS, uvar->latRad, diff, tol );
XLAL_CHECK ( uvar->longInt == 4294967294, XLAL_EFAILED, "Failed to read an INT8: longInt = %" LAL_INT8_FORMAT " != 4294967294", uvar->longInt );
/* ----- cleanup ---------- */
XLALDestroyUserVars();
for (i=0; i < my_argc; i ++ ) {
XLALFree ( my_argv[i] );
}
XLALFree ( my_argv );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->randSeed = 1;
uvar->Nruns = 1;
uvar->inAlign = uvar->outAlign = sizeof(void*);
// ---------- register user-variable ----------
XLALRegisterUvarMember( randSeed, INT4, 's', OPTIONAL, "Random-number seed");
XLALRegisterUvarMember( Nruns, INT4, 'r', OPTIONAL, "Number of repeated timing 'runs' to average over (=improves variance)" );
XLALRegisterUvarMember( inAlign, INT4, 'a', OPTIONAL, "Alignment of input vectors; default is sizeof(void*), i.e. no particular alignment" );
XLALRegisterUvarMember( outAlign, INT4, 'b', OPTIONAL, "Alignment of output vectors; default is sizeof(void*), i.e. no particular alignment" );
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv, lalVCSInfoList ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit (1);
}
srand ( uvar->randSeed );
XLAL_CHECK ( uvar->Nruns >= 1, XLAL_EDOM );
UINT4 Nruns = (UINT4)uvar->Nruns;
UINT4 Ntrials = 1000000 + 7;
REAL4VectorAligned *xIn_a, *xIn2_a, *xOut_a, *xOut2_a;
XLAL_CHECK ( ( xIn_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xIn2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOut_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOut2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
REAL4VectorAligned *xOutRef_a, *xOutRef2_a;
XLAL_CHECK ( (xOutRef_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (xOutRef2_a = XLALCreateREAL4VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
// extract aligned REAL4 vectors from these
REAL4 *xIn = xIn_a->data;
REAL4 *xIn2 = xIn2_a->data;
REAL4 *xOut = xOut_a->data;
REAL4 *xOut2 = xOut2_a->data;
REAL4 *xOutRef = xOutRef_a->data;
REAL4 *xOutRef2 = xOutRef2_a->data;
UINT4Vector *xOutU4;
UINT4Vector *xOutRefU4;
XLAL_CHECK ( ( xOutU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOutRefU4 = XLALCreateUINT4Vector ( Ntrials )) != NULL, XLAL_EFUNC );
REAL8VectorAligned *xInD_a, *xIn2D_a, *xOutD_a, *xOutRefD_a;
XLAL_CHECK ( ( xInD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xIn2D_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->inAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( ( xOutD_a = XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (xOutRefD_a= XLALCreateREAL8VectorAligned ( Ntrials, uvar->outAlign )) != NULL, XLAL_EFUNC );
// extract aligned REAL8 vectors from these
REAL8 *xInD = xInD_a->data;
REAL8 *xIn2D = xIn2D_a->data;
REAL8 *xOutD = xOutD_a->data;
REAL8 *xOutRefD = xOutRefD_a->data;
REAL8 tic, toc;
REAL4 maxErr = 0, maxRelerr = 0;
REAL4 abstol, reltol;
XLALPrintInfo ("Testing sin(x), cos(x) for x in [-1000, 1000]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 2000 * ( frand() - 0.5 );
}
abstol = 2e-7, reltol = 1e-5;
// ==================== SIN() ====================
TESTBENCH_VECTORMATH_S2S(Sin,xIn);
// ==================== COS() ====================
TESTBENCH_VECTORMATH_S2S(Cos,xIn);
// ==================== SINCOS() ====================
TESTBENCH_VECTORMATH_S2SS(SinCos,xIn);
// ==================== SINCOS(2PI*x) ====================
TESTBENCH_VECTORMATH_S2SS(SinCos2Pi,xIn);
// ==================== EXP() ====================
XLALPrintInfo ("\nTesting exp(x) for x in [-10, 10]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 20 * ( frand() - 0.5 );
}
abstol = 4e-3, reltol = 3e-7;
TESTBENCH_VECTORMATH_S2S(Exp,xIn);
// ==================== LOG() ====================
XLALPrintInfo ("\nTesting log(x) for x in (0, 10000]\n");
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = 10000.0f * frand() + 1e-6;
} // for i < Ntrials
abstol = 2e-6, reltol = 2e-7;
TESTBENCH_VECTORMATH_S2S(Log,xIn);
// ==================== ADD,MUL ====================
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xInD[i] = -100000.0 + 200000.0 * frand() + 1e-6;
xIn2D[i]= -100000.0 + 200000.0 * frand() + 1e-6;
} // for i < Ntrials
abstol = 2e-7, reltol = 2e-7;
XLALPrintInfo ("\nTesting add,multiply,shift,scale(x,y) for x,y in (-10000, 10000]\n");
TESTBENCH_VECTORMATH_SS2S(Add,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Multiply,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Max,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2S(Shift,xIn[0],xIn2);
TESTBENCH_VECTORMATH_SS2S(Scale,xIn[0],xIn2);
TESTBENCH_VECTORMATH_DD2D(Scale,xInD[0],xIn2D);
// ==================== FIND ====================
for ( UINT4 i = 0; i < Ntrials; i ++ ) {
xIn[i] = -10000.0f + 20000.0f * frand() + 1e-6;
xIn2[i] = -10000.0f + 20000.0f * frand() + 1e-6;
} // for i < Ntrials
XLALPrintInfo ("\nTesting find for x,y in (-10000, 10000]\n");
TESTBENCH_VECTORMATH_SS2uU(FindVectorLessEqual,xIn,xIn2);
TESTBENCH_VECTORMATH_SS2uU(FindScalarLessEqual,xIn[0],xIn2);
XLALPrintInfo ("\n");
// ---------- clean up memory ----------
XLALDestroyREAL4VectorAligned ( xIn_a );
XLALDestroyREAL4VectorAligned ( xIn2_a );
XLALDestroyREAL4VectorAligned ( xOut_a );
XLALDestroyREAL4VectorAligned ( xOut2_a );
XLALDestroyREAL4VectorAligned ( xOutRef_a );
XLALDestroyREAL4VectorAligned ( xOutRef2_a );
XLALDestroyUINT4Vector ( xOutU4 );
XLALDestroyUINT4Vector ( xOutRefU4 );
XLALDestroyREAL8VectorAligned ( xInD_a );
XLALDestroyREAL8VectorAligned ( xIn2D_a );
XLALDestroyREAL8VectorAligned ( xOutD_a );
XLALDestroyREAL8VectorAligned ( xOutRefD_a );
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/*============================================================
* FUNCTION definitions
*============================================================*/
int
main(int argc, char *argv[])
{
static LALStatus status; /* LALStatus pointer */
UserVariables_t XLAL_INIT_DECL(uvar);
ConfigVariables_t XLAL_INIT_DECL(cfg);
UINT4 k, numBins, numIFOs, maxNumSFTs, X, alpha;
REAL8 Freq0, dFreq, normPSD;
UINT4 finalBinSize, finalBinStep, finalNumBins;
REAL8Vector *overSFTs = NULL; /* one frequency bin over SFTs */
REAL8Vector *overIFOs = NULL; /* one frequency bin over IFOs */
REAL8Vector *finalPSD = NULL; /* math. operation PSD over SFTs and IFOs */
REAL8Vector *finalNormSFT = NULL; /* normalised SFT power */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
/* register and read user variables */
if (initUserVars(argc, argv, &uvar) != XLAL_SUCCESS)
return EXIT_FAILURE;
MultiSFTVector *inputSFTs = NULL;
if ( ( inputSFTs = XLALReadSFTs ( &cfg, &uvar ) ) == NULL )
{
XLALPrintError ("Call to XLALReadSFTs() failed with xlalErrno = %d\n", xlalErrno );
return EXIT_FAILURE;
}
/* clean sfts if required */
if ( XLALUserVarWasSet( &uvar.linefiles ) )
{
RandomParams *randPar=NULL;
FILE *fpRand=NULL;
INT4 seed, ranCount;
if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) {
fprintf(stderr,"Error in opening /dev/urandom" );
return EXIT_FAILURE;
}
if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) {
fprintf(stderr,"Error in getting random seed" );
return EXIT_FAILURE;
}
LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status );
LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar.maxBinsClean, uvar.blocksRngMed, uvar.linefiles, randPar), &status);
LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status);
fclose(fpRand);
} /* end cleaning */
LogPrintf (LOG_DEBUG, "Computing spectrogram and PSD ... ");
/* get power running-median rngmed[ |data|^2 ] from SFTs */
MultiPSDVector *multiPSD = NULL;
XLAL_CHECK_MAIN( ( multiPSD = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.blocksRngMed, NULL ) ) != NULL, XLAL_EFUNC);
/* restrict this PSD to just the "physical" band if requested using {--Freq, --FreqBand} */
if ( ( XLALCropMultiPSDandSFTVectors ( multiPSD, inputSFTs, cfg.firstBin, cfg.lastBin )) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALCropMultiPSDandSFTVectors (inputPSD, inputSFTs, %d, %d) failed with xlalErrno = %d\n", __func__, cfg.firstBin, cfg.lastBin, xlalErrno );
return EXIT_FAILURE;
}
/* start frequency and frequency spacing */
Freq0 = multiPSD->data[0]->data[0].f0;
dFreq = multiPSD->data[0]->data[0].deltaF;
/* number of raw bins in final PSD */
numBins = multiPSD->data[0]->data[0].data->length;
if ( (finalPSD = XLALCreateREAL8Vector ( numBins )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* number of IFOs */
numIFOs = multiPSD->length;
if ( (overIFOs = XLALCreateREAL8Vector ( numIFOs )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* maximum number of SFTs */
maxNumSFTs = 0;
for (X = 0; X < numIFOs; ++X) {
maxNumSFTs = GSL_MAX(maxNumSFTs, multiPSD->data[X]->length);
}
if ( (overSFTs = XLALCreateREAL8Vector ( maxNumSFTs )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* normalize rngmd(power) to get proper *single-sided* PSD: Sn = (2/Tsft) rngmed[|data|^2]] */
normPSD = 2.0 * dFreq;
/* loop over frequency bins in final PSD */
for (k = 0; k < numBins; ++k) {
/* loop over IFOs */
for (X = 0; X < numIFOs; ++X) {
/* number of SFTs for this IFO */
UINT4 numSFTs = multiPSD->data[X]->length;
/* copy PSD frequency bins and normalise multiPSD for later use */
for (alpha = 0; alpha < numSFTs; ++alpha) {
multiPSD->data[X]->data[alpha].data->data[k] *= normPSD;
overSFTs->data[alpha] = multiPSD->data[X]->data[alpha].data->data[k];
}
/* compute math. operation over SFTs for this IFO */
overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.PSDmthopSFTs);
if ( isnan( overIFOs->data[X] ) )
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X );
} /* for IFOs X */
/* compute math. operation over IFOs for this frequency */
finalPSD->data[k] = math_op(overIFOs->data, numIFOs, uvar.PSDmthopIFOs);
if ( isnan ( finalPSD->data[k] ) )
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in finalPSD->data[k=%d] = NAN ... exiting\n", k );
} /* for freq bins k */
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
/* compute normalised SFT power */
if (uvar.outputNormSFT) {
LogPrintf (LOG_DEBUG, "Computing normalised SFT power ... ");
if ( (finalNormSFT = XLALCreateREAL8Vector ( numBins )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* loop over frequency bins in SFTs */
for (k = 0; k < numBins; ++k) {
/* loop over IFOs */
for (X = 0; X < numIFOs; ++X) {
/* number of SFTs for this IFO */
UINT4 numSFTs = inputSFTs->data[X]->length;
/* compute SFT power */
for (alpha = 0; alpha < numSFTs; ++alpha) {
COMPLEX8 bin = inputSFTs->data[X]->data[alpha].data->data[k];
overSFTs->data[alpha] = crealf(bin)*crealf(bin) + cimagf(bin)*cimagf(bin);
}
/* compute math. operation over SFTs for this IFO */
overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.nSFTmthopSFTs);
if ( isnan ( overIFOs->data[X] ))
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X );
} /* over IFOs */
/* compute math. operation over IFOs for this frequency */
finalNormSFT->data[k] = math_op(overIFOs->data, numIFOs, uvar.nSFTmthopIFOs);
if ( isnan( finalNormSFT->data[k] ) )
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in bin finalNormSFT->data[k=%d] = NAN ... exiting\n", k );
} /* over freq bins */
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
}
/* output spectrograms */
if ( uvar.outputSpectBname ) {
LAL_CALL ( LALfwriteSpectrograms ( &status, uvar.outputSpectBname, multiPSD ), &status );
}
/* ---------- if user requested it, output complete MultiPSDVector over IFOs X, timestamps and freq-bins into ASCI file(s) */
if ( uvar.dumpMultiPSDVector ) {
if ( XLALDumpMultiPSDVector ( uvar.outputPSD, multiPSD ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALDumpMultiPSDVector() failed, xlalErrnor = %d\n", __func__, xlalErrno );
return EXIT_FAILURE;
}
} /* if uvar.dumpMultiPSDVector */
/* ----- if requested, compute data-quality factor 'Q' -------------------- */
if ( uvar.outputQ )
{
REAL8FrequencySeries *Q;
if ( (Q = XLALComputeSegmentDataQ ( multiPSD, cfg.dataSegment )) == NULL ) {
XLALPrintError ("%s: XLALComputeSegmentDataQ() failed with xlalErrno = %d\n", __func__, xlalErrno );
return EXIT_FAILURE;
}
if ( XLAL_SUCCESS != XLALWriteREAL8FrequencySeries_to_file ( Q, uvar.outputQ ) ) {
return EXIT_FAILURE;
}
XLALDestroyREAL8FrequencySeries ( Q );
} /* if outputQ */
/* ---------- BINNING if requested ---------- */
/* work out bin size */
if (XLALUserVarWasSet(&uvar.binSize)) {
finalBinSize = uvar.binSize;
}
else if (XLALUserVarWasSet(&uvar.binSizeHz)) {
finalBinSize = (UINT4)floor(uvar.binSizeHz / dFreq + 0.5); /* round to nearest bin */
}
else {
finalBinSize = 1;
}
/* work out bin step */
if (XLALUserVarWasSet(&uvar.binStep)) {
finalBinStep = uvar.binStep;
}
else if (XLALUserVarWasSet(&uvar.binStepHz)) {
finalBinStep = (UINT4)floor(uvar.binStepHz / dFreq + 0.5); /* round to nearest bin */
}
else {
finalBinStep = finalBinSize;
}
/* work out total number of bins */
finalNumBins = (UINT4)floor((numBins - finalBinSize) / finalBinStep) + 1;
/* write final PSD to file */
if (XLALUserVarWasSet(&uvar.outputPSD)) {
FILE *fpOut = NULL;
if ((fpOut = fopen(uvar.outputPSD, "wb")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Unable to open output file %s for writing...exiting \n", uvar.outputPSD );
return EXIT_FAILURE;
}
/* write header info in comments */
if ( XLAL_SUCCESS != XLALOutputVersionString ( fpOut, 0 ) )
XLAL_ERROR ( XLAL_EFUNC );
/* write the command-line */
for (int a = 0; a < argc; a++)
fprintf(fpOut,"%%%% argv[%d]: '%s'\n", a, argv[a]);
/* write column headings */
fprintf(fpOut,"%%%% columns:\n%%%% FreqBinStart");
if (uvar.outFreqBinEnd)
fprintf(fpOut," FreqBinEnd");
fprintf(fpOut," PSD");
if (uvar.outputNormSFT)
fprintf(fpOut," normSFTpower");
fprintf(fpOut,"\n");
LogPrintf(LOG_DEBUG, "Printing PSD to file ... ");
for (k = 0; k < finalNumBins; ++k) {
UINT4 b = k * finalBinStep;
REAL8 f0 = Freq0 + b * dFreq;
REAL8 f1 = f0 + finalBinStep * dFreq;
fprintf(fpOut, "%f", f0);
if (uvar.outFreqBinEnd)
fprintf(fpOut, " %f", f1);
REAL8 psd = math_op(&(finalPSD->data[b]), finalBinSize, uvar.PSDmthopBins);
if ( isnan ( psd ))
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in psd[k=%d] = NAN ... exiting\n", k );
fprintf(fpOut, " %e", psd);
if (uvar.outputNormSFT) {
REAL8 nsft = math_op(&(finalNormSFT->data[b]), finalBinSize, uvar.nSFTmthopBins);
if ( isnan ( nsft ))
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in nsft[k=%d] = NAN ... exiting\n", k );
fprintf(fpOut, " %f", nsft);
}
fprintf(fpOut, "\n");
} // k < finalNumBins
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
fclose(fpOut);
}
/* we are now done with the psd */
XLALDestroyMultiPSDVector ( multiPSD);
XLALDestroyMultiSFTVector ( inputSFTs);
XLALDestroyUserVars();
XLALDestroyREAL8Vector ( overSFTs );
XLALDestroyREAL8Vector ( overIFOs );
XLALDestroyREAL8Vector ( finalPSD );
XLALDestroyREAL8Vector ( finalNormSFT );
LALCheckMemoryLeaks();
return EXIT_SUCCESS;
} /* main() */
/**
* some basic consistency checks of the (XLAL) UserInput module, far from exhaustive,
* but should be enough to catch big obvious malfunctions
*/
int
main(int argc, char *argv[])
{
int i, my_argc = 8;
char **my_argv;
const char *argv_in[] = { "progname", "--argNum=1", "--argStr=xyz", "--argBool=true", "-a", "1", "-b", "@" TEST_DATA_DIR "ConfigFileSample.cfg" };
UserInput_t XLAL_INIT_DECL(my_uvars);
XLAL_CHECK ( argc == 1, XLAL_EINVAL, "No input arguments allowed.\n");
my_argv = XLALCalloc ( my_argc, sizeof(char*) );
for (i=0; i < my_argc; i ++ )
{
my_argv[i] = XLALCalloc ( 1, strlen(argv_in[i])+1);
strcpy ( my_argv[i], argv_in[i] );
}
/* ---------- Register all test user-variables ---------- */
UserInput_t *uvar = &my_uvars;
XLAL_CHECK ( XLALregREALUserStruct( argNum, 0, UVAR_REQUIRED, "Testing float argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregSTRINGUserStruct( argStr, 0, UVAR_REQUIRED, "Testing string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregBOOLUserStruct( argBool, 0, UVAR_REQUIRED, "Testing bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregINTUserStruct( argInt, 'a', UVAR_REQUIRED, "Testing INT argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregINTUserStruct( dummy, 'c', UVAR_OPTIONAL, "Testing INT argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregBOOLUserStruct( argB2, 'b', UVAR_REQUIRED, "Testing short-option bool argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregSTRINGUserStruct( string2, 0, UVAR_REQUIRED, "Testing another string argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregEPOCHUserStruct( epochGPS, 0, UVAR_REQUIRED, "Testing epoch given as GPS time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregEPOCHUserStruct( epochMJDTT, 0, UVAR_REQUIRED, "Testing epoch given as MJD(TT) time") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregRAJUserStruct( longHMS, 0, UVAR_REQUIRED, "Testing RAJ(HMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregRAJUserStruct( longRad, 0, UVAR_REQUIRED, "Testing RAJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregDECJUserStruct( latDMS, 0, UVAR_REQUIRED, "Testing DECJ(DMS) argument") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALregDECJUserStruct( latRad, 0, UVAR_REQUIRED, "Testing DECJ(rad) argument") == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- now read all input from commandline and config-file ---------- */
XLAL_CHECK ( XLALUserVarReadAllInput ( my_argc, my_argv ) == XLAL_SUCCESS, XLAL_EFUNC );
/* ---------- test help-string generation */
CHAR *helpstr;
XLAL_CHECK ( (helpstr = XLALUserVarHelpString ( argv[0])) != NULL, XLAL_EFUNC );
XLALFree ( helpstr );
/* ---------- test log-generation */
CHAR *logstr;
XLAL_CHECK ( ( logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE )) != NULL, XLAL_EFUNC );
XLALFree ( logstr );
/* ---------- test values were read in correctly ---------- */
XLAL_CHECK ( uvar->argNum == 1, XLAL_EFAILED, "Failed to read in argNum\n" );
XLAL_CHECK ( strcmp ( uvar->argStr, "xyz" ) == 0, XLAL_EFAILED, "Failed to read in argStr\n" );
XLAL_CHECK ( uvar->argBool, XLAL_EFAILED, "Failed to read in argBool\n" );
XLAL_CHECK ( uvar->argInt == 1, XLAL_EFAILED, "Failed to read in argInt\n" );
XLAL_CHECK ( uvar->argB2, XLAL_EFAILED, "Failed to read in argB2\n" );
XLAL_CHECK ( strcmp ( uvar->string2, "this is also possible, and # here does nothing; and neither does semi-colon " ) == 0, XLAL_EFAILED, "Failed to read in string2\n" );
char buf1[256], buf2[256];
XLAL_CHECK ( XLALGPSCmp ( &uvar->epochGPS, &uvar->epochMJDTT ) == 0, XLAL_EFAILED, "GPS epoch %s differs from MJD(TT) epoch %s\n",
XLALGPSToStr ( buf1, &uvar->epochGPS), XLALGPSToStr ( buf2, &uvar->epochMJDTT ) );
REAL8 diff, tol = 3e-15;
XLAL_CHECK ( (diff = fabs(uvar->longHMS - uvar->longRad)) < tol, XLAL_EFAILED, "longitude(HMS) = %.16g differs from longitude(rad) = %.16g by %g > tolerance\n", uvar->longHMS, uvar->longRad, diff, tol );
XLAL_CHECK ( (diff = fabs(uvar->latDMS - uvar->latRad)) < tol, XLAL_EFAILED, "latitude(HMS) = %.16g differs from latitude(rad) = %.16g by %g > tolerance\n", uvar->latDMS, uvar->latRad, diff, tol );
/* ----- cleanup ---------- */
XLALDestroyUserVars();
for (i=0; i < my_argc; i ++ ) {
XLALFree ( my_argv[i] );
}
XLALFree ( my_argv );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
// ---------- handle user input ----------
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->FstatMethod = XLALStringDuplicate("ResampBest");
uvar->Freq = 100;
uvar->f1dot = -3e-9;
uvar->FreqResolution = XLALCreateREAL8Vector ( 2 );
uvar->FreqResolution->data[0] = 1;
uvar->FreqResolution->data[1] = 10;
uvar->numFreqBins = XLALCreateINT4Vector ( 2 );
uvar->numFreqBins->data[0] = 1000;
uvar->numFreqBins->data[1] = 100000;
uvar->Tseg = 60 * 3600;
uvar->numSegments = 90;
uvar->numTrials = 1;
uvar->Tsft = 1800;
uvar->runBuffered = 0;
XLAL_CHECK ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) != NULL, XLAL_EFUNC );
uvar->outputInfo = NULL;
XLAL_CHECK ( XLALRegisterUvarMember ( help, BOOLEAN, 'h', HELP, "Print help message" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FstatMethod, STRING, 0, OPTIONAL, XLALFstatMethodHelpString() ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Freq, REAL8, 0, OPTIONAL, "Search frequency in Hz" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( f1dot, REAL8, 0, OPTIONAL, "Search spindown f1dot in Hz/s" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FreqResolution, REAL8Vector, 0, OPTIONAL, "Range of frequency resolution factor 'r' (st dFreq = 1/(r*T)) [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tseg, REAL8, 0, OPTIONAL, "Coherent segment length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numSegments, INT4, 0, OPTIONAL, "Number of semi-coherent segment" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numFreqBins, INT4Vector, 0, OPTIONAL, "Range of number of frequency bins to search [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( IFOs, STRINGVector, 0, OPTIONAL, "IFOs to use" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numTrials, INT4, 0, OPTIONAL, "Number of repeated trials to run (with potentially randomized parameters)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( outputInfo, STRING, 0, OPTIONAL, "Append Resampling internal info into this file") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tsft, REAL8, 0, DEVELOPER, "SFT length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( runBuffered, BOOLEAN, 0, DEVELOPER, "Explicitly time buffered Fstat call (only useful for double-checking and Demod timing)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar->help) { // if help was requested, we're done here
return XLAL_SUCCESS;
}
// check user input
XLAL_CHECK ( uvar->numSegments >= 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->FreqResolution->length == 1) || (uvar->FreqResolution->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[0] > 0, XLAL_EINVAL );
REAL8 FreqResolutionMin, FreqResolutionMax;
FreqResolutionMin = FreqResolutionMax = uvar->FreqResolution->data[0];
if ( uvar->FreqResolution->length == 2 )
{
XLAL_CHECK ( uvar->FreqResolution->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[1] > uvar->FreqResolution->data[0], XLAL_EINVAL );
FreqResolutionMax = uvar->FreqResolution->data[1];
}
XLAL_CHECK ( uvar->Freq > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tseg > uvar->Tsft, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tsft > 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->numFreqBins->length == 1) || (uvar->numFreqBins->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[0] > 0, XLAL_EINVAL );
UINT4 numFreqBinsMax, numFreqBinsMin;
numFreqBinsMin = numFreqBinsMax = uvar->numFreqBins->data[0];
if ( uvar->numFreqBins->length == 2 )
{
XLAL_CHECK ( uvar->numFreqBins->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[1] > uvar->numFreqBins->data[0], XLAL_EINVAL );
numFreqBinsMax = uvar->numFreqBins->data[1];
}
XLAL_CHECK ( uvar->numTrials >= 1, XLAL_EINVAL );
// ---------- end: handle user input ----------
// common setup over repeated trials
FstatMethodType FstatMethod;
XLAL_CHECK ( XLALParseFstatMethodString ( &FstatMethod, uvar->FstatMethod ) == XLAL_SUCCESS, XLAL_EFUNC );
EphemerisData *ephem;
XLAL_CHECK ( (ephem = XLALInitBarycenter ( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" )) != NULL, XLAL_EFUNC );
REAL8 memBase = XLALGetPeakHeapUsageMB();
UINT4 numDetectors = uvar->IFOs->length;
// ----- setup injection and data parameters
LIGOTimeGPS startTime = {711595934, 0};
LIGOTimeGPS startTime_l = startTime;
LIGOTimeGPS endTime_l;
SFTCatalog **catalogs;
XLAL_CHECK ( (catalogs = XLALCalloc ( uvar->numSegments, sizeof( catalogs[0] ))) != NULL, XLAL_ENOMEM );
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
endTime_l = startTime_l;
XLALGPSAdd( &endTime_l, uvar->Tseg );
MultiLIGOTimeGPSVector *multiTimestamps;
XLAL_CHECK ( (multiTimestamps = XLALMakeMultiTimestamps ( startTime_l, uvar->Tseg, uvar->Tsft, 0, numDetectors )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (catalogs[l] = XLALMultiAddToFakeSFTCatalog ( NULL, uvar->IFOs, multiTimestamps )) != NULL, XLAL_EFUNC );
XLALDestroyMultiTimestamps ( multiTimestamps );
startTime_l = endTime_l;
} // for l < numSegments
LIGOTimeGPS endTime = endTime_l;
UINT4 numSFTsPerSeg = catalogs[0]->length;
FILE *fpInfo = NULL;
if ( (uvar->outputInfo != NULL) && (FstatMethod == FMETHOD_RESAMP_GENERIC) )
{
XLAL_CHECK ( (fpInfo = fopen (uvar->outputInfo, "ab")) != NULL, XLAL_ESYS, "Failed to open '%s' for appending\n", uvar->outputInfo );
XLALAppendResampInfo2File ( fpInfo, NULL ); // create header comment line
}
PulsarSpinRange XLAL_INIT_DECL(spinRange);
LIGOTimeGPS refTime = { startTime.gpsSeconds - 2.3 * uvar->Tseg, 0 };
spinRange.refTime = refTime;
spinRange.fkdot[0] = uvar->Freq;
spinRange.fkdot[1] = uvar->f1dot;
spinRange.fkdotBand[1] = 0;
REAL8 asini = 0, Period = 0, ecc = 0;
REAL8 minCoverFreq, maxCoverFreq;
PulsarDopplerParams XLAL_INIT_DECL(Doppler);
Doppler.refTime = refTime;
Doppler.Alpha = 0.5;
Doppler.Delta = 0.5;
memcpy ( &Doppler.fkdot, &spinRange.fkdot, sizeof(Doppler.fkdot) );;
Doppler.period = Period;
Doppler.ecc = ecc;
Doppler.asini = asini;
// ----- setup optional Fstat arguments
FstatOptionalArgs optionalArgs = FstatOptionalArgsDefaults;
MultiNoiseFloor XLAL_INIT_DECL(injectSqrtSX);
injectSqrtSX.length = numDetectors;
for ( UINT4 X=0; X < numDetectors; X ++ ) {
injectSqrtSX.sqrtSn[X] = 1;
}
optionalArgs.injectSqrtSX = &injectSqrtSX;
optionalArgs.FstatMethod = FstatMethod;
FstatWorkspace *sharedWorkspace = NULL;
FstatInputVector *inputs;
FstatQuantities whatToCompute = (FSTATQ_2F | FSTATQ_2F_PER_DET);
FstatResults *results = NULL;
REAL8 tauF1NoBuf = 0;
REAL8 tauF1Buf = 0;
// ---------- main loop over repeated trials ----------
for ( INT4 i = 0; i < uvar->numTrials; i ++ )
{
// randomize numFreqBins
UINT4 numFreqBins_i = numFreqBinsMin + (UINT4)round ( 1.0 * (numFreqBinsMax - numFreqBinsMin) * rand() / RAND_MAX );
// randomize FreqResolution
REAL8 FreqResolution_i = FreqResolutionMin + 1.0 * ( FreqResolutionMax - FreqResolutionMin ) * rand() / RAND_MAX;
XLAL_CHECK ( (inputs = XLALCreateFstatInputVector ( uvar->numSegments )) != NULL, XLAL_EFUNC );
REAL8 dFreq = 1.0 / ( FreqResolution_i * uvar->Tseg );
REAL8 FreqBand = numFreqBins_i * dFreq;
fprintf ( stderr, "trial %d/%d: Tseg = %.1f d, numSegments = %d, Freq = %.1f Hz, f1dot = %.1e Hz/s, FreqResolution r = %f, numFreqBins = %d [dFreq = %.2e Hz, FreqBand = %.2e Hz]\n",
i+1, uvar->numTrials, uvar->Tseg / 86400.0, uvar->numSegments, uvar->Freq, uvar->f1dot, FreqResolution_i, numFreqBins_i, dFreq, FreqBand );
spinRange.fkdotBand[0] = FreqBand;
XLAL_CHECK ( XLALCWSignalCoveringBand ( &minCoverFreq, &maxCoverFreq, &startTime, &endTime, &spinRange, asini, Period, ecc ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numBinsSFT = ceil ( (maxCoverFreq - minCoverFreq) * uvar->Tsft + 2 * 8 );
REAL8 memSFTs = uvar->numSegments * numSFTsPerSeg * ( sizeof(SFTtype) + numBinsSFT * sizeof(COMPLEX8)) / 1e6;
// create per-segment input structs
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( (inputs->data[l] = XLALCreateFstatInput ( catalogs[l], minCoverFreq, maxCoverFreq, dFreq, ephem, &optionalArgs )) != NULL, XLAL_EFUNC );
if ( l == 0 ) {
sharedWorkspace = XLALGetSharedFstatWorkspace ( inputs->data[0] );
}
optionalArgs.sharedWorkspace = sharedWorkspace;
}
// ----- compute Fstatistics over segments
REAL8 tauF1NoBuf_i = 0;
REAL8 tauF1Buf_i = 0;
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( XLALComputeFstat ( &results, inputs->data[l], &Doppler, numFreqBins_i, whatToCompute ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- output timing details if requested
if ( (fpInfo != NULL) ) {
XLALAppendResampInfo2File ( fpInfo, inputs->data[l] );
}
REAL8 tauF1NoBuf_il, tauF1Buf_il;
XLAL_CHECK ( XLALGetResampTimingInfo ( &tauF1NoBuf_il, &tauF1Buf_il, inputs->data[l] ) == XLAL_SUCCESS, XLAL_EFUNC );
tauF1NoBuf_i += tauF1NoBuf_il;
tauF1Buf_i += tauF1Buf_il;
} // for l < numSegments
tauF1NoBuf_i /= uvar->numSegments;
tauF1Buf_i /= uvar->numSegments;
REAL8 memMaxCompute = XLALGetPeakHeapUsageMB() - memBase;
tauF1Buf += tauF1Buf_i;
tauF1NoBuf += tauF1NoBuf_i;
fprintf (stderr, "%-15s: tauF1Buf = %.2g s, tauF1NoBuf = %.2g s, memSFTs = %.1f MB, memMaxCompute = %.1f MB\n",
XLALGetFstatMethodName ( FstatMethod ), tauF1Buf_i, tauF1NoBuf_i, memSFTs, memMaxCompute );
XLALDestroyFstatInputVector ( inputs );
XLALDestroyFstatWorkspace ( sharedWorkspace );
optionalArgs.sharedWorkspace = NULL;
} // for i < numTrials
tauF1Buf /= uvar->numTrials;
tauF1NoBuf /= uvar->numTrials;
fprintf (stderr, "\nAveraged timings: <tauF1Buf> = %.2g s, <tauF1NoBuf> = %.2g s\n", tauF1Buf, tauF1NoBuf );
// ----- free memory ----------
if ( fpInfo != NULL ) {
fclose ( fpInfo );
}
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLALDestroySFTCatalog ( catalogs[l] );
}
XLALFree ( catalogs );
XLALDestroyFstatResults ( results );
XLALDestroyUserVars();
XLALDestroyEphemerisData ( ephem );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/*----------------------------------------------------------------------
* 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 */
int main(int argc, char *argv[]){
UserInput_t XLAL_INIT_DECL(uvar);
static ConfigVariables config;
/* sft related variables */
MultiSFTVector *inputSFTs = NULL;
MultiPSDVector *multiPSDs = NULL;
MultiNoiseWeights *multiWeights = NULL;
MultiLIGOTimeGPSVector *multiTimes = NULL;
MultiLALDetector multiDetectors;
MultiDetectorStateSeries *multiStates = NULL;
MultiAMCoeffs *multiCoeffs = NULL;
SFTIndexList *sftIndices = NULL;
SFTPairIndexList *sftPairs = NULL;
REAL8Vector *shiftedFreqs = NULL;
UINT4Vector *lowestBins = NULL;
COMPLEX8Vector *expSignalPhases = NULL;
REAL8VectorSequence *sincList = NULL;
PulsarDopplerParams XLAL_INIT_DECL(dopplerpos);
PulsarDopplerParams thisBinaryTemplate, binaryTemplateSpacings;
PulsarDopplerParams minBinaryTemplate, maxBinaryTemplate;
SkyPosition XLAL_INIT_DECL(skyPos);
MultiSSBtimes *multiBinaryTimes = NULL;
INT4 k;
UINT4 j;
REAL8 fMin, fMax; /* min and max frequencies read from SFTs */
REAL8 deltaF; /* frequency resolution associated with time baseline of SFTs */
REAL8 diagff = 0; /*diagonal metric components*/
REAL8 diagaa = 0;
REAL8 diagTT = 0;
REAL8 diagpp = 1;
REAL8 ccStat = 0;
REAL8 evSquared=0;
REAL8 estSens=0; /*estimated sensitivity(4.13)*/
BOOLEAN dopplerShiftFlag = TRUE;
toplist_t *ccToplist=NULL;
CrossCorrBinaryOutputEntry thisCandidate;
UINT4 checksum;
LogPrintf (LOG_CRITICAL, "Starting time\n"); /*for debug convenience to record calculating time*/
/* initialize and register user variables */
LIGOTimeGPS computingStartGPSTime, computingEndGPSTime;
XLALGPSTimeNow (&computingStartGPSTime); /* record the rough starting GPS time*/
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read user input from the command line or config file */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if (uvar.help) /* if help was requested, then exit */
return 0;
CHAR *VCSInfoString = XLALGetVersionString(0); /**<LAL + LALapps Vsersion string*/
/*If the version information was requested, output it and exit*/
if ( uvar.version ){
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
printf ("%s\n", VCSInfoString );
exit (0);
}
/* configure useful variables based on user input */
if ( XLALInitializeConfigVars ( &config, &uvar) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
deltaF = config.catalog->data[0].header.deltaF;
REAL8 Tsft = 1.0 / deltaF;
if (XLALUserVarWasSet(&uvar.spacingF) && XLALUserVarWasSet(&uvar.mismatchF))
LogPrintf (LOG_CRITICAL, "spacingF and mismatchF are both set, use spacingF %.9g by default\n\n", uvar.spacingF);
if (XLALUserVarWasSet(&uvar.spacingA) && XLALUserVarWasSet(&uvar.mismatchA))
LogPrintf (LOG_CRITICAL, "spacingA and mismatchA are both set, use spacingA %.9g by default\n\n", uvar.spacingA);
if (XLALUserVarWasSet(&uvar.spacingT) && XLALUserVarWasSet(&uvar.mismatchT))
LogPrintf (LOG_CRITICAL, "spacingT and mismatchT are both set, use spacingT %.9g by default\n\n", uvar.spacingT);
if (XLALUserVarWasSet(&uvar.spacingP) && XLALUserVarWasSet(&uvar.mismatchP))
LogPrintf (LOG_CRITICAL, "spacingP and mismatchP are both set, use spacingP %.9g by default\n\n", uvar.spacingP);
/* create the toplist */
create_crossCorrBinary_toplist( &ccToplist, uvar.numCand);
/* now read the data */
/* /\* get SFT parameters so that we can initialise search frequency resolutions *\/ */
/* /\* calculate deltaF_SFT *\/ */
/* deltaF_SFT = catalog->data[0].header.deltaF; /\* frequency resolution *\/ */
/* timeBase= 1.0/deltaF_SFT; /\* sft baseline *\/ */
/* /\* catalog is ordered in time so we can get start, end time and tObs *\/ */
/* firstTimeStamp = catalog->data[0].header.epoch; */
/* lastTimeStamp = catalog->data[catalog->length - 1].header.epoch; */
/* tObs = XLALGPSDiff( &lastTimeStamp, &firstTimeStamp ) + timeBase; */
/* /\*set pulsar reference time *\/ */
/* if (LALUserVarWasSet ( &uvar_refTime )) { */
/* XLALGPSSetREAL8(&refTime, uvar_refTime); */
/* } */
/* else { /\*if refTime is not set, set it to midpoint of sfts*\/ */
/* XLALGPSSetREAL8(&refTime, (0.5*tObs) + XLALGPSGetREAL8(&firstTimeStamp)); */
/* } */
/* /\* set frequency resolution defaults if not set by user *\/ */
/* if (!(LALUserVarWasSet (&uvar_fResolution))) { */
/* uvar_fResolution = 1/tObs; */
/* } */
/* { */
/* /\* block for calculating frequency range to read from SFTs *\/ */
/* /\* user specifies freq and fdot range at reftime */
/* we translate this range of fdots to start and endtime and find */
/* the largest frequency band required to cover the */
/* frequency evolution *\/ */
/* PulsarSpinRange spinRange_startTime; /\**< freq and fdot range at start-time of observation *\/ */
/* PulsarSpinRange spinRange_endTime; /\**< freq and fdot range at end-time of observation *\/ */
/* PulsarSpinRange spinRange_refTime; /\**< freq and fdot range at the reference time *\/ */
/* REAL8 startTime_freqLo, startTime_freqHi, endTime_freqLo, endTime_freqHi, freqLo, freqHi; */
/* REAL8Vector *fdotsMin=NULL; */
/* REAL8Vector *fdotsMax=NULL; */
/* UINT4 k; */
/* fdotsMin = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMin->length = N_SPINDOWN_DERIVS; */
/* fdotsMin->data = (REAL8 *)LALCalloc(fdotsMin->length, sizeof(REAL8)); */
/* fdotsMax = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMax->length = N_SPINDOWN_DERIVS; */
/* fdotsMax->data = (REAL8 *)LALCalloc(fdotsMax->length, sizeof(REAL8)); */
/* XLAL_INIT_MEM(spinRange_startTime); */
/* XLAL_INIT_MEM(spinRange_endTime); */
/* XLAL_INIT_MEM(spinRange_refTime); */
/* spinRange_refTime.refTime = refTime; */
/* spinRange_refTime.fkdot[0] = uvar_f0; */
/* spinRange_refTime.fkdotBand[0] = uvar_fBand; */
/* } */
/* FIXME: need to correct fMin and fMax for Doppler shift, rngmedian bins and spindown range */
/* this is essentially just a place holder for now */
/* FIXME: this running median buffer is overkill, since the running median block need not be centered on the search frequency */
REAL8 vMax = LAL_TWOPI * (uvar.orbitAsiniSec + uvar.orbitAsiniSecBand) / uvar.orbitPSec + LAL_TWOPI * LAL_REARTH_SI / (LAL_DAYSID_SI * LAL_C_SI) + LAL_TWOPI * LAL_AU_SI/(LAL_YRSID_SI * LAL_C_SI); /*calculate the maximum relative velocity in speed of light*/
fMin = uvar.fStart * (1 - vMax) - 0.5 * uvar.rngMedBlock * deltaF;
fMax = (uvar.fStart + uvar.fBand) * (1 + vMax) + 0.5 * uvar.rngMedBlock * deltaF;
/* read the SFTs*/
if ((inputSFTs = XLALLoadMultiSFTs ( config.catalog, fMin, fMax)) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALLoadMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* calculate the psd and normalize the SFTs */
if (( multiPSDs = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.rngMedBlock, NULL )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALNormalizeMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* compute the noise weights for the AM coefficients */
if (( multiWeights = XLALComputeMultiNoiseWeights ( multiPSDs, uvar.rngMedBlock, 0 )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiNoiseWeights() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the timestamps from the SFTs */
if ((multiTimes = XLALExtractMultiTimestampsFromSFTs ( inputSFTs )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALExtractMultiTimestampsFromSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the detector information from the SFTs */
if ( XLALMultiLALDetectorFromMultiSFTs ( &multiDetectors, inputSFTs ) != XLAL_SUCCESS){
LogPrintf ( LOG_CRITICAL, "%s: XLALMultiLALDetectorFromMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Find the detector state for each SFT */
/* Offset by Tsft/2 to get midpoint as timestamp */
if ((multiStates = XLALGetMultiDetectorStates ( multiTimes, &multiDetectors, config.edat, 0.5 * Tsft )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiDetectorStates() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Note this is specialized to a single sky position */
/* This might need to be moved into the config variables */
skyPos.system = COORDINATESYSTEM_EQUATORIAL;
skyPos.longitude = uvar.alphaRad;
skyPos.latitude = uvar.deltaRad;
/* Calculate the AM coefficients (a,b) for each SFT */
if ((multiCoeffs = XLALComputeMultiAMCoeffs ( multiStates, multiWeights, skyPos )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiAMCoeffs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the flat list of SFTs (this sort of replicates the
catalog, but there's not an obvious way to get the information
back) */
if ( ( XLALCreateSFTIndexListFromMultiSFTVect( &sftIndices, inputSFTs ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTIndexListFromMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the list of SFT pairs */
#define PCC_SFTPAIR_HEADER "# The length of SFT-pair list is %u #\n"
#define PCC_SFTPAIR_BODY "%u %u\n"
#define PCC_SFT_HEADER "# The length of SFT list is %u #\n"
#define PCC_SFT_BODY "%s %d %d\n"
FILE *fp = NULL;
if (XLALUserVarWasSet(&uvar.pairListInputFilename)) { /* If the user provided a list for reading, use it */
if((sftPairs = XLALCalloc(1, sizeof(sftPairs))) == NULL){
XLAL_ERROR(XLAL_ENOMEM);
}
if((fp = fopen(uvar.pairListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "didn't find SFT-pair list file with given input name\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(fscanf(fp,PCC_SFTPAIR_HEADER,&sftPairs->length)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read the length of SFT-pair list from the header\n");
XLAL_ERROR( XLAL_EFUNC );
}
if((sftPairs->data = XLALCalloc(sftPairs->length, sizeof(*sftPairs->data)))==NULL){
XLALFree(sftPairs);
XLAL_ERROR(XLAL_ENOMEM);
}
for(j = 0; j < sftPairs->length; j++){ /*read in the SFT-pair list */
if(fscanf(fp,PCC_SFTPAIR_BODY, &sftPairs->data[j].sftNum[0], &sftPairs->data[j].sftNum[1])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT-pair list doesn't match!");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
}
else { /* if not, construct the list of pairs */
if ( ( XLALCreateSFTPairIndexList( &sftPairs, sftIndices, inputSFTs, uvar.maxLag, uvar.inclAutoCorr ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTPairIndexList() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if (XLALUserVarWasSet(&uvar.pairListOutputFilename)) { /* Write the list of pairs to a file, if a name was provided */
if((fp = fopen(uvar.pairListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in SFT-pair list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFTPAIR_HEADER, sftPairs->length ); /*output the length of SFT-pair list to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_SFTPAIR_BODY, sftPairs->data[j].sftNum[0], sftPairs->data[j].sftNum[1]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.sftListOutputFilename)) { /* Write the list of SFTs to a file for sanity-checking purposes */
if((fp = fopen(uvar.sftListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFT_HEADER, sftIndices->length ); /*output the length of SFT list to the header*/
for(j = 0; j < sftIndices->length; j++){ /*output the SFT list */
fprintf(fp,PCC_SFT_BODY, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds);
}
fclose(fp);
}
else if(XLALUserVarWasSet(&uvar.sftListInputFilename)){ /*do a sanity check of the order of SFTs list if the name of input SFT list is given*/
UINT4 numofsft=0;
if((fp = fopen(uvar.sftListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't read in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
if (fscanf(fp, PCC_SFT_HEADER, &numofsft)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read in the length of SFT list from header\n");
XLAL_ERROR( XLAL_EFUNC );
}
CHARVectorSequence *checkDet=NULL;
if ((checkDet = XLALCreateCHARVectorSequence (numofsft, LALNameLength) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateCHARVector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
INT4 checkGPS[numofsft], checkGPSns[numofsft];
if(numofsft == sftIndices->length){
for (j=0; j<numofsft; j++){
if( fscanf(fp,PCC_SFT_BODY,&checkDet->data[j * LALNameLength], &checkGPS[j], &checkGPSns[j])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT list doesn't match\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(strcmp( inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, &checkDet->data[j * LALNameLength] ) != 0
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds != checkGPS[j]
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds != checkGPSns[j] ){
LogPrintf ( LOG_CRITICAL, "The order of SFTs has been changed, it's the end of civilization\n");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
XLALDestroyCHARVectorSequence(checkDet);
}
else{
LogPrintf ( LOG_CRITICAL, "Run for your life, the length of SFT list doesn't match");
XLAL_ERROR( XLAL_EFUNC );
}
}
else
{
}
/* Get weighting factors for calculation of metric */
/* note that the sigma-squared is now absorbed into the curly G
because the AM coefficients are noise-weighted. */
REAL8Vector *GammaAve = NULL;
REAL8Vector *GammaCirc = NULL;
if ( ( XLALCalculateCrossCorrGammas( &GammaAve, &GammaCirc, sftPairs, sftIndices, multiCoeffs) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrGammas() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
#define PCC_GAMMA_HEADER "# The normalization Sinv_Tsft is %g #\n"
#define PCC_GAMMA_BODY "%.10g\n"
if (XLALUserVarWasSet(&uvar.gammaAveOutputFilename)) { /* Write the aa+bb weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaAveOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_ave list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaAve->data[j]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.gammaCircOutputFilename)) { /* Write the ab-ba weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaCircOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_circ list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaCirc->data[j]);
}
fclose(fp);
}
/*initialize binary parameters structure*/
XLAL_INIT_MEM(minBinaryTemplate);
XLAL_INIT_MEM(maxBinaryTemplate);
XLAL_INIT_MEM(thisBinaryTemplate);
XLAL_INIT_MEM(binaryTemplateSpacings);
/*fill in minbinaryOrbitParams*/
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc);
minBinaryTemplate.argp = 0.0;
minBinaryTemplate.asini = uvar.orbitAsiniSec;
minBinaryTemplate.ecc = 0.0;
minBinaryTemplate.period = uvar.orbitPSec;
minBinaryTemplate.fkdot[0] = uvar.fStart;
/*fill in maxBinaryParams*/
XLALGPSSetREAL8( &maxBinaryTemplate.tp, uvar.orbitTimeAsc + uvar.orbitTimeAscBand);
maxBinaryTemplate.argp = 0.0;
maxBinaryTemplate.asini = uvar.orbitAsiniSec + uvar.orbitAsiniSecBand;
maxBinaryTemplate.ecc = 0.0;
maxBinaryTemplate.period = uvar.orbitPSec;
maxBinaryTemplate.fkdot[0] = uvar.fStart + uvar.fBand;
/*fill in thisBinaryTemplate*/
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * uvar.orbitTimeAscBand);
thisBinaryTemplate.argp = 0.0;
thisBinaryTemplate.asini = 0.5*(minBinaryTemplate.asini + maxBinaryTemplate.asini);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.period =0.5*(minBinaryTemplate.period + maxBinaryTemplate.period);
thisBinaryTemplate.fkdot[0]=0.5*(minBinaryTemplate.fkdot[0] + maxBinaryTemplate.fkdot[0]);
/*Get metric diagonal components, also estimate sensitivity i.e. E[rho]/(h0)^2 (4.13)*/
if ( (XLALCalculateLMXBCrossCorrDiagMetric(&estSens, &diagff, &diagaa, &diagTT, thisBinaryTemplate, GammaAve, sftPairs, sftIndices, inputSFTs, multiWeights /*, kappaValues*/) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateLMXBCrossCorrDiagMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* spacing in frequency from diagff */ /* set spacings in new dopplerparams struct */
if (XLALUserVarWasSet(&uvar.spacingF)) /* If spacing was given by CMD line, use it, else calculate spacing by mismatch*/
binaryTemplateSpacings.fkdot[0] = uvar.spacingF;
else
binaryTemplateSpacings.fkdot[0] = sqrt(uvar.mismatchF / diagff);
if (XLALUserVarWasSet(&uvar.spacingA))
binaryTemplateSpacings.asini = uvar.spacingA;
else
binaryTemplateSpacings.asini = sqrt(uvar.mismatchA / diagaa);
/* this is annoying: tp is a GPS time while we want a difference
in time which should be just REAL8 */
if (XLALUserVarWasSet(&uvar.spacingT))
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, uvar.spacingT);
else
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, sqrt(uvar.mismatchT / diagTT));
if (XLALUserVarWasSet(&uvar.spacingP))
binaryTemplateSpacings.period = uvar.spacingP;
else
binaryTemplateSpacings.period = sqrt(uvar.mismatchP / diagpp);
/* metric elements for eccentric case not considered? */
UINT8 fCount = 0, aCount = 0, tCount = 0 , pCount = 0;
const UINT8 fSpacingNum = floor( uvar.fBand / binaryTemplateSpacings.fkdot[0]);
const UINT8 aSpacingNum = floor( uvar.orbitAsiniSecBand / binaryTemplateSpacings.asini);
const UINT8 tSpacingNum = floor( uvar.orbitTimeAscBand / XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
const UINT8 pSpacingNum = floor( uvar.orbitPSecBand / binaryTemplateSpacings.period);
/*reset minbinaryOrbitParams to shift the first point a factor so as to make the center of all seaching points centers at the center of searching band*/
minBinaryTemplate.fkdot[0] = uvar.fStart + 0.5 * (uvar.fBand - fSpacingNum * binaryTemplateSpacings.fkdot[0]);
minBinaryTemplate.asini = uvar.orbitAsiniSec + 0.5 * (uvar.orbitAsiniSecBand - aSpacingNum * binaryTemplateSpacings.asini);
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * (uvar.orbitTimeAscBand - tSpacingNum * XLALGPSGetREAL8(&binaryTemplateSpacings.tp)));
minBinaryTemplate.period = uvar.orbitPSec + 0.5 * (uvar.orbitPSecBand - pSpacingNum * binaryTemplateSpacings.period);
/* initialize the doppler scan struct which stores the current template information */
XLALGPSSetREAL8(&dopplerpos.refTime, config.refTime);
dopplerpos.Alpha = uvar.alphaRad;
dopplerpos.Delta = uvar.deltaRad;
dopplerpos.fkdot[0] = minBinaryTemplate.fkdot[0];
/* set all spindowns to zero */
for (k=1; k < PULSAR_MAX_SPINS; k++)
dopplerpos.fkdot[k] = 0.0;
dopplerpos.asini = minBinaryTemplate.asini;
dopplerpos.period = minBinaryTemplate.period;
dopplerpos.tp = minBinaryTemplate.tp;
dopplerpos.ecc = minBinaryTemplate.ecc;
dopplerpos.argp = minBinaryTemplate.argp;
/* now set the initial values of binary parameters */
/* thisBinaryTemplate.asini = uvar.orbitAsiniSec;
thisBinaryTemplate.period = uvar.orbitPSec;
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.argp = 0.0;*/
/* copy to dopplerpos */
/* Calculate SSB times (can do this once since search is currently only for one sky position, and binary doppler shift is added later) */
MultiSSBtimes *multiSSBTimes = NULL;
if ((multiSSBTimes = XLALGetMultiSSBtimes ( multiStates, skyPos, dopplerpos.refTime, SSBPREC_RELATIVISTICOPT )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* "New" general metric computation */
/* For now hard-code circular parameter space */
const DopplerCoordinateSystem coordSys = {
.dim = 4,
.coordIDs = { DOPPLERCOORD_FREQ,
DOPPLERCOORD_ASINI,
DOPPLERCOORD_TASC,
DOPPLERCOORD_PORB, },
};
REAL8VectorSequence *phaseDerivs = NULL;
if ( ( XLALCalculateCrossCorrPhaseDerivatives ( &phaseDerivs, &thisBinaryTemplate, config.edat, sftIndices, multiSSBTimes, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseDerivatives() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill in metric and parameter offsets */
gsl_matrix *g_ij = NULL;
gsl_vector *eps_i = NULL;
REAL8 sumGammaSq = 0;
if ( ( XLALCalculateCrossCorrPhaseMetric ( &g_ij, &eps_i, &sumGammaSq, phaseDerivs, sftPairs, GammaAve, GammaCirc, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
XLALDestroyREAL8VectorSequence ( phaseDerivs );
XLALDestroyREAL8Vector ( GammaCirc );
if ((fp = fopen("gsldata.dat","w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in gsl matrix file");
XLAL_ERROR( XLAL_EFUNC );
}
XLALfprintfGSLvector(fp, "%g", eps_i);
XLALfprintfGSLmatrix(fp, "%g", g_ij);
/* Allocate structure for binary doppler-shifting information */
if ((multiBinaryTimes = XLALDuplicateMultiSSBtimes ( multiSSBTimes )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALDuplicateMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
UINT8 numSFTs = sftIndices->length;
if ((shiftedFreqs = XLALCreateREAL8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((lowestBins = XLALCreateUINT4Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateUINT4Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((expSignalPhases = XLALCreateCOMPLEX8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((sincList = XLALCreateREAL8VectorSequence ( numSFTs, uvar.numBins ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8VectorSequence() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* args should be : spacings, min and max doppler params */
BOOLEAN firstPoint = TRUE; /* a boolean to help to search at the beginning point in parameter space, after the search it is set to be FALSE to end the loop*/
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
} /*Need to apply additional doppler shifting before the loop, or the first point in parameter space will be lost and return a wrong SNR when fBand!=0*/
while ( GetNextCrossCorrTemplate(&dopplerShiftFlag, &firstPoint, &dopplerpos, &binaryTemplateSpacings, &minBinaryTemplate, &maxBinaryTemplate, &fCount, &aCount, &tCount, &pCount, fSpacingNum, aSpacingNum, tSpacingNum, pSpacingNum) == 0)
{
/* do useful stuff here*/
/* Apply additional Doppler shifting using current binary orbital parameters */
/* Might want to be clever about checking whether we've changed the orbital parameters or only the frequency */
if (dopplerShiftFlag == TRUE)
{
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if ( (XLALGetDopplerShiftedFrequencyInfo( shiftedFreqs, lowestBins, expSignalPhases, sincList, uvar.numBins, &dopplerpos, sftIndices, inputSFTs, multiBinaryTimes, Tsft ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALGetDopplerShiftedFrequencyInfo() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ( (XLALCalculatePulsarCrossCorrStatistic( &ccStat, &evSquared, GammaAve, expSignalPhases, lowestBins, sincList, sftPairs, sftIndices, inputSFTs, multiWeights, uvar.numBins) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculatePulsarCrossCorrStatistic() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill candidate struct and insert into toplist if necessary */
thisCandidate.freq = dopplerpos.fkdot[0];
thisCandidate.tp = XLALGPSGetREAL8( &dopplerpos.tp );
thisCandidate.argp = dopplerpos.argp;
thisCandidate.asini = dopplerpos.asini;
thisCandidate.ecc = dopplerpos.ecc;
thisCandidate.period = dopplerpos.period;
thisCandidate.rho = ccStat;
thisCandidate.evSquared = evSquared;
thisCandidate.estSens = estSens;
insert_into_crossCorrBinary_toplist(ccToplist, thisCandidate);
} /* end while loop over templates */
/* write candidates to file */
sort_crossCorrBinary_toplist( ccToplist );
/* add error checking */
final_write_crossCorrBinary_toplist_to_file( ccToplist, uvar.toplistFilename, &checksum);
REAL8 h0Sens = sqrt((10 / sqrt(estSens))); /*for a SNR=10 signal, the h0 we can detect*/
XLALGPSTimeNow (&computingEndGPSTime); /*record the rough end time*/
UINT4 computingTime = computingEndGPSTime.gpsSeconds - computingStartGPSTime.gpsSeconds;
/* make a meta-data file*/
if(XLALUserVarWasSet(&uvar.logFilename)){
CHAR *CMDInputStr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE );
if ((fp = fopen(uvar.logFilename,"w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in logfile");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp, "[UserInput]\n\n");
fprintf(fp, "%s\n", CMDInputStr);
fprintf(fp, "[CalculatedValues]\n\n");
fprintf(fp, "g_ff = %.9f\n", diagff );
fprintf(fp, "g_aa = %.9f\n", diagaa );
fprintf(fp, "g_TT = %.9f\n", diagTT );
fprintf(fp, "FSpacing = %.9g\n", binaryTemplateSpacings.fkdot[0]);
fprintf(fp, "ASpacing = %.9g\n", binaryTemplateSpacings.asini);
fprintf(fp, "TSpacing = %.9g\n", XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
/* fprintf(fp, "PSpacing = %.9g\n", binaryTemplateSpacings.period );*/
fprintf(fp, "TemplatenumF = %" LAL_UINT8_FORMAT "\n", (fSpacingNum + 1));
fprintf(fp, "TemplatenumA = %" LAL_UINT8_FORMAT "\n", (aSpacingNum + 1));
fprintf(fp, "TemplatenumT = %" LAL_UINT8_FORMAT "\n", (tSpacingNum + 1));
fprintf(fp, "TemplatenumP = %" LAL_UINT8_FORMAT "\n", (pSpacingNum + 1));
fprintf(fp, "TemplatenumTotal = %" LAL_UINT8_FORMAT "\n",(fSpacingNum + 1) * (aSpacingNum + 1) * (tSpacingNum + 1) * (pSpacingNum + 1));
fprintf(fp, "Sens = %.9g\n", estSens);/*(E[rho]/h0^2)^2*/
fprintf(fp, "h0_min_SNR10 = %.9g\n", h0Sens);/*for rho = 10 in our pipeline*/
fprintf(fp, "startTime = %" LAL_INT4_FORMAT "\n", computingStartGPSTime.gpsSeconds );/*start time in GPS-time*/
fprintf(fp, "endTime = %" LAL_INT4_FORMAT "\n", computingEndGPSTime.gpsSeconds );/*end time in GPS-time*/
fprintf(fp, "computingTime = %" LAL_UINT4_FORMAT "\n", computingTime );/*total time in sec*/
fprintf(fp, "SFTnum = %" LAL_UINT4_FORMAT "\n", sftIndices->length);/*total number of SFT*/
fprintf(fp, "pairnum = %" LAL_UINT4_FORMAT "\n", sftPairs->length);/*total number of pair of SFT*/
fprintf(fp, "Tsft = %.6g\n", Tsft);/*SFT duration*/
fprintf(fp, "\n[Version]\n\n");
fprintf(fp, "%s", VCSInfoString);
fclose(fp);
XLALFree(CMDInputStr);
}
XLALFree(VCSInfoString);
XLALDestroyCOMPLEX8Vector ( expSignalPhases );
XLALDestroyUINT4Vector ( lowestBins );
XLALDestroyREAL8Vector ( shiftedFreqs );
XLALDestroyREAL8VectorSequence ( sincList );
XLALDestroyMultiSSBtimes ( multiBinaryTimes );
XLALDestroyMultiSSBtimes ( multiSSBTimes );
XLALDestroyREAL8Vector ( GammaAve );
XLALDestroySFTPairIndexList( sftPairs );
XLALDestroySFTIndexList( sftIndices );
XLALDestroyMultiAMCoeffs ( multiCoeffs );
XLALDestroyMultiDetectorStateSeries ( multiStates );
XLALDestroyMultiTimestamps ( multiTimes );
XLALDestroyMultiNoiseWeights ( multiWeights );
XLALDestroyMultiPSDVector ( multiPSDs );
XLALDestroyMultiSFTVector ( inputSFTs );
/* de-allocate memory for configuration variables */
XLALDestroyConfigVars ( &config );
/* de-allocate memory for user input variables */
XLALDestroyUserVars();
/* free toplist memory */
free_crossCorr_toplist(&ccToplist);
/* check memory leaks if we forgot to de-allocate anything */
LALCheckMemoryLeaks();
LogPrintf (LOG_CRITICAL, "End time\n");/*for debug convenience to record calculating time*/
return 0;
} /* main */
/* initialize and register user variables */
int XLALInitUserVars (UserInput_t *uvar)
{
/* initialize with some defaults */
uvar->help = FALSE;
uvar->maxLag = 0.0;
uvar->inclAutoCorr = FALSE;
uvar->fStart = 100.0;
uvar->fBand = 0.1;
/* uvar->fdotStart = 0.0; */
/* uvar->fdotBand = 0.0; */
uvar->alphaRad = 0.0;
uvar->deltaRad = 0.0;
uvar->refTime = 0.0;
uvar->rngMedBlock = 50;
uvar->numBins = 1;
/* zero binary orbital parameters means not a binary */
uvar->orbitAsiniSec = 0.0;
uvar->orbitAsiniSecBand = 0.0;
uvar->orbitPSec = 0.0;
uvar->orbitPSecBand = 0.0;
uvar->orbitTimeAsc = 0;
uvar->orbitTimeAscBand = 0;
/*default mismatch values */
/* set to 0.1 by default -- for no real reason */
/* make 0.1 a macro? */
uvar->mismatchF = 0.1;
uvar->mismatchA = 0.1;
uvar->mismatchT = 0.1;
uvar->mismatchP = 0.1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->sftLocation = XLALCalloc(1, MAXFILENAMELENGTH+1);
/* initialize number of candidates in toplist -- default is just to return the single best candidate */
uvar->numCand = 1;
uvar->toplistFilename = XLALStringDuplicate("toplist_crosscorr.dat");
uvar->version = FALSE;
/* register user-variables */
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP, "Print this message");
XLALregINTUserStruct ( startTime, 0, UVAR_REQUIRED, "Desired start time of analysis in GPS seconds");
XLALregINTUserStruct ( endTime, 0, UVAR_REQUIRED, "Desired end time of analysis in GPS seconds");
XLALregREALUserStruct ( maxLag, 0, UVAR_OPTIONAL, "Maximum lag time in seconds between SFTs in correlation");
XLALregBOOLUserStruct ( inclAutoCorr, 0, UVAR_OPTIONAL, "Include auto-correlation terms (an SFT with itself)");
XLALregREALUserStruct ( fStart, 0, UVAR_OPTIONAL, "Start frequency in Hz");
XLALregREALUserStruct ( fBand, 0, UVAR_OPTIONAL, "Frequency band to search over in Hz ");
/* XLALregREALUserStruct ( fdotStart, 0, UVAR_OPTIONAL, "Start value of spindown in Hz/s"); */
/* XLALregREALUserStruct ( fdotBand, 0, UVAR_OPTIONAL, "Band for spindown values in Hz/s"); */
XLALregREALUserStruct ( alphaRad, 0, UVAR_OPTIONAL, "Right ascension for directed search (radians)");
XLALregREALUserStruct ( deltaRad, 0, UVAR_OPTIONAL, "Declination for directed search (radians)");
XLALregREALUserStruct ( refTime, 0, UVAR_OPTIONAL, "SSB reference time for pulsar-parameters [Default: midPoint]");
XLALregREALUserStruct ( orbitAsiniSec, 0, UVAR_OPTIONAL, "Start of search band for projected semimajor axis (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitAsiniSecBand, 0, UVAR_OPTIONAL, "Width of search band for projected semimajor axis (seconds)");
XLALregREALUserStruct ( orbitPSec, 0, UVAR_OPTIONAL, "Binary orbital period (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitPSecBand, 0, UVAR_OPTIONAL, "Band for binary orbital period (seconds) ");
XLALregREALUserStruct ( orbitTimeAsc, 0, UVAR_OPTIONAL, "Start of orbital time-of-ascension band in GPS seconds");
XLALregREALUserStruct ( orbitTimeAscBand, 0, UVAR_OPTIONAL, "Width of orbital time-of-ascension band (seconds)");
XLALregSTRINGUserStruct( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregSTRINGUserStruct( sftLocation, 0, UVAR_REQUIRED, "Filename pattern for locating SFT data");
XLALregINTUserStruct ( rngMedBlock, 0, UVAR_OPTIONAL, "Running median block size for PSD estimation");
XLALregINTUserStruct ( numBins, 0, UVAR_OPTIONAL, "Number of frequency bins to include in calculation");
XLALregREALUserStruct ( mismatchF, 0, UVAR_OPTIONAL, "Desired mismatch for frequency spacing");
XLALregREALUserStruct ( mismatchA, 0, UVAR_OPTIONAL, "Desired mismatch for asini spacing");
XLALregREALUserStruct ( mismatchT, 0, UVAR_OPTIONAL, "Desired mismatch for periapse passage time spacing");
XLALregREALUserStruct ( mismatchP, 0, UVAR_OPTIONAL, "Desired mismatch for period spacing");
XLALregREALUserStruct ( spacingF, 0, UVAR_OPTIONAL, "Desired frequency spacing");
XLALregREALUserStruct ( spacingA, 0, UVAR_OPTIONAL, "Desired asini spacing");
XLALregREALUserStruct ( spacingT, 0, UVAR_OPTIONAL, "Desired periapse passage time spacing");
XLALregREALUserStruct ( spacingP, 0, UVAR_OPTIONAL, "Desired period spacing");
XLALregINTUserStruct ( numCand, 0, UVAR_OPTIONAL, "Number of candidates to keep in toplist");
XLALregSTRINGUserStruct( pairListInputFilename, 0, UVAR_OPTIONAL, "Name of file from which to read list of SFT pairs");
XLALregSTRINGUserStruct( pairListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFT pairs");
XLALregSTRINGUserStruct( sftListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( sftListInputFilename, 0, UVAR_OPTIONAL, "Name of file to which to read in list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( gammaAveOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write aa+bb weights (for e.g., false alarm estimation)");
XLALregSTRINGUserStruct( gammaCircOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write ab-ba weights (for e.g., systematic error)");
XLALregSTRINGUserStruct( toplistFilename, 0, UVAR_OPTIONAL, "Output filename containing candidates in toplist");
XLALregSTRINGUserStruct( logFilename, 0, UVAR_OPTIONAL, "Output a meta-data file for the search");
XLALregBOOLUserStruct ( version, 'V', UVAR_SPECIAL, "Output version(VCS) information");
if ( xlalErrno ) {
XLALPrintError ("%s: user variable initialization failed with errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
}
/*----------------------------------------------------------------------
* 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 */
/* ----- function definitions ---------- */
int
main ( int argc, char *argv[] )
{
LALStatus status;
UserInput_t uvar_s;
UserInput_t *uvar = &uvar_s;
INIT_MEM ( status );
INIT_MEM ( uvar_s );
struct tms buf;
uvar->randSeed = times(&buf);
// ---------- register all our user-variable ----------
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP , "Print this help/usage message");
XLALregINTUserStruct ( randSeed, 's', UVAR_OPTIONAL, "Specify random-number seed for reproducible noise.");
/* read cmdline & cfgfile */
XLAL_CHECK ( XLALUserVarReadAllInput ( argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( uvar->help ) { /* if help was requested, we're done */
exit (0);
}
srand ( uvar->randSeed );
REAL8 startTimeREAL8 = 714180733;
REAL8 duration = 180000; /* 50 hours */
REAL8 Tsft = 1800; /* assume 30min SFTs */
char earthEphem[] = TEST_DATA_DIR "earth00-19-DE200.dat.gz";
char sunEphem[] = TEST_DATA_DIR "sun00-19-DE200.dat.gz";
//REAL8 tolerance = 2e-10; /* same algorithm, should be basically identical results */
LIGOTimeGPS startTime, refTime;
XLALGPSSetREAL8 ( &startTime, startTimeREAL8 );
refTime = startTime;
// pick skyposition at random ----- */
SkyPosition skypos;
skypos.longitude = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // alpha uniform in [0, 2pi)
skypos.latitude = LAL_PI_2 - acos ( 1 - 2.0 * rand()/RAND_MAX ); // sin(delta) uniform in [-1,1]
skypos.system = COORDINATESYSTEM_EQUATORIAL;
// pick binary orbital parameters:
// somewhat inspired by Sco-X1 parameters from S2-paper (PRD76, 082001 (2007), gr-qc/0605028)
// but with a more extreme eccentricity, and random argp
REAL8 argp = LAL_TWOPI * (1.0 * rand() / ( RAND_MAX + 1.0 ) ); // uniform in [0, 2pi)
BinaryOrbitParams orbit;
XLALGPSSetREAL8 ( &orbit.tp, 731163327 ); // time of observed periapsis passage (in SSB)
orbit.argp = argp; // argument of periapsis (radians)
orbit.asini = 1.44; // projected, normalized orbital semi-major axis (s) */
orbit.ecc = 1e-2; // relatively large value, for better testing
orbit.period = 68023; // period (s) : about ~18.9h
// ----- step 0: prepare test-case input for calling the BinarySSB-functions
// setup detectors
const char *sites[3] = { "H1", "L1", "V1" };
UINT4 numDetectors = sizeof( sites ) / sizeof ( sites[0] );
MultiLALDetector multiIFO;
multiIFO.length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
LALDetector *det = XLALGetSiteInfo ( sites[X] );
XLAL_CHECK ( det != NULL, XLAL_EFUNC, "XLALGetSiteInfo ('%s') failed for detector X=%d\n", sites[X], X );
multiIFO.sites[X] = (*det); // struct copy
XLALFree ( det );
}
// load ephemeris
EphemerisData *edat = XLALInitBarycenter ( earthEphem, sunEphem );
XLAL_CHECK ( edat != NULL, XLAL_EFUNC, "XLALInitBarycenter('%s','%s') failed\n", earthEphem, sunEphem );
// setup multi-timeseries
MultiLIGOTimeGPSVector *multiTS;
XLAL_CHECK ( (multiTS = XLALCalloc ( 1, sizeof(*multiTS))) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( (multiTS->data = XLALCalloc (numDetectors, sizeof(*multiTS->data))) != NULL, XLAL_ENOMEM );
multiTS->length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
multiTS->data[X] = XLALMakeTimestamps ( startTime, duration, Tsft, 0 );
XLAL_CHECK ( multiTS->data[X] != NULL, XLAL_EFUNC, "XLALMakeTimestamps() failed.\n");
} /* for X < numIFOs */
// generate detector-states
MultiDetectorStateSeries *multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiIFO, edat, 0 );
XLAL_CHECK ( multiDetStates != NULL, XLAL_EFUNC, "XLALGetMultiDetectorStates() failed.\n");
// generate isolated-NS SSB times
MultiSSBtimes *multiSSBIn = XLALGetMultiSSBtimes ( multiDetStates, skypos, refTime, SSBPREC_RELATIVISTICOPT );
XLAL_CHECK ( multiSSBIn != NULL, XLAL_EFUNC, "XLALGetMultiSSBtimes() failed.\n");
// ----- step 1: compute reference-result using old LALGetMultiBinarytimes()
MultiSSBtimes *multiBinary_ref = NULL;
LALGetMultiBinarytimes (&status, &(multiBinary_ref), multiSSBIn, multiDetStates, &orbit, refTime );
XLAL_CHECK ( status.statusCode == 0, XLAL_EFAILED, "LALGetMultiBinarytimes() failed with status = %d : '%s'\n", status.statusCode, status.statusDescription );
// ----- step 2: compute test-result using new XLALAddMultiBinaryTimes()
MultiSSBtimes *multiBinary_test = NULL;
PulsarDopplerParams doppler;
memset(&doppler, 0, sizeof(doppler));
doppler.tp = orbit.tp;
doppler.argp = orbit.argp;
doppler.asini = orbit.asini;
doppler.ecc = orbit.ecc;
doppler.period = orbit.period;
XLAL_CHECK ( XLALAddMultiBinaryTimes ( &multiBinary_test, multiSSBIn, &doppler ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- step 3: compare results
REAL8 err_DeltaT, err_Tdot;
REAL8 tolerance = 1e-10;
int ret = XLALCompareMultiSSBtimes ( &err_DeltaT, &err_Tdot, multiBinary_ref, multiBinary_test );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALCompareMultiSSBtimes() failed.\n");
XLALPrintWarning ( "INFO: err(DeltaT) = %g, err(Tdot) = %g\n", err_DeltaT, err_Tdot );
XLAL_CHECK ( err_DeltaT < tolerance, XLAL_ETOL, "error(DeltaT) = %g exceeds tolerance of %g\n", err_DeltaT, tolerance );
XLAL_CHECK ( err_Tdot < tolerance, XLAL_ETOL, "error(Tdot) = %g exceeds tolerance of %g\n", err_Tdot, tolerance );
// ---- step 4: clean-up memory
XLALDestroyUserVars();
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiSSBtimes ( multiBinary_test );
XLALDestroyMultiSSBtimes ( multiBinary_ref );
XLALDestroyMultiSSBtimes ( multiSSBIn );
XLALDestroyMultiTimestamps ( multiTS );
XLALDestroyMultiDetectorStateSeries ( multiDetStates );
// check for memory-leaks
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
int main( int argc, char *argv[]){
static LALStatus status;
static LALDetector detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
static 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;
}
