/**
* Simply outputs version information to fp.
*
* Returns != XLAL_SUCCESS on error (version-mismatch or writing to fp)
*/
int
XLALOutputVersionString ( FILE *fp, int level )
{
char *VCSInfoString;
if (!fp ) {
XLALPrintError ("%s: invalid NULL input 'fp'\n", __func__ );
XLAL_ERROR ( XLAL_EINVAL );
}
if ( (VCSInfoString = XLALGetVersionString(level)) == NULL ) {
XLALPrintError("%s: XLALGetVersionString() failed.\n", __func__);
XLAL_ERROR ( XLAL_EFUNC );
}
if ( fprintf (fp, "%s", VCSInfoString ) < 0 ) {
XLALPrintError("%s: fprintf failed for given file-pointer 'fp'\n", __func__);
XLALFree ( VCSInfoString);
XLAL_ERROR ( XLAL_EIO );
}
XLALFree ( VCSInfoString);
return XLAL_SUCCESS;
} /* XLALOutputVersionString() */
int main(int argc, char *argv[]){
UserInput_t XLAL_INIT_DECL(uvar);
static ConfigVariables config;
/* sft related variables */
MultiSFTVector *inputSFTs = NULL;
MultiPSDVector *multiPSDs = NULL;
MultiNoiseWeights *multiWeights = NULL;
MultiLIGOTimeGPSVector *multiTimes = NULL;
MultiLALDetector multiDetectors;
MultiDetectorStateSeries *multiStates = NULL;
MultiAMCoeffs *multiCoeffs = NULL;
SFTIndexList *sftIndices = NULL;
SFTPairIndexList *sftPairs = NULL;
REAL8Vector *shiftedFreqs = NULL;
UINT4Vector *lowestBins = NULL;
COMPLEX8Vector *expSignalPhases = NULL;
REAL8VectorSequence *sincList = NULL;
PulsarDopplerParams XLAL_INIT_DECL(dopplerpos);
PulsarDopplerParams thisBinaryTemplate, binaryTemplateSpacings;
PulsarDopplerParams minBinaryTemplate, maxBinaryTemplate;
SkyPosition XLAL_INIT_DECL(skyPos);
MultiSSBtimes *multiBinaryTimes = NULL;
INT4 k;
UINT4 j;
REAL8 fMin, fMax; /* min and max frequencies read from SFTs */
REAL8 deltaF; /* frequency resolution associated with time baseline of SFTs */
REAL8 diagff = 0; /*diagonal metric components*/
REAL8 diagaa = 0;
REAL8 diagTT = 0;
REAL8 diagpp = 1;
REAL8 ccStat = 0;
REAL8 evSquared=0;
REAL8 estSens=0; /*estimated sensitivity(4.13)*/
BOOLEAN dopplerShiftFlag = TRUE;
toplist_t *ccToplist=NULL;
CrossCorrBinaryOutputEntry thisCandidate;
UINT4 checksum;
LogPrintf (LOG_CRITICAL, "Starting time\n"); /*for debug convenience to record calculating time*/
/* initialize and register user variables */
LIGOTimeGPS computingStartGPSTime, computingEndGPSTime;
XLALGPSTimeNow (&computingStartGPSTime); /* record the rough starting GPS time*/
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read user input from the command line or config file */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if (uvar.help) /* if help was requested, then exit */
return 0;
CHAR *VCSInfoString = XLALGetVersionString(0); /**<LAL + LALapps Vsersion string*/
/*If the version information was requested, output it and exit*/
if ( uvar.version ){
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
printf ("%s\n", VCSInfoString );
exit (0);
}
/* configure useful variables based on user input */
if ( XLALInitializeConfigVars ( &config, &uvar) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
deltaF = config.catalog->data[0].header.deltaF;
REAL8 Tsft = 1.0 / deltaF;
if (XLALUserVarWasSet(&uvar.spacingF) && XLALUserVarWasSet(&uvar.mismatchF))
LogPrintf (LOG_CRITICAL, "spacingF and mismatchF are both set, use spacingF %.9g by default\n\n", uvar.spacingF);
if (XLALUserVarWasSet(&uvar.spacingA) && XLALUserVarWasSet(&uvar.mismatchA))
LogPrintf (LOG_CRITICAL, "spacingA and mismatchA are both set, use spacingA %.9g by default\n\n", uvar.spacingA);
if (XLALUserVarWasSet(&uvar.spacingT) && XLALUserVarWasSet(&uvar.mismatchT))
LogPrintf (LOG_CRITICAL, "spacingT and mismatchT are both set, use spacingT %.9g by default\n\n", uvar.spacingT);
if (XLALUserVarWasSet(&uvar.spacingP) && XLALUserVarWasSet(&uvar.mismatchP))
LogPrintf (LOG_CRITICAL, "spacingP and mismatchP are both set, use spacingP %.9g by default\n\n", uvar.spacingP);
/* create the toplist */
create_crossCorrBinary_toplist( &ccToplist, uvar.numCand);
/* now read the data */
/* /\* get SFT parameters so that we can initialise search frequency resolutions *\/ */
/* /\* calculate deltaF_SFT *\/ */
/* deltaF_SFT = catalog->data[0].header.deltaF; /\* frequency resolution *\/ */
/* timeBase= 1.0/deltaF_SFT; /\* sft baseline *\/ */
/* /\* catalog is ordered in time so we can get start, end time and tObs *\/ */
/* firstTimeStamp = catalog->data[0].header.epoch; */
/* lastTimeStamp = catalog->data[catalog->length - 1].header.epoch; */
/* tObs = XLALGPSDiff( &lastTimeStamp, &firstTimeStamp ) + timeBase; */
/* /\*set pulsar reference time *\/ */
/* if (LALUserVarWasSet ( &uvar_refTime )) { */
/* XLALGPSSetREAL8(&refTime, uvar_refTime); */
/* } */
/* else { /\*if refTime is not set, set it to midpoint of sfts*\/ */
/* XLALGPSSetREAL8(&refTime, (0.5*tObs) + XLALGPSGetREAL8(&firstTimeStamp)); */
/* } */
/* /\* set frequency resolution defaults if not set by user *\/ */
/* if (!(LALUserVarWasSet (&uvar_fResolution))) { */
/* uvar_fResolution = 1/tObs; */
/* } */
/* { */
/* /\* block for calculating frequency range to read from SFTs *\/ */
/* /\* user specifies freq and fdot range at reftime */
/* we translate this range of fdots to start and endtime and find */
/* the largest frequency band required to cover the */
/* frequency evolution *\/ */
/* PulsarSpinRange spinRange_startTime; /\**< freq and fdot range at start-time of observation *\/ */
/* PulsarSpinRange spinRange_endTime; /\**< freq and fdot range at end-time of observation *\/ */
/* PulsarSpinRange spinRange_refTime; /\**< freq and fdot range at the reference time *\/ */
/* REAL8 startTime_freqLo, startTime_freqHi, endTime_freqLo, endTime_freqHi, freqLo, freqHi; */
/* REAL8Vector *fdotsMin=NULL; */
/* REAL8Vector *fdotsMax=NULL; */
/* UINT4 k; */
/* fdotsMin = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMin->length = N_SPINDOWN_DERIVS; */
/* fdotsMin->data = (REAL8 *)LALCalloc(fdotsMin->length, sizeof(REAL8)); */
/* fdotsMax = (REAL8Vector *)LALCalloc(1, sizeof(REAL8Vector)); */
/* fdotsMax->length = N_SPINDOWN_DERIVS; */
/* fdotsMax->data = (REAL8 *)LALCalloc(fdotsMax->length, sizeof(REAL8)); */
/* XLAL_INIT_MEM(spinRange_startTime); */
/* XLAL_INIT_MEM(spinRange_endTime); */
/* XLAL_INIT_MEM(spinRange_refTime); */
/* spinRange_refTime.refTime = refTime; */
/* spinRange_refTime.fkdot[0] = uvar_f0; */
/* spinRange_refTime.fkdotBand[0] = uvar_fBand; */
/* } */
/* FIXME: need to correct fMin and fMax for Doppler shift, rngmedian bins and spindown range */
/* this is essentially just a place holder for now */
/* FIXME: this running median buffer is overkill, since the running median block need not be centered on the search frequency */
REAL8 vMax = LAL_TWOPI * (uvar.orbitAsiniSec + uvar.orbitAsiniSecBand) / uvar.orbitPSec + LAL_TWOPI * LAL_REARTH_SI / (LAL_DAYSID_SI * LAL_C_SI) + LAL_TWOPI * LAL_AU_SI/(LAL_YRSID_SI * LAL_C_SI); /*calculate the maximum relative velocity in speed of light*/
fMin = uvar.fStart * (1 - vMax) - 0.5 * uvar.rngMedBlock * deltaF;
fMax = (uvar.fStart + uvar.fBand) * (1 + vMax) + 0.5 * uvar.rngMedBlock * deltaF;
/* read the SFTs*/
if ((inputSFTs = XLALLoadMultiSFTs ( config.catalog, fMin, fMax)) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALLoadMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* calculate the psd and normalize the SFTs */
if (( multiPSDs = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.rngMedBlock, NULL )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALNormalizeMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* compute the noise weights for the AM coefficients */
if (( multiWeights = XLALComputeMultiNoiseWeights ( multiPSDs, uvar.rngMedBlock, 0 )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiNoiseWeights() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the timestamps from the SFTs */
if ((multiTimes = XLALExtractMultiTimestampsFromSFTs ( inputSFTs )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALExtractMultiTimestampsFromSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* read the detector information from the SFTs */
if ( XLALMultiLALDetectorFromMultiSFTs ( &multiDetectors, inputSFTs ) != XLAL_SUCCESS){
LogPrintf ( LOG_CRITICAL, "%s: XLALMultiLALDetectorFromMultiSFTs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Find the detector state for each SFT */
/* Offset by Tsft/2 to get midpoint as timestamp */
if ((multiStates = XLALGetMultiDetectorStates ( multiTimes, &multiDetectors, config.edat, 0.5 * Tsft )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiDetectorStates() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Note this is specialized to a single sky position */
/* This might need to be moved into the config variables */
skyPos.system = COORDINATESYSTEM_EQUATORIAL;
skyPos.longitude = uvar.alphaRad;
skyPos.latitude = uvar.deltaRad;
/* Calculate the AM coefficients (a,b) for each SFT */
if ((multiCoeffs = XLALComputeMultiAMCoeffs ( multiStates, multiWeights, skyPos )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALComputeMultiAMCoeffs() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the flat list of SFTs (this sort of replicates the
catalog, but there's not an obvious way to get the information
back) */
if ( ( XLALCreateSFTIndexListFromMultiSFTVect( &sftIndices, inputSFTs ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTIndexListFromMultiSFTVect() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* Construct the list of SFT pairs */
#define PCC_SFTPAIR_HEADER "# The length of SFT-pair list is %u #\n"
#define PCC_SFTPAIR_BODY "%u %u\n"
#define PCC_SFT_HEADER "# The length of SFT list is %u #\n"
#define PCC_SFT_BODY "%s %d %d\n"
FILE *fp = NULL;
if (XLALUserVarWasSet(&uvar.pairListInputFilename)) { /* If the user provided a list for reading, use it */
if((sftPairs = XLALCalloc(1, sizeof(sftPairs))) == NULL){
XLAL_ERROR(XLAL_ENOMEM);
}
if((fp = fopen(uvar.pairListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "didn't find SFT-pair list file with given input name\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(fscanf(fp,PCC_SFTPAIR_HEADER,&sftPairs->length)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read the length of SFT-pair list from the header\n");
XLAL_ERROR( XLAL_EFUNC );
}
if((sftPairs->data = XLALCalloc(sftPairs->length, sizeof(*sftPairs->data)))==NULL){
XLALFree(sftPairs);
XLAL_ERROR(XLAL_ENOMEM);
}
for(j = 0; j < sftPairs->length; j++){ /*read in the SFT-pair list */
if(fscanf(fp,PCC_SFTPAIR_BODY, &sftPairs->data[j].sftNum[0], &sftPairs->data[j].sftNum[1])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT-pair list doesn't match!");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
}
else { /* if not, construct the list of pairs */
if ( ( XLALCreateSFTPairIndexList( &sftPairs, sftIndices, inputSFTs, uvar.maxLag, uvar.inclAutoCorr ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateSFTPairIndexList() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if (XLALUserVarWasSet(&uvar.pairListOutputFilename)) { /* Write the list of pairs to a file, if a name was provided */
if((fp = fopen(uvar.pairListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in SFT-pair list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFTPAIR_HEADER, sftPairs->length ); /*output the length of SFT-pair list to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_SFTPAIR_BODY, sftPairs->data[j].sftNum[0], sftPairs->data[j].sftNum[1]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.sftListOutputFilename)) { /* Write the list of SFTs to a file for sanity-checking purposes */
if((fp = fopen(uvar.sftListOutputFilename, "w")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_SFT_HEADER, sftIndices->length ); /*output the length of SFT list to the header*/
for(j = 0; j < sftIndices->length; j++){ /*output the SFT list */
fprintf(fp,PCC_SFT_BODY, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds, inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds);
}
fclose(fp);
}
else if(XLALUserVarWasSet(&uvar.sftListInputFilename)){ /*do a sanity check of the order of SFTs list if the name of input SFT list is given*/
UINT4 numofsft=0;
if((fp = fopen(uvar.sftListInputFilename, "r")) == NULL){
LogPrintf ( LOG_CRITICAL, "Can't read in flat SFT list \n");
XLAL_ERROR( XLAL_EFUNC );
}
if (fscanf(fp, PCC_SFT_HEADER, &numofsft)==EOF){
LogPrintf ( LOG_CRITICAL, "can't read in the length of SFT list from header\n");
XLAL_ERROR( XLAL_EFUNC );
}
CHARVectorSequence *checkDet=NULL;
if ((checkDet = XLALCreateCHARVectorSequence (numofsft, LALNameLength) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateCHARVector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
INT4 checkGPS[numofsft], checkGPSns[numofsft];
if(numofsft == sftIndices->length){
for (j=0; j<numofsft; j++){
if( fscanf(fp,PCC_SFT_BODY,&checkDet->data[j * LALNameLength], &checkGPS[j], &checkGPSns[j])==EOF){
LogPrintf ( LOG_CRITICAL, "The length of SFT list doesn't match\n");
XLAL_ERROR( XLAL_EFUNC );
}
if(strcmp( inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].name, &checkDet->data[j * LALNameLength] ) != 0
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsSeconds != checkGPS[j]
||inputSFTs->data[sftIndices->data[j].detInd]->data[sftIndices->data[j].sftInd].epoch.gpsNanoSeconds != checkGPSns[j] ){
LogPrintf ( LOG_CRITICAL, "The order of SFTs has been changed, it's the end of civilization\n");
XLAL_ERROR( XLAL_EFUNC );
}
}
fclose(fp);
XLALDestroyCHARVectorSequence(checkDet);
}
else{
LogPrintf ( LOG_CRITICAL, "Run for your life, the length of SFT list doesn't match");
XLAL_ERROR( XLAL_EFUNC );
}
}
else
{
}
/* Get weighting factors for calculation of metric */
/* note that the sigma-squared is now absorbed into the curly G
because the AM coefficients are noise-weighted. */
REAL8Vector *GammaAve = NULL;
REAL8Vector *GammaCirc = NULL;
if ( ( XLALCalculateCrossCorrGammas( &GammaAve, &GammaCirc, sftPairs, sftIndices, multiCoeffs) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrGammas() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
#define PCC_GAMMA_HEADER "# The normalization Sinv_Tsft is %g #\n"
#define PCC_GAMMA_BODY "%.10g\n"
if (XLALUserVarWasSet(&uvar.gammaAveOutputFilename)) { /* Write the aa+bb weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaAveOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_ave list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaAve->data[j]);
}
fclose(fp);
}
if (XLALUserVarWasSet(&uvar.gammaCircOutputFilename)) { /* Write the ab-ba weight for each pair to a file, if a name was provided */
if((fp = fopen(uvar.gammaCircOutputFilename, "w")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Can't write in Gamma_circ list \n");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp,PCC_GAMMA_HEADER, multiWeights->Sinv_Tsft); /*output the normalization factor to the header*/
for(j = 0; j < sftPairs->length; j++){
fprintf(fp,PCC_GAMMA_BODY, GammaCirc->data[j]);
}
fclose(fp);
}
/*initialize binary parameters structure*/
XLAL_INIT_MEM(minBinaryTemplate);
XLAL_INIT_MEM(maxBinaryTemplate);
XLAL_INIT_MEM(thisBinaryTemplate);
XLAL_INIT_MEM(binaryTemplateSpacings);
/*fill in minbinaryOrbitParams*/
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc);
minBinaryTemplate.argp = 0.0;
minBinaryTemplate.asini = uvar.orbitAsiniSec;
minBinaryTemplate.ecc = 0.0;
minBinaryTemplate.period = uvar.orbitPSec;
minBinaryTemplate.fkdot[0] = uvar.fStart;
/*fill in maxBinaryParams*/
XLALGPSSetREAL8( &maxBinaryTemplate.tp, uvar.orbitTimeAsc + uvar.orbitTimeAscBand);
maxBinaryTemplate.argp = 0.0;
maxBinaryTemplate.asini = uvar.orbitAsiniSec + uvar.orbitAsiniSecBand;
maxBinaryTemplate.ecc = 0.0;
maxBinaryTemplate.period = uvar.orbitPSec;
maxBinaryTemplate.fkdot[0] = uvar.fStart + uvar.fBand;
/*fill in thisBinaryTemplate*/
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * uvar.orbitTimeAscBand);
thisBinaryTemplate.argp = 0.0;
thisBinaryTemplate.asini = 0.5*(minBinaryTemplate.asini + maxBinaryTemplate.asini);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.period =0.5*(minBinaryTemplate.period + maxBinaryTemplate.period);
thisBinaryTemplate.fkdot[0]=0.5*(minBinaryTemplate.fkdot[0] + maxBinaryTemplate.fkdot[0]);
/*Get metric diagonal components, also estimate sensitivity i.e. E[rho]/(h0)^2 (4.13)*/
if ( (XLALCalculateLMXBCrossCorrDiagMetric(&estSens, &diagff, &diagaa, &diagTT, thisBinaryTemplate, GammaAve, sftPairs, sftIndices, inputSFTs, multiWeights /*, kappaValues*/) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateLMXBCrossCorrDiagMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* spacing in frequency from diagff */ /* set spacings in new dopplerparams struct */
if (XLALUserVarWasSet(&uvar.spacingF)) /* If spacing was given by CMD line, use it, else calculate spacing by mismatch*/
binaryTemplateSpacings.fkdot[0] = uvar.spacingF;
else
binaryTemplateSpacings.fkdot[0] = sqrt(uvar.mismatchF / diagff);
if (XLALUserVarWasSet(&uvar.spacingA))
binaryTemplateSpacings.asini = uvar.spacingA;
else
binaryTemplateSpacings.asini = sqrt(uvar.mismatchA / diagaa);
/* this is annoying: tp is a GPS time while we want a difference
in time which should be just REAL8 */
if (XLALUserVarWasSet(&uvar.spacingT))
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, uvar.spacingT);
else
XLALGPSSetREAL8( &binaryTemplateSpacings.tp, sqrt(uvar.mismatchT / diagTT));
if (XLALUserVarWasSet(&uvar.spacingP))
binaryTemplateSpacings.period = uvar.spacingP;
else
binaryTemplateSpacings.period = sqrt(uvar.mismatchP / diagpp);
/* metric elements for eccentric case not considered? */
UINT8 fCount = 0, aCount = 0, tCount = 0 , pCount = 0;
const UINT8 fSpacingNum = floor( uvar.fBand / binaryTemplateSpacings.fkdot[0]);
const UINT8 aSpacingNum = floor( uvar.orbitAsiniSecBand / binaryTemplateSpacings.asini);
const UINT8 tSpacingNum = floor( uvar.orbitTimeAscBand / XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
const UINT8 pSpacingNum = floor( uvar.orbitPSecBand / binaryTemplateSpacings.period);
/*reset minbinaryOrbitParams to shift the first point a factor so as to make the center of all seaching points centers at the center of searching band*/
minBinaryTemplate.fkdot[0] = uvar.fStart + 0.5 * (uvar.fBand - fSpacingNum * binaryTemplateSpacings.fkdot[0]);
minBinaryTemplate.asini = uvar.orbitAsiniSec + 0.5 * (uvar.orbitAsiniSecBand - aSpacingNum * binaryTemplateSpacings.asini);
XLALGPSSetREAL8( &minBinaryTemplate.tp, uvar.orbitTimeAsc + 0.5 * (uvar.orbitTimeAscBand - tSpacingNum * XLALGPSGetREAL8(&binaryTemplateSpacings.tp)));
minBinaryTemplate.period = uvar.orbitPSec + 0.5 * (uvar.orbitPSecBand - pSpacingNum * binaryTemplateSpacings.period);
/* initialize the doppler scan struct which stores the current template information */
XLALGPSSetREAL8(&dopplerpos.refTime, config.refTime);
dopplerpos.Alpha = uvar.alphaRad;
dopplerpos.Delta = uvar.deltaRad;
dopplerpos.fkdot[0] = minBinaryTemplate.fkdot[0];
/* set all spindowns to zero */
for (k=1; k < PULSAR_MAX_SPINS; k++)
dopplerpos.fkdot[k] = 0.0;
dopplerpos.asini = minBinaryTemplate.asini;
dopplerpos.period = minBinaryTemplate.period;
dopplerpos.tp = minBinaryTemplate.tp;
dopplerpos.ecc = minBinaryTemplate.ecc;
dopplerpos.argp = minBinaryTemplate.argp;
/* now set the initial values of binary parameters */
/* thisBinaryTemplate.asini = uvar.orbitAsiniSec;
thisBinaryTemplate.period = uvar.orbitPSec;
XLALGPSSetREAL8( &thisBinaryTemplate.tp, uvar.orbitTimeAsc);
thisBinaryTemplate.ecc = 0.0;
thisBinaryTemplate.argp = 0.0;*/
/* copy to dopplerpos */
/* Calculate SSB times (can do this once since search is currently only for one sky position, and binary doppler shift is added later) */
MultiSSBtimes *multiSSBTimes = NULL;
if ((multiSSBTimes = XLALGetMultiSSBtimes ( multiStates, skyPos, dopplerpos.refTime, SSBPREC_RELATIVISTICOPT )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALGetMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* "New" general metric computation */
/* For now hard-code circular parameter space */
const DopplerCoordinateSystem coordSys = {
.dim = 4,
.coordIDs = { DOPPLERCOORD_FREQ,
DOPPLERCOORD_ASINI,
DOPPLERCOORD_TASC,
DOPPLERCOORD_PORB, },
};
REAL8VectorSequence *phaseDerivs = NULL;
if ( ( XLALCalculateCrossCorrPhaseDerivatives ( &phaseDerivs, &thisBinaryTemplate, config.edat, sftIndices, multiSSBTimes, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseDerivatives() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill in metric and parameter offsets */
gsl_matrix *g_ij = NULL;
gsl_vector *eps_i = NULL;
REAL8 sumGammaSq = 0;
if ( ( XLALCalculateCrossCorrPhaseMetric ( &g_ij, &eps_i, &sumGammaSq, phaseDerivs, sftPairs, GammaAve, GammaCirc, &coordSys ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculateCrossCorrPhaseMetric() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
XLALDestroyREAL8VectorSequence ( phaseDerivs );
XLALDestroyREAL8Vector ( GammaCirc );
if ((fp = fopen("gsldata.dat","w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in gsl matrix file");
XLAL_ERROR( XLAL_EFUNC );
}
XLALfprintfGSLvector(fp, "%g", eps_i);
XLALfprintfGSLmatrix(fp, "%g", g_ij);
/* Allocate structure for binary doppler-shifting information */
if ((multiBinaryTimes = XLALDuplicateMultiSSBtimes ( multiSSBTimes )) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALDuplicateMultiSSBtimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
UINT8 numSFTs = sftIndices->length;
if ((shiftedFreqs = XLALCreateREAL8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((lowestBins = XLALCreateUINT4Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateUINT4Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((expSignalPhases = XLALCreateCOMPLEX8Vector ( numSFTs ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8Vector() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ((sincList = XLALCreateREAL8VectorSequence ( numSFTs, uvar.numBins ) ) == NULL){
LogPrintf ( LOG_CRITICAL, "%s: XLALCreateREAL8VectorSequence() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* args should be : spacings, min and max doppler params */
BOOLEAN firstPoint = TRUE; /* a boolean to help to search at the beginning point in parameter space, after the search it is set to be FALSE to end the loop*/
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
} /*Need to apply additional doppler shifting before the loop, or the first point in parameter space will be lost and return a wrong SNR when fBand!=0*/
while ( GetNextCrossCorrTemplate(&dopplerShiftFlag, &firstPoint, &dopplerpos, &binaryTemplateSpacings, &minBinaryTemplate, &maxBinaryTemplate, &fCount, &aCount, &tCount, &pCount, fSpacingNum, aSpacingNum, tSpacingNum, pSpacingNum) == 0)
{
/* do useful stuff here*/
/* Apply additional Doppler shifting using current binary orbital parameters */
/* Might want to be clever about checking whether we've changed the orbital parameters or only the frequency */
if (dopplerShiftFlag == TRUE)
{
if ( (XLALAddMultiBinaryTimes( &multiBinaryTimes, multiSSBTimes, &dopplerpos ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALAddMultiBinaryTimes() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
}
if ( (XLALGetDopplerShiftedFrequencyInfo( shiftedFreqs, lowestBins, expSignalPhases, sincList, uvar.numBins, &dopplerpos, sftIndices, inputSFTs, multiBinaryTimes, Tsft ) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALGetDopplerShiftedFrequencyInfo() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
if ( (XLALCalculatePulsarCrossCorrStatistic( &ccStat, &evSquared, GammaAve, expSignalPhases, lowestBins, sincList, sftPairs, sftIndices, inputSFTs, multiWeights, uvar.numBins) != XLAL_SUCCESS ) ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALCalculatePulsarCrossCorrStatistic() failed with errno=%d\n", __func__, xlalErrno );
XLAL_ERROR( XLAL_EFUNC );
}
/* fill candidate struct and insert into toplist if necessary */
thisCandidate.freq = dopplerpos.fkdot[0];
thisCandidate.tp = XLALGPSGetREAL8( &dopplerpos.tp );
thisCandidate.argp = dopplerpos.argp;
thisCandidate.asini = dopplerpos.asini;
thisCandidate.ecc = dopplerpos.ecc;
thisCandidate.period = dopplerpos.period;
thisCandidate.rho = ccStat;
thisCandidate.evSquared = evSquared;
thisCandidate.estSens = estSens;
insert_into_crossCorrBinary_toplist(ccToplist, thisCandidate);
} /* end while loop over templates */
/* write candidates to file */
sort_crossCorrBinary_toplist( ccToplist );
/* add error checking */
final_write_crossCorrBinary_toplist_to_file( ccToplist, uvar.toplistFilename, &checksum);
REAL8 h0Sens = sqrt((10 / sqrt(estSens))); /*for a SNR=10 signal, the h0 we can detect*/
XLALGPSTimeNow (&computingEndGPSTime); /*record the rough end time*/
UINT4 computingTime = computingEndGPSTime.gpsSeconds - computingStartGPSTime.gpsSeconds;
/* make a meta-data file*/
if(XLALUserVarWasSet(&uvar.logFilename)){
CHAR *CMDInputStr = XLALUserVarGetLog ( UVAR_LOGFMT_CFGFILE );
if ((fp = fopen(uvar.logFilename,"w"))==NULL){
LogPrintf ( LOG_CRITICAL, "Can't write in logfile");
XLAL_ERROR( XLAL_EFUNC );
}
fprintf(fp, "[UserInput]\n\n");
fprintf(fp, "%s\n", CMDInputStr);
fprintf(fp, "[CalculatedValues]\n\n");
fprintf(fp, "g_ff = %.9f\n", diagff );
fprintf(fp, "g_aa = %.9f\n", diagaa );
fprintf(fp, "g_TT = %.9f\n", diagTT );
fprintf(fp, "FSpacing = %.9g\n", binaryTemplateSpacings.fkdot[0]);
fprintf(fp, "ASpacing = %.9g\n", binaryTemplateSpacings.asini);
fprintf(fp, "TSpacing = %.9g\n", XLALGPSGetREAL8(&binaryTemplateSpacings.tp));
/* fprintf(fp, "PSpacing = %.9g\n", binaryTemplateSpacings.period );*/
fprintf(fp, "TemplatenumF = %" LAL_UINT8_FORMAT "\n", (fSpacingNum + 1));
fprintf(fp, "TemplatenumA = %" LAL_UINT8_FORMAT "\n", (aSpacingNum + 1));
fprintf(fp, "TemplatenumT = %" LAL_UINT8_FORMAT "\n", (tSpacingNum + 1));
fprintf(fp, "TemplatenumP = %" LAL_UINT8_FORMAT "\n", (pSpacingNum + 1));
fprintf(fp, "TemplatenumTotal = %" LAL_UINT8_FORMAT "\n",(fSpacingNum + 1) * (aSpacingNum + 1) * (tSpacingNum + 1) * (pSpacingNum + 1));
fprintf(fp, "Sens = %.9g\n", estSens);/*(E[rho]/h0^2)^2*/
fprintf(fp, "h0_min_SNR10 = %.9g\n", h0Sens);/*for rho = 10 in our pipeline*/
fprintf(fp, "startTime = %" LAL_INT4_FORMAT "\n", computingStartGPSTime.gpsSeconds );/*start time in GPS-time*/
fprintf(fp, "endTime = %" LAL_INT4_FORMAT "\n", computingEndGPSTime.gpsSeconds );/*end time in GPS-time*/
fprintf(fp, "computingTime = %" LAL_UINT4_FORMAT "\n", computingTime );/*total time in sec*/
fprintf(fp, "SFTnum = %" LAL_UINT4_FORMAT "\n", sftIndices->length);/*total number of SFT*/
fprintf(fp, "pairnum = %" LAL_UINT4_FORMAT "\n", sftPairs->length);/*total number of pair of SFT*/
fprintf(fp, "Tsft = %.6g\n", Tsft);/*SFT duration*/
fprintf(fp, "\n[Version]\n\n");
fprintf(fp, "%s", VCSInfoString);
fclose(fp);
XLALFree(CMDInputStr);
}
XLALFree(VCSInfoString);
XLALDestroyCOMPLEX8Vector ( expSignalPhases );
XLALDestroyUINT4Vector ( lowestBins );
XLALDestroyREAL8Vector ( shiftedFreqs );
XLALDestroyREAL8VectorSequence ( sincList );
XLALDestroyMultiSSBtimes ( multiBinaryTimes );
XLALDestroyMultiSSBtimes ( multiSSBTimes );
XLALDestroyREAL8Vector ( GammaAve );
XLALDestroySFTPairIndexList( sftPairs );
XLALDestroySFTIndexList( sftIndices );
XLALDestroyMultiAMCoeffs ( multiCoeffs );
XLALDestroyMultiDetectorStateSeries ( multiStates );
XLALDestroyMultiTimestamps ( multiTimes );
XLALDestroyMultiNoiseWeights ( multiWeights );
XLALDestroyMultiPSDVector ( multiPSDs );
XLALDestroyMultiSFTVector ( inputSFTs );
/* de-allocate memory for configuration variables */
XLALDestroyConfigVars ( &config );
/* de-allocate memory for user input variables */
XLALDestroyUserVars();
/* free toplist memory */
free_crossCorr_toplist(&ccToplist);
/* check memory leaks if we forgot to de-allocate anything */
LALCheckMemoryLeaks();
LogPrintf (LOG_CRITICAL, "End time\n");/*for debug convenience to record calculating time*/
return 0;
} /* main */
/* initialize and register user variables */
int XLALInitUserVars (UserInput_t *uvar)
{
/* initialize with some defaults */
uvar->help = FALSE;
uvar->maxLag = 0.0;
uvar->inclAutoCorr = FALSE;
uvar->fStart = 100.0;
uvar->fBand = 0.1;
/* uvar->fdotStart = 0.0; */
/* uvar->fdotBand = 0.0; */
uvar->alphaRad = 0.0;
uvar->deltaRad = 0.0;
uvar->refTime = 0.0;
uvar->rngMedBlock = 50;
uvar->numBins = 1;
/* zero binary orbital parameters means not a binary */
uvar->orbitAsiniSec = 0.0;
uvar->orbitAsiniSecBand = 0.0;
uvar->orbitPSec = 0.0;
uvar->orbitPSecBand = 0.0;
uvar->orbitTimeAsc = 0;
uvar->orbitTimeAscBand = 0;
/*default mismatch values */
/* set to 0.1 by default -- for no real reason */
/* make 0.1 a macro? */
uvar->mismatchF = 0.1;
uvar->mismatchA = 0.1;
uvar->mismatchT = 0.1;
uvar->mismatchP = 0.1;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->sftLocation = XLALCalloc(1, MAXFILENAMELENGTH+1);
/* initialize number of candidates in toplist -- default is just to return the single best candidate */
uvar->numCand = 1;
uvar->toplistFilename = XLALStringDuplicate("toplist_crosscorr.dat");
uvar->version = FALSE;
/* register user-variables */
XLALregBOOLUserStruct ( help, 'h', UVAR_HELP, "Print this message");
XLALregINTUserStruct ( startTime, 0, UVAR_REQUIRED, "Desired start time of analysis in GPS seconds");
XLALregINTUserStruct ( endTime, 0, UVAR_REQUIRED, "Desired end time of analysis in GPS seconds");
XLALregREALUserStruct ( maxLag, 0, UVAR_OPTIONAL, "Maximum lag time in seconds between SFTs in correlation");
XLALregBOOLUserStruct ( inclAutoCorr, 0, UVAR_OPTIONAL, "Include auto-correlation terms (an SFT with itself)");
XLALregREALUserStruct ( fStart, 0, UVAR_OPTIONAL, "Start frequency in Hz");
XLALregREALUserStruct ( fBand, 0, UVAR_OPTIONAL, "Frequency band to search over in Hz ");
/* XLALregREALUserStruct ( fdotStart, 0, UVAR_OPTIONAL, "Start value of spindown in Hz/s"); */
/* XLALregREALUserStruct ( fdotBand, 0, UVAR_OPTIONAL, "Band for spindown values in Hz/s"); */
XLALregREALUserStruct ( alphaRad, 0, UVAR_OPTIONAL, "Right ascension for directed search (radians)");
XLALregREALUserStruct ( deltaRad, 0, UVAR_OPTIONAL, "Declination for directed search (radians)");
XLALregREALUserStruct ( refTime, 0, UVAR_OPTIONAL, "SSB reference time for pulsar-parameters [Default: midPoint]");
XLALregREALUserStruct ( orbitAsiniSec, 0, UVAR_OPTIONAL, "Start of search band for projected semimajor axis (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitAsiniSecBand, 0, UVAR_OPTIONAL, "Width of search band for projected semimajor axis (seconds)");
XLALregREALUserStruct ( orbitPSec, 0, UVAR_OPTIONAL, "Binary orbital period (seconds) [0 means not a binary]");
XLALregREALUserStruct ( orbitPSecBand, 0, UVAR_OPTIONAL, "Band for binary orbital period (seconds) ");
XLALregREALUserStruct ( orbitTimeAsc, 0, UVAR_OPTIONAL, "Start of orbital time-of-ascension band in GPS seconds");
XLALregREALUserStruct ( orbitTimeAscBand, 0, UVAR_OPTIONAL, "Width of orbital time-of-ascension band (seconds)");
XLALregSTRINGUserStruct( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregSTRINGUserStruct( sftLocation, 0, UVAR_REQUIRED, "Filename pattern for locating SFT data");
XLALregINTUserStruct ( rngMedBlock, 0, UVAR_OPTIONAL, "Running median block size for PSD estimation");
XLALregINTUserStruct ( numBins, 0, UVAR_OPTIONAL, "Number of frequency bins to include in calculation");
XLALregREALUserStruct ( mismatchF, 0, UVAR_OPTIONAL, "Desired mismatch for frequency spacing");
XLALregREALUserStruct ( mismatchA, 0, UVAR_OPTIONAL, "Desired mismatch for asini spacing");
XLALregREALUserStruct ( mismatchT, 0, UVAR_OPTIONAL, "Desired mismatch for periapse passage time spacing");
XLALregREALUserStruct ( mismatchP, 0, UVAR_OPTIONAL, "Desired mismatch for period spacing");
XLALregREALUserStruct ( spacingF, 0, UVAR_OPTIONAL, "Desired frequency spacing");
XLALregREALUserStruct ( spacingA, 0, UVAR_OPTIONAL, "Desired asini spacing");
XLALregREALUserStruct ( spacingT, 0, UVAR_OPTIONAL, "Desired periapse passage time spacing");
XLALregREALUserStruct ( spacingP, 0, UVAR_OPTIONAL, "Desired period spacing");
XLALregINTUserStruct ( numCand, 0, UVAR_OPTIONAL, "Number of candidates to keep in toplist");
XLALregSTRINGUserStruct( pairListInputFilename, 0, UVAR_OPTIONAL, "Name of file from which to read list of SFT pairs");
XLALregSTRINGUserStruct( pairListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFT pairs");
XLALregSTRINGUserStruct( sftListOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( sftListInputFilename, 0, UVAR_OPTIONAL, "Name of file to which to read in list of SFTs (for sanity checks)");
XLALregSTRINGUserStruct( gammaAveOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write aa+bb weights (for e.g., false alarm estimation)");
XLALregSTRINGUserStruct( gammaCircOutputFilename, 0, UVAR_OPTIONAL, "Name of file to which to write ab-ba weights (for e.g., systematic error)");
XLALregSTRINGUserStruct( toplistFilename, 0, UVAR_OPTIONAL, "Output filename containing candidates in toplist");
XLALregSTRINGUserStruct( logFilename, 0, UVAR_OPTIONAL, "Output a meta-data file for the search");
XLALregBOOLUserStruct ( version, 'V', UVAR_SPECIAL, "Output version(VCS) information");
if ( xlalErrno ) {
XLALPrintError ("%s: user variable initialization failed with errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
}
/** Initialize Fstat-code: handle user-input and set everything up. */
int
XLALInitCode ( ConfigVariables *cfg, const UserInput_t *uvar )
{
/* generate log-string for file-output, containing cmdline-options + code VCS version info */
char *vcs;
if ( (vcs = XLALGetVersionString(0)) == NULL ) { /* short VCS version string */
XLALPrintError ( "%s: XLALGetVersionString(0) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
char *cmdline;
if ( (cmdline = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) == NULL ) {
XLALPrintError ( "%s: XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE ) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
const char fmt[] = "%%%% cmdline: %s\n%%%%\n%s%%%%\n";
UINT4 len = strlen(vcs) + strlen(cmdline) + strlen(fmt) + 1;
if ( ( cfg->logString = XLALMalloc ( len )) == NULL ) {
XLALPrintError ("%s: XLALMalloc ( %d ) failed.\n", __func__, len );
XLAL_ERROR ( XLAL_ENOMEM );
}
sprintf ( cfg->logString, fmt, cmdline, vcs );
XLALFree ( cmdline );
XLALFree ( vcs );
/* trivial settings from user-input */
cfg->SignalOnly = uvar->SignalOnly;
/* ----- parse user-input on signal amplitude-paramters + ranges ----- */
/* skypos */
cfg->skypos.longitude = uvar->Alpha; /* Alpha < 0 indicates 'allsky' */
cfg->skypos.latitude = uvar->Delta;
cfg->skypos.system = COORDINATESYSTEM_EQUATORIAL;
/* ----- amplitude-params: create prior pdfs reflecting the user-input */
if ( XLALInitAmplitudePrior ( &cfg->AmpPrior, uvar ) != XLAL_SUCCESS )
XLAL_ERROR ( XLAL_EFUNC );
/* ----- initialize random-number generator ----- */
/* read out environment variables GSL_RNG_xxx
* GSL_RNG_SEED: use to set random seed: default = 0, override by using --randSeed on cmdline
* GSL_RNG_TYPE: type of random-number generator to use: default = 'mt19937'
*/
gsl_rng_env_setup ();
/* allow overriding the random-seed per command-line */
if ( XLALUserVarWasSet ( &uvar->randSeed ) )
gsl_rng_default_seed = uvar->randSeed;
cfg->rng = gsl_rng_alloc (gsl_rng_default);
LogPrintf ( LOG_DEBUG, "random-number generator type: %s\n", gsl_rng_name (cfg->rng));
LogPrintf ( LOG_DEBUG, "seed = %lu\n", gsl_rng_default_seed );
/* init ephemeris-data */
EphemerisData *edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun );
if ( !edat ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", __func__, uvar->ephemEarth, uvar->ephemSun);
XLAL_ERROR ( XLAL_EFUNC );
}
UINT4 numDetectors = uvar->IFOs->length;
MultiLALDetector multiDet;
XLAL_CHECK ( XLALParseMultiLALDetector ( &multiDet, uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC );
/* init timestamps vector covering observation time */
UINT4 numSteps = (UINT4) ceil ( uvar->dataDuration / uvar->TAtom );
MultiLIGOTimeGPSVector * multiTS;
if ( (multiTS = XLALCreateMultiLIGOTimeGPSVector (numDetectors)) == NULL ) {
XLALPrintError ("%s: XLALCreateMultiLIGOTimeGPSVector(%d) failed.\n", __func__, numDetectors );
}
for ( UINT4 X=0; X < numDetectors; X++ ) {
if ( (multiTS->data[X] = XLALCreateTimestampVector (numSteps)) == NULL ) {
XLALPrintError ("%s: XLALCreateTimestampVector(%d) failed.\n", __func__, numSteps );
}
multiTS->data[X]->deltaT = uvar->TAtom;
UINT4 i;
for ( i=0; i < numSteps; i ++ )
{
UINT4 ti = uvar->dataStartGPS + i * uvar->TAtom;
multiTS->data[X]->data[i].gpsSeconds = ti;
multiTS->data[X]->data[i].gpsNanoSeconds = 0;
}
}
/* get detector states */
if ( (cfg->multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiDet, edat, 0.5 * uvar->TAtom )) == NULL ) {
XLALPrintError ( "%s: XLALGetMultiDetectorStates() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar->sqrtSX ) { /* translate user-input PSD sqrt(SX) to noise-weights (this actually does not care whether they were normalized or not) */
/* parse input comma-separated list */
MultiNoiseFloor multiNoiseFloor;
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &multiNoiseFloor, uvar->sqrtSX, numDetectors ) == XLAL_SUCCESS, XLAL_EFUNC );
/* translate to noise weights */
XLAL_CHECK ( ( cfg->multiNoiseWeights = XLALComputeConstantMultiNoiseWeightsFromNoiseFloor ( &multiNoiseFloor, multiTS, uvar->TAtom ) ) != NULL, XLAL_EFUNC );
} /* if ( uvar->sqrtSX ) */
/* get rid of all temporary memory allocated for this step */
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiTimestamps ( multiTS );
multiTS = NULL;
/* ---------- initialize transient window ranges, for injection ... ---------- */
cfg->transientInjectRange.type = TRANSIENT_NONE; /* default: no transient signal window */
/* apply correct defaults if unset: t0=dataStart, t0Band=dataDuration-3*tauMax */
// cfg->transientInjectRange.t0 = uvar->dataStartGPS + uvar->injectWindow_t0Days * DAY24;
cfg->transientSearchRange = cfg->transientInjectRange;
return XLAL_SUCCESS;
} /* XLALInitCode() */
/**
* 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() */
/** Initialize Fstat-code: handle user-input and set everything up. */
int
XLALInitCode ( ConfigVariables *cfg, const UserInput_t *uvar )
{
/* generate log-string for file-output, containing cmdline-options + code VCS version info */
char *vcs;
if ( (vcs = XLALGetVersionString(0)) == NULL ) { /* short VCS version string */
XLALPrintError ( "%s: XLALGetVersionString(0) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
char *cmdline;
if ( (cmdline = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) == NULL ) {
XLALPrintError ( "%s: XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE ) failed with errno=%d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
const char fmt[] = "%%%% cmdline: %s\n%%%%\n%s%%%%\n";
UINT4 len = strlen(vcs) + strlen(cmdline) + strlen(fmt) + 1;
if ( ( cfg->logString = XLALMalloc ( len )) == NULL ) {
XLALPrintError ("%s: XLALMalloc ( %d ) failed.\n", __func__, len );
XLAL_ERROR ( XLAL_ENOMEM );
}
sprintf ( cfg->logString, fmt, cmdline, vcs );
XLALFree ( cmdline );
XLALFree ( vcs );
/* trivial settings from user-input */
cfg->SignalOnly = uvar->SignalOnly;
/* ----- parse user-input on signal amplitude-paramters + ranges ----- */
/* skypos */
cfg->skypos.longitude = uvar->Alpha; /* Alpha < 0 indicates 'allsky' */
cfg->skypos.latitude = uvar->Delta;
cfg->skypos.system = COORDINATESYSTEM_EQUATORIAL;
/* ----- amplitude-params: create prior pdfs reflecting the user-input */
if ( XLALInitAmplitudePrior ( &cfg->AmpPrior, uvar ) != XLAL_SUCCESS )
XLAL_ERROR ( XLAL_EFUNC );
/* ----- initialize random-number generator ----- */
/* read out environment variables GSL_RNG_xxx
* GSL_RNG_SEED: use to set random seed: default = 0, override by using --randSeed on cmdline
* GSL_RNG_TYPE: type of random-number generator to use: default = 'mt19937'
*/
gsl_rng_env_setup ();
/* allow overriding the random-seed per command-line */
if ( XLALUserVarWasSet ( &uvar->randSeed ) )
gsl_rng_default_seed = uvar->randSeed;
cfg->rng = gsl_rng_alloc (gsl_rng_default);
LogPrintf ( LOG_DEBUG, "random-number generator type: %s\n", gsl_rng_name (cfg->rng));
LogPrintf ( LOG_DEBUG, "seed = %lu\n", gsl_rng_default_seed );
/* init ephemeris-data */
EphemerisData *edat = XLALInitBarycenter( uvar->ephemEarth, uvar->ephemSun );
if ( !edat ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitBarycenter failed: could not load Earth ephemeris '%s' and Sun ephemeris '%s'\n", __func__, uvar->ephemEarth, uvar->ephemSun);
XLAL_ERROR ( XLAL_EFUNC );
}
/* init detector info */
LALDetector *site;
if ( (site = XLALGetSiteInfo ( uvar->IFO )) == NULL ) {
XLALPrintError ("%s: Failed to get site-info for detector '%s'\n", __func__, uvar->IFO );
XLAL_ERROR ( XLAL_EFUNC );
}
MultiLALDetector multiDet;
multiDet.length = 1;
multiDet.sites[0] = (*site); /* copy! */
XLALFree ( site );
/* init timestamps vector covering observation time */
UINT4 numSteps = (UINT4) ceil ( uvar->dataDuration / uvar->TAtom );
MultiLIGOTimeGPSVector * multiTS;
if ( (multiTS = XLALCalloc ( 1, sizeof(*multiTS))) == NULL ) {
XLAL_ERROR ( XLAL_ENOMEM );
}
multiTS->length = 1;
if ( (multiTS->data = XLALCalloc (1, sizeof(*multiTS->data))) == NULL ) {
XLAL_ERROR ( XLAL_ENOMEM );
}
if ( (multiTS->data[0] = XLALCreateTimestampVector (numSteps)) == NULL ) {
XLALPrintError ("%s: XLALCreateTimestampVector(%d) failed.\n", __func__, numSteps );
}
multiTS->data[0]->deltaT = uvar->TAtom;
UINT4 i;
for ( i=0; i < numSteps; i ++ )
{
UINT4 ti = uvar->dataStartGPS + i * uvar->TAtom;
multiTS->data[0]->data[i].gpsSeconds = ti;
multiTS->data[0]->data[i].gpsNanoSeconds = 0;
}
/* get detector states */
if ( (cfg->multiDetStates = XLALGetMultiDetectorStates ( multiTS, &multiDet, edat, 0.5 * uvar->TAtom )) == NULL ) {
XLALPrintError ( "%s: XLALGetMultiDetectorStates() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* get rid of all temporary memory allocated for this step */
XLALDestroyEphemerisData ( edat );
XLALDestroyMultiTimestamps ( multiTS );
multiTS = NULL;
/* ---------- initialize transient window ranges, for injection ... ---------- */
transientWindowRange_t XLAL_INIT_DECL(InjectRange);
int twtype;
XLAL_CHECK ( (twtype = XLALParseTransientWindowName ( uvar->injectWindow_type )) >= 0, XLAL_EFUNC );
InjectRange.type = twtype;
/* make sure user doesn't set window=none but sets window-parameters => indicates she didn't mean 'none' */
if ( InjectRange.type == TRANSIENT_NONE ) {
if ( XLALUserVarWasSet ( &uvar->injectWindow_t0Days ) || XLALUserVarWasSet ( &uvar->injectWindow_t0DaysBand ) ||
XLALUserVarWasSet ( &uvar->injectWindow_tauDays ) || XLALUserVarWasSet ( &uvar->injectWindow_tauDaysBand ) ) {
XLALPrintError ("%s: ERROR: injectWindow_type == NONE, but window-parameters were set! Use a different window-type!\n", __func__ );
XLAL_ERROR ( XLAL_EINVAL );
}
}
if ( uvar->injectWindow_t0DaysBand < 0 || uvar->injectWindow_tauDaysBand < 0 ) {
XLALPrintError ("%s: only positive t0/tau window injection bands allowed (%f, %f)\n", __func__, uvar->injectWindow_t0DaysBand, uvar->injectWindow_tauDaysBand );
XLAL_ERROR ( XLAL_EINVAL );
}
/* apply correct defaults if unset: t0=dataStart, t0Band=dataDuration-3*tauMax */
InjectRange.t0 = uvar->dataStartGPS + uvar->injectWindow_t0Days * DAY24;
REAL8 tauMax = ( uvar->injectWindow_tauDays + uvar->injectWindow_tauDaysBand ) * DAY24;
if ( XLALUserVarWasSet (&uvar->injectWindow_t0DaysBand ) )
InjectRange.t0Band = uvar->injectWindow_t0DaysBand * DAY24;
else
InjectRange.t0Band = fmax ( 0.0, uvar->dataDuration - TRANSIENT_EXP_EFOLDING * tauMax - InjectRange.t0 ); /* make sure it's >= 0 */
InjectRange.tau = (UINT4) ( uvar->injectWindow_tauDays * DAY24 );
InjectRange.tauBand = (UINT4) ( uvar->injectWindow_tauDaysBand * DAY24 );
cfg->transientInjectRange = InjectRange;
/* ---------- ... and for search -------------------- */
transientWindowRange_t XLAL_INIT_DECL(SearchRange);
XLAL_CHECK ( (twtype = XLALParseTransientWindowName ( uvar->searchWindow_type )) >= 0, XLAL_EFUNC );
SearchRange.type = twtype;
/* apply correct defaults if unset: use inect window */
if ( !XLALUserVarWasSet ( &uvar->searchWindow_type ) )
SearchRange.type = InjectRange.type;
if ( !XLALUserVarWasSet ( &uvar->searchWindow_t0Days ) )
SearchRange.t0 = InjectRange.t0;
else
SearchRange.t0 = uvar->dataStartGPS + uvar->searchWindow_t0Days * DAY24;
if ( !XLALUserVarWasSet ( &uvar->searchWindow_t0DaysBand ) )
SearchRange.t0Band = InjectRange.t0Band;
else
SearchRange.t0Band = (UINT4) (uvar->searchWindow_t0DaysBand * DAY24);
if ( !XLALUserVarWasSet ( &uvar->searchWindow_tauDays ) )
SearchRange.tau = InjectRange.tau;
else
SearchRange.tau = (UINT4) ( uvar->searchWindow_tauDays * DAY24 );
if ( !XLALUserVarWasSet ( &uvar->searchWindow_tauDaysBand ) )
SearchRange.tauBand = InjectRange.tauBand;
else
SearchRange.tauBand = (UINT4) ( uvar->searchWindow_tauDaysBand * DAY24 );
if ( XLALUserVarWasSet ( &uvar->searchWindow_dt0 ) )
SearchRange.dt0 = uvar->searchWindow_dt0;
else
SearchRange.dt0 = uvar->TAtom;
if ( XLALUserVarWasSet ( &uvar->searchWindow_dtau ) )
SearchRange.dtau = uvar->searchWindow_dtau;
else
SearchRange.dtau = uvar->TAtom;
/* make sure user doesn't set window=none but sets window-parameters => indicates she didn't mean 'none' */
if ( SearchRange.type == TRANSIENT_NONE )
if ( XLALUserVarWasSet ( &uvar->searchWindow_t0Days ) || XLALUserVarWasSet ( &uvar->searchWindow_t0DaysBand ) ||
XLALUserVarWasSet ( &uvar->searchWindow_tauDays ) || XLALUserVarWasSet ( &uvar->searchWindow_tauDaysBand ) ) {
XLALPrintError ("%s: ERROR: searchWindow_type == NONE, but window-parameters were set! Use a different window-type!\n", __func__ );
XLAL_ERROR ( XLAL_EINVAL );
}
if ( uvar->searchWindow_t0DaysBand < 0 || uvar->searchWindow_tauDaysBand < 0 ) {
XLALPrintError ("%s: only positive t0/tau window injection bands allowed (%f, %f)\n", __func__, uvar->searchWindow_t0DaysBand, uvar->searchWindow_tauDaysBand );
XLAL_ERROR ( XLAL_EINVAL );
}
cfg->transientSearchRange = SearchRange;
return XLAL_SUCCESS;
} /* XLALInitCode() */
/**
* 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() */
/** The main function of binary2sft.c
*
*/
int main( int argc, char *argv[] ) {
UserInput_t uvar = empty_UserInput; /* user input variables */
INT4 i,j; /* counter */
SFTVector *SFTvect = NULL;
char *noisestr = XLALCalloc(1,sizeof(char));
/**********************************************************************************/
/* register and read all user-variables */
if (XLALReadUserVars(argc,argv,&uvar)) {
LogPrintf(LOG_CRITICAL,"%s : XLALReadUserVars() failed with error = %d\n",__func__,xlalErrno);
return 1;
}
LogPrintf(LOG_DEBUG,"%s : read in uservars\n",__func__);
/**********************************************************************************/
/* read in the cache file */
FILE *cachefp = NULL;
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
i = 0;
while (fscanf(cachefp,"%*s %*d %*d")!=EOF) i++;
INT4 Nfiles = i;
fclose(cachefp);
LogPrintf(LOG_DEBUG,"%s : counted %d files listed in the cache file.\n",__func__,Nfiles);
/* allocate memory */
char **filenames = LALCalloc(Nfiles,sizeof(char*));
LIGOTimeGPSVector fileStart;
fileStart.data = LALCalloc(Nfiles,sizeof(LIGOTimeGPS));
for (i=0;i<Nfiles;i++) filenames[i] = LALCalloc(512,sizeof(char));
if ((cachefp = fopen(uvar.cachefile,"r")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s : failed to open binary input file %s\n",__func__,uvar.cachefile);
return 1;
}
for (i=0;i<Nfiles;i++) {
fscanf(cachefp,"%s %d %d %*d",filenames[i],&(fileStart.data[i].gpsSeconds),&(fileStart.data[i].gpsNanoSeconds));
}
fclose(cachefp);
/* initialise the random number generator */
gsl_rng * r;
if (XLALInitgslrand(&r,uvar.seed)) {
LogPrintf(LOG_CRITICAL,"%s: XLALinitgslrand() failed with error = %d\n",__func__,xlalErrno);
XLAL_ERROR(XLAL_EFAULT);
}
/* setup the binaryToSFT parameters */
BinaryToSFTparams par;
par.tsft = uvar.tsft;
par.freq = uvar.freq;
par.freqband = uvar.freqband;
par.tsamp = uvar.tsamp;
par.highpassf = uvar.highpassf;
par.amp_inj = uvar.amp_inj;
par.f_inj = uvar.f_inj;
par.asini_inj = uvar.asini_inj;
XLALGPSSetREAL8(&(par.tasc_inj),uvar.tasc_inj);
par.tref = fileStart.data[0];
par.P_inj = uvar.P_inj;
par.phi_inj = uvar.phi_inj;
par.r = r;
/**********************************************************************************/
/* loop over the input files */
long int ntot = 0;
for (j=0;j<Nfiles;j++) {
UINT4 k = 0;
INT8Vector *np = NULL;
REAL8Vector *R = NULL;
par.tstart = fileStart.data[j];
REAL8 norm1 = par.tsamp/par.tsft;
REAL8 norm2 = 1.0/(par.tsamp*par.tsft);
UINT4 oldlen;
if (SFTvect==NULL) oldlen = 0;
else oldlen = SFTvect->length;
LogPrintf(LOG_DEBUG,"%s : working on file %s\n",__func__,filenames[j]);
if (XLALBinaryToSFTVector(&SFTvect,filenames[j],&(fileStart.data[j]),&par,&np,&R)) {
LogPrintf(LOG_CRITICAL,"%s : failed to convert binary input file %s to sfts\n",__func__,filenames[j]);
return 1;
}
if ((np!=NULL) && (R!=NULL)) {
for (k=0;k<np->length;k++) {
ntot += np->data[k];
char temp[64];
sprintf(temp,"%d %e %e\n",SFTvect->data[oldlen+k].epoch.gpsSeconds,(REAL8)np->data[k]*norm1,R->data[k]*norm2);
noisestr = (char *)XLALRealloc(noisestr,sizeof(char)*(1+strlen(noisestr)+strlen(temp)));
strcat(noisestr,temp);
}
XLALDestroyINT8Vector(np);
XLALDestroyREAL8Vector(R);
}
} /* end loop over input files */
/**********************************************************************************/
/* create a noise string */
/**********************************************************************************/
/* generate comment string */
char *VCSInfoString = XLALGetVersionString(0);
XLAL_CHECK ( VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
CHAR *logstr;
size_t len;
XLAL_CHECK ( (logstr = XLALUserVarGetLog ( UVAR_LOGFMT_CMDLINE )) != NULL, XLAL_EFUNC );
char *comment = XLALCalloc ( 1, len = strlen ( logstr ) + strlen(VCSInfoString) + strlen(noisestr) + 512 );
XLAL_CHECK ( comment != NULL, XLAL_ENOMEM, "XLALCalloc(1,%zd) failed.\n", len );
sprintf ( comment, "Generated by:\n%s\n%s\nTotal number of photons = %ld\n%s\n", logstr, VCSInfoString, ntot, noisestr );
/**********************************************************************************/
/* either write whole SFT-vector to single concatenated file */
if ( uvar.outSingleSFT ) {
XLAL_CHECK ( XLALWriteSFTVector2File( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
} else { /* or as individual SFT-files */
XLAL_CHECK ( XLALWriteSFTVector2Dir( SFTvect, uvar.outputdir, comment, uvar.outLabel ) == XLAL_SUCCESS, XLAL_EFUNC );
}
/**********************************************************************************/
/* free memory */
XLALDestroySFTVector(SFTvect);
XLALFree(logstr);
XLALFree(comment);
XLALFree(noisestr);
LALCheckMemoryLeaks();
return 0;
}
int
main(int argc, char *argv[])
{
ConfigVariables XLAL_INIT_DECL(config);
UserVariables_t XLAL_INIT_DECL(uvar);
DopplerMetricParams XLAL_INIT_DECL(metricParams);
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
/* register user-variables */
if ( initUserVars(&uvar) != XLAL_SUCCESS ) {
XLALPrintError( "%s(): initUserVars() failed\n", __func__ );
return EXIT_FAILURE;
}
/* read cmdline & cfgfile */
if ( XLALUserVarReadAllInput(argc,argv) != XLAL_SUCCESS ) {
XLALPrintError( "%s(): XLALUserVarReadAllInput() failed\n", __func__ );
return EXIT_FAILURE;
}
if (uvar.help) /* help requested: we're done */
return 0;
CHAR *VCSInfoString;
if ( (VCSInfoString = XLALGetVersionString(0)) == NULL ) {
XLALPrintError("XLALGetVersionString(0) failed.\n");
exit(1);
}
if ( uvar.version ) {
printf ( "%s\n", VCSInfoString );
return 0;
}
if ( uvar.coordsHelp )
{
CHAR *helpstr;
if ( (helpstr = XLALDopplerCoordinateHelpAll()) == NULL )
{
LogPrintf ( LOG_CRITICAL, "XLALDopplerCoordinateHelpAll() failed!\n\n");
return -1;
}
printf ( "\n%s\n", helpstr );
XLALFree ( helpstr );
return 0;
} /* if coordsHelp */
/* basic setup and initializations */
XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC, "XLALInitCode() failed with xlalErrno = %d\n\n", xlalErrno );
config.history->VCSInfoString = VCSInfoString;
/* parse detector motion string */
int detMotionType = XLALParseDetectorMotionString( uvar.detMotionStr );
XLAL_CHECK ( detMotionType != XLAL_FAILURE, XLAL_EFUNC, "Failed to pass detector motion string '%s'", uvar.detMotionStr );
metricParams.detMotionType = detMotionType;
metricParams.segmentList = config.segmentList;
metricParams.coordSys = config.coordSys;
metricParams.multiIFO = config.multiIFO;
metricParams.multiNoiseFloor = config.multiNoiseFloor;
metricParams.signalParams = config.signalParams;
metricParams.projectCoord = uvar.projection - 1; /* user-input counts from 1, but interally we count 0=1st coord. (-1==no projection) */
metricParams.approxPhase = uvar.approxPhase;
/* ----- compute metric full metric + Fisher matrix ---------- */
DopplerPhaseMetric *Pmetric = NULL;
if ( uvar.metricType == 0 || uvar.metricType == 2 ) {
if ( (Pmetric = XLALComputeDopplerPhaseMetric ( &metricParams, config.edat )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Something failed in XLALComputeDopplerPhaseMetric(). xlalErrno = %d\n\n", xlalErrno);
return -1;
}
}
DopplerFstatMetric *Fmetric = NULL;
if ( uvar.metricType == 1 || uvar.metricType == 2 ) {
if ( (Fmetric = XLALComputeDopplerFstatMetric ( &metricParams, config.edat )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Something failed in XLALComputeDopplerFstatMetric(). xlalErrno = %d\n\n", xlalErrno);
return -1;
}
}
/* ---------- output results ---------- */
if ( uvar.outputMetric )
{
FILE *fpMetric;
if ( (fpMetric = fopen ( uvar.outputMetric, "wb" )) == NULL ) {
LogPrintf (LOG_CRITICAL, "%s: failed to open '%s' for writing. error = '%s'\n",
__func__, uvar.outputMetric, strerror(errno));
return FSTATMETRIC_EFILE;
}
if ( XLALOutputDopplerMetric ( fpMetric, Pmetric, Fmetric, config.history ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: failed to write Doppler metric into output-file '%s'. xlalErrno = %d\n\n",
__func__, uvar.outputMetric, xlalErrno );
return FSTATMETRIC_EFILE;
}
fclose ( fpMetric );
} /* if outputMetric */
/* ----- done: free all memory */
XLALDestroyDopplerPhaseMetric ( Pmetric );
XLALDestroyDopplerFstatMetric ( Fmetric );
if ( XLALDestroyConfig( &config ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLADestroyConfig() failed, xlalErrno = %d.\n\n", __func__, xlalErrno );
return FSTATMETRIC_EXLAL;
}
LALCheckMemoryLeaks();
return 0;
} /* main */
/**
* Handle user-input and set up shop accordingly, and do all
* consistency-checks on user-input.
*/
int
XLALInitMakefakedata ( ConfigVars_t *cfg, UserVariables_t *uvar )
{
XLAL_CHECK ( cfg != NULL, XLAL_EINVAL, "Invalid NULL input 'cfg'\n" );
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL, "Invalid NULL input 'uvar'\n");
cfg->VCSInfoString = XLALGetVersionString(0);
XLAL_CHECK ( cfg->VCSInfoString != NULL, XLAL_EFUNC, "XLALGetVersionString(0) failed.\n" );
// version info was requested: output then exit
if ( uvar->version )
{
printf ("%s\n", cfg->VCSInfoString );
exit (0);
}
/* if requested, log all user-input and code-versions */
if ( uvar->logfile ) {
XLAL_CHECK ( XLALWriteMFDlog ( uvar->logfile, cfg ) == XLAL_SUCCESS, XLAL_EFUNC, "XLALWriteMFDlog() failed with xlalErrno = %d\n", xlalErrno );
}
/* Init ephemerides */
XLAL_CHECK ( (cfg->edat = XLALInitBarycenter ( uvar->ephemEarth, uvar->ephemSun )) != NULL, XLAL_EFUNC );
/* check for negative fMin and Band, which would break the fMin_eff, fBand_eff calculation below */
XLAL_CHECK ( uvar->fmin >= 0, XLAL_EDOM, "Invalid negative frequency fMin=%f!\n\n", uvar->fmin );
XLAL_CHECK ( uvar->Band > 0, XLAL_EDOM, "Invalid non-positive frequency band Band=%f!\n\n", uvar->Band );
// ---------- check user-input consistency ----------
// ----- check if frames + frame channels given
BOOLEAN have_frames = (uvar->inFrames != NULL);
BOOLEAN have_channels= (uvar->inFrChannels != NULL);
XLAL_CHECK ( !(have_frames || have_channels) || (have_frames && have_channels), XLAL_EINVAL, "Need both --inFrames and --inFrChannels, or NONE\n");
// ----- IFOs : only from one of {--IFOs, --noiseSFTs, --inFrChannels}: mutually exclusive
BOOLEAN have_IFOs = (uvar->IFOs != NULL);
BOOLEAN have_noiseSFTs = (uvar->noiseSFTs != NULL);
XLAL_CHECK ( have_frames || have_IFOs || have_noiseSFTs, XLAL_EINVAL, "Need one of --IFOs, --noiseSFTs or --inFrChannels to determine detectors\n");
if ( have_frames ) {
XLAL_CHECK ( !have_IFOs && !have_noiseSFTs, XLAL_EINVAL, "If --inFrames given, cannot handle --IFOs or --noiseSFTs input\n");
XLAL_CHECK ( XLALParseMultiLALDetector ( &(cfg->multiIFO), uvar->inFrChannels ) == XLAL_SUCCESS, XLAL_EFUNC );
} else { // !have_frames
XLAL_CHECK ( !(have_IFOs && have_noiseSFTs), XLAL_EINVAL, "Cannot handle both --IFOs and --noiseSFTs input\n");
}
if ( have_IFOs ) {
XLAL_CHECK ( XLALParseMultiLALDetector ( &(cfg->multiIFO), uvar->IFOs ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// ----- TIMESTAMPS: either from --timestampsFiles, --startTime+duration, or --noiseSFTs
BOOLEAN have_startTime = XLALUserVarWasSet ( &uvar->startTime );
BOOLEAN have_duration = XLALUserVarWasSet ( &uvar->duration );
BOOLEAN have_timestampsFiles = ( uvar->timestampsFiles != NULL );
// need BOTH startTime+duration or none
XLAL_CHECK ( ( have_duration && have_startTime) || !( have_duration || have_startTime ), XLAL_EINVAL, "Need BOTH {--startTime,--duration} or NONE\n");
// at least one of {startTime,timestamps,noiseSFTs,inFrames} required
XLAL_CHECK ( have_timestampsFiles || have_startTime || have_noiseSFTs || have_frames, XLAL_EINVAL, "Need at least one of {--timestampsFiles, --startTime+duration, --noiseSFTs, --inFrames}\n" );
// don't allow timestamps + {startTime+duration OR noiseSFTs}
XLAL_CHECK ( !have_timestampsFiles || !(have_startTime||have_noiseSFTs), XLAL_EINVAL, "--timestampsFiles incompatible with {--noiseSFTs or --startTime+duration}\n");
// note, however, that we DO allow --noiseSFTs and --startTime+duration, which will act as a constraint
// on the noise-SFTs to load in
// don't allow --SFToverlap with either --noiseSFTs OR --timestampsFiles
XLAL_CHECK ( uvar->SFToverlap >= 0, XLAL_EDOM );
BOOLEAN haveOverlap = ( uvar->SFToverlap > 0 );
XLAL_CHECK ( !haveOverlap || !( have_noiseSFTs || have_timestampsFiles ), XLAL_EINVAL, "--SFToverlap incompatible with {--noiseSFTs or --timestampsFiles}\n" );
// now handle the 3 mutually-exclusive cases: have_noiseSFTs || have_timestampsFiles || have_startTime (only)
if ( have_noiseSFTs )
{
SFTConstraints XLAL_INIT_DECL(constraints);
if ( have_startTime && have_duration ) // use optional (startTime+duration) as constraints,
{
LIGOTimeGPS minStartTime, maxStartTime;
minStartTime = uvar->startTime;
maxStartTime = uvar->startTime;
XLALGPSAdd ( &maxStartTime, uvar->duration );
constraints.minStartTime = &minStartTime;
constraints.maxStartTime = &maxStartTime;
char bufGPS1[32], bufGPS2[32];
XLALPrintWarning ( "Only noise-SFTs between GPS [%s, %s] will be used!\n", XLALGPSToStr(bufGPS1, &minStartTime), XLALGPSToStr(bufGPS2, &maxStartTime) );
} /* if start+duration given */
XLAL_CHECK ( (cfg->noiseCatalog = XLALSFTdataFind ( uvar->noiseSFTs, &constraints )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( cfg->noiseCatalog->length > 0, XLAL_EINVAL, "No noise-SFTs matching (start+duration, timestamps) were found!\n" );
XLAL_CHECK ( (cfg->multiNoiseCatalogView = XLALGetMultiSFTCatalogView ( cfg->noiseCatalog )) != NULL, XLAL_EFUNC );
// extract multi-timestamps from the multi-SFT-catalog view
XLAL_CHECK ( (cfg->multiTimestamps = XLALTimestampsFromMultiSFTCatalogView ( cfg->multiNoiseCatalogView )) != NULL, XLAL_EFUNC );
// extract IFOs from multi-SFT catalog
XLAL_CHECK ( XLALMultiLALDetectorFromMultiSFTCatalogView ( &(cfg->multiIFO), cfg->multiNoiseCatalogView ) == XLAL_SUCCESS, XLAL_EFUNC );
} // endif have_noiseSFTs
else if ( have_timestampsFiles )
{
XLAL_CHECK ( (cfg->multiTimestamps = XLALReadMultiTimestampsFiles ( uvar->timestampsFiles )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (cfg->multiTimestamps->length > 0) && (cfg->multiTimestamps->data != NULL), XLAL_EINVAL, "Got empty timestamps-list from XLALReadMultiTimestampsFiles()\n" );
for ( UINT4 X=0; X < cfg->multiTimestamps->length; X ++ ) {
cfg->multiTimestamps->data[X]->deltaT = uvar->Tsft; // Tsft information not given by timestamps-file
}
} // endif have_timestampsFiles
else if ( have_startTime && have_duration )
{
XLAL_CHECK ( ( cfg->multiTimestamps = XLALMakeMultiTimestamps ( uvar->startTime, uvar->duration, uvar->Tsft, uvar->SFToverlap, cfg->multiIFO.length )) != NULL, XLAL_EFUNC );
} // endif have_startTime
// check if the user asked for Gaussian white noise to be produced (sqrtSn[X]!=0), otherwise leave noise-floors at 0
if ( uvar->sqrtSX != NULL ) {
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &(cfg->multiNoiseFloor), uvar->sqrtSX, cfg->multiIFO.length ) == XLAL_SUCCESS, XLAL_EFUNC );
} else {
cfg->multiNoiseFloor.length = cfg->multiIFO.length;
// values remain at their default sqrtSn[X] = 0;
}
#ifdef HAVE_LIBLALFRAME
// if user requested time-series data from frames to be added: try to read the frames now
if ( have_frames )
{
UINT4 numDetectors = uvar->inFrChannels->length;
XLAL_CHECK ( uvar->inFrames->length == numDetectors, XLAL_EINVAL, "Need equal number of channel names (%d) as frame specifications (%d)\n", uvar->inFrChannels->length, numDetectors );
XLAL_CHECK ( (cfg->inputMultiTS = XLALCalloc ( 1, sizeof(*cfg->inputMultiTS))) != NULL, XLAL_ENOMEM );
cfg->inputMultiTS->length = numDetectors;
XLAL_CHECK ( (cfg->inputMultiTS->data = XLALCalloc ( numDetectors, sizeof(cfg->inputMultiTS->data[0]) )) != NULL, XLAL_ENOMEM );
if ( cfg->multiTimestamps == NULL )
{
XLAL_CHECK ( (cfg->multiTimestamps = XLALCalloc ( 1, sizeof(*cfg->multiTimestamps) )) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( (cfg->multiTimestamps->data = XLALCalloc ( numDetectors, sizeof(cfg->multiTimestamps->data[0]))) != NULL, XLAL_ENOMEM );
cfg->multiTimestamps->length = numDetectors;
}
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
LALCache *cache;
XLAL_CHECK ( (cache = XLALCacheImport ( uvar->inFrames->data[X] )) != NULL, XLAL_EFUNC, "Failed to import cache file '%s'\n", uvar->inFrames->data[X] );
// this is a sorted cache, so extract its time-range:
REAL8 cache_tStart = cache->list[0].t0;
REAL8 cache_tEnd = cache->list[cache->length-1].t0 + cache->list[cache->length-1].dt;
REAL8 cache_duration = (cache_tEnd - cache_tStart);
LIGOTimeGPS ts_start;
REAL8 ts_duration;
// check that it's consistent with timestamps, if given, otherwise create timestamps from this
if ( cfg->multiTimestamps->data[X] != NULL ) // FIXME: implicitly assumes timestamps are sorted, which is not guaranteed by timestamps-reading from file
{
const LIGOTimeGPSVector *timestampsX = cfg->multiTimestamps->data[X];
REAL8 tStart = XLALGPSGetREAL8( ×tampsX->data[0] );
REAL8 tEnd = XLALGPSGetREAL8( ×tampsX->data[timestampsX->length-1]) + timestampsX->deltaT;
XLAL_CHECK ( tStart >= cache_tStart && tEnd <= cache_tEnd, XLAL_EINVAL, "Detector X=%d: Requested timestamps-range [%.0f, %.0f]s outside of cache range [%.0f,%.0f]s\n",
X, tStart, tEnd, cache_tStart, cache_tEnd );
XLALGPSSetREAL8 ( &ts_start, tStart );
ts_duration = (tEnd - tStart);
}
else
{
XLALGPSSetREAL8 ( &ts_start, (REAL8)cache_tStart + 1); // cache times can apparently be by rounded up or down by 1s, so shift by 1s to be safe
ts_duration = cache_duration - 1;
XLAL_CHECK ( (cfg->multiTimestamps->data[X] = XLALMakeTimestamps ( ts_start, ts_duration, uvar->Tsft, uvar->SFToverlap ) ) != NULL, XLAL_EFUNC );
}
// ----- now open frame stream and read *all* the data within this time-range [FIXME] ----------
LALFrStream *stream;
XLAL_CHECK ( (stream = XLALFrStreamCacheOpen ( cache )) != NULL, XLAL_EFUNC, "Failed to open stream from cache file '%s'\n", uvar->inFrames->data[X] );
XLALDestroyCache ( cache );
const char *channel = uvar->inFrChannels->data[X];
size_t limit = 0; // unlimited read
REAL8TimeSeries *ts;
XLAL_CHECK ( (ts = XLALFrStreamInputREAL8TimeSeries ( stream, channel, &ts_start, ts_duration, limit )) != NULL,
XLAL_EFUNC, "Frame reading failed for stream created for '%s': ts_start = {%d,%d}, duration=%.0f\n", uvar->inFrames->data[X], ts_start.gpsSeconds, ts_start.gpsNanoSeconds, ts_duration );
cfg->inputMultiTS->data[X] = ts;
XLAL_CHECK ( XLALFrStreamClose ( stream ) == XLAL_SUCCESS, XLAL_EFUNC, "Stream closing failed for cache file '%s'\n", uvar->inFrames->data[X] );
} // for X < numDetectors
} // if inFrames
// if user requested timeseries *output* to frame files, handle deprecated options
XLAL_CHECK ( !(uvar->TDDframedir && uvar->outFrameDir), XLAL_EINVAL, "Specify only ONE of {--TDDframedir or --outFrameDir} or NONE\n");
if ( uvar->TDDframedir ) {
cfg->outFrameDir = uvar->TDDframedir;
} else if ( uvar->outFrameDir ) {
cfg->outFrameDir = uvar->outFrameDir;
}
#endif
return XLAL_SUCCESS;
} /* XLALInitMakefakedata() */
/** Output the results to file
*
* We choose to output all results from a specific analysis to a single file
*
*/
int XLALOpenSemiCoherentResultsFile(FILE **fp, /**< [in] filepointer to output file */
CHAR *outputdir, /**< [in] the output directory name */
ParameterSpace *pspace, /**< [in] the parameter space */
CHAR *clargs, /**< [in] the command line args */
UserInput_t *uvar /**< UNDOCUMENTED */
)
{
CHAR outputfile[LONGSTRINGLENGTH]; /* the output filename */
time_t curtime = time(NULL); /* get the current time */
CHAR *time_string = NULL; /* stores the current time */
CHAR *version_string = NULL; /* pointer to a string containing the git version information */
/* validate input */
if (outputdir == NULL) {
LogPrintf(LOG_CRITICAL,"%s: Invalid input, output directory string == NULL.\n",__func__);
XLAL_ERROR(XLAL_EINVAL);
}
if (pspace == NULL) {
LogPrintf(LOG_CRITICAL,"%s: Invalid input, ParameterSpace structure == NULL.\n",__func__);
XLAL_ERROR(XLAL_EINVAL);
}
/* define the output filename */
/* the format we adopt is the following SemiCoherentResults-<SOURCE>-<START>_<END>-<MIN_FREQ_INT>_<MIN_FREQ_mHZ>_ <MAX_FREQ_INT>_<MAX_FREQ_mHZ>.txt */
{
UINT4 min_freq_int = floor(pspace->space->data[0].min);
UINT4 max_freq_int = floor(pspace->space->data[0].max);
UINT4 min_freq_mhz = (UINT4)floor(0.5 + (pspace->space->data[0].min - (REAL8)min_freq_int)*1e3);
UINT4 max_freq_mhz = (UINT4)floor(0.5 + (pspace->space->data[0].max - (REAL8)max_freq_int)*1e3);
UINT4 end = (UINT4)ceil(XLALGPSGetREAL8(&(pspace->epoch)) + pspace->span);
/* if (coherent) snprintf(outputfile,LONGSTRINGLENGTH,"%s/CoherentResults-%s-%d_%d-%04d_%03d_%04d_%03d.txt",
outputdir,(CHAR*)uvar->comment,pspace->epoch.gpsSeconds,end,min_freq_int,min_freq_mhz,max_freq_int,max_freq_mhz);
else */
snprintf(outputfile,LONGSTRINGLENGTH,"%s/SemiCoherentResults-%s-%d_%d-%04d_%03d_%04d_%03d.txt",
outputdir,(CHAR*)uvar->comment,pspace->epoch.gpsSeconds,end,min_freq_int,min_freq_mhz,max_freq_int,max_freq_mhz);
}
LogPrintf(LOG_DEBUG,"%s : output %s\n",__func__,outputfile);
/* open the output file */
if (((*fp) = fopen(outputfile,"w")) == NULL) {
LogPrintf(LOG_CRITICAL,"%s: Error, failed to open file %s for writing. Exiting.\n",__func__,outputfile);
XLAL_ERROR(XLAL_EINVAL);
}
/* Convert time to local time representation */
{
struct tm *loctime = localtime(&curtime);
CHAR *temp_time = asctime(loctime);
UINT4 n = strlen(temp_time);
time_string = XLALCalloc(n,sizeof(CHAR));
snprintf(time_string,n-1,"%s",temp_time);
}
/* get GIT version information */
{
CHAR *temp_version = XLALGetVersionString(0);
UINT4 n = strlen(temp_version);
version_string = XLALCalloc(n,sizeof(CHAR));
snprintf(version_string,n-1,"%s",temp_version);
XLALFree(temp_version);
}
/* output header information */
fprintf((*fp),"%s \n",version_string);
fprintf((*fp),"%%%% command line args\t\t= %s\n",clargs);
fprintf((*fp),"%%%% filename\t\t\t\t= %s\n",outputfile);
fprintf((*fp),"%%%% date\t\t\t\t\t= %s\n",time_string);
fprintf((*fp),"%%%% start time (GPS sec)\t\t= %d\n",pspace->epoch.gpsSeconds);
fprintf((*fp),"%%%% observation span (sec)\t= %d\n",(UINT4)pspace->span);
fprintf((*fp),"%%%% coherent time (sec)\t\t= %d\n",(UINT4)pspace->tseg);
/* fprintf(fp,"%%%% number of segments\t\t= %d\n",Bayes->nsegments); */
/* fprintf(fp,"%%%% number of dimensions\t= %d\n",Bayes->gridparams->ndim); */
/* if (pspace->ampspace) fprintf(fp,"%%%% amplitude dimension\t\t\t= 1\n"); */
/* else fprintf(fp,"%%%% amplitude dimension\t\t\t= 0\n"); */
/* fprintf(fp,"%%%% mismatch\t\t\t\t= %6.12f\n",Bayes->gridparams->mismatch); */
fprintf((*fp),"%%%%\n");
/* free memory */
XLALFree(time_string);
XLALFree(version_string);
LogPrintf(LOG_DEBUG,"%s : leaving.\n",__func__);
return XLAL_SUCCESS;
}
/** Read in input user arguments
*
*/
int XLALReadUserVars(int argc, /**< [in] the command line argument counter */
char *argv[], /**< [in] the command line arguments */
UserInput_t *uvar, /**< [out] the user input structure */
CHAR **clargs /**< [out] the command line args string */
)
{
CHAR *version_string;
INT4 i;
/* initialise user variables */
uvar->sftbasename = NULL;
uvar->comment = NULL;
uvar->gpsstart = -1;
uvar->gpsend = -1;
uvar->mismatch = 0.2;
uvar->ntoplist = 10;
uvar->coverage = -1;
uvar->blocksize = 100;
uvar->tsft = 256;
uvar->seed = 1;
uvar->tempdir = NULL;
/* initialise all parameter space ranges to zero */
uvar->freqband = 0;
uvar->minorbperiod = 0.0;
uvar->maxorbperiod = 0.0;
uvar->minasini = 0.0;
uvar->maxasini = 0.0;
uvar->tasc = -1.0;
uvar->deltaorbphase = 2.0*LAL_PI;
/* ---------- register all user-variables ---------- */
XLALRegisterUvarMember(sftbasename, STRING, 'i', REQUIRED, "The basename of the input SFT files");
XLALRegisterUvarMember(outputdir, STRING, 'o', REQUIRED, "The output directory name");
XLALRegisterUvarMember(comment, STRING, 'C', REQUIRED, "An analysis descriptor string");
XLALRegisterUvarMember(tempdir, STRING, 'z', OPTIONAL, "A temporary directory");
XLALRegisterUvarMember(freq, REAL8, 'f', REQUIRED, "The starting frequency (Hz)");
XLALRegisterUvarMember(freqband, REAL8, 'b', OPTIONAL, "The frequency band (Hz)");
XLALRegisterUvarMember(minorbperiod, REAL8, 'p', REQUIRED, "The minimum orbital period value (sec)");
XLALRegisterUvarMember(maxorbperiod, REAL8, 'P', OPTIONAL, "The maximum orbital period value (sec)");
XLALRegisterUvarMember(minasini, REAL8, 'a', REQUIRED, "The minimum orbital semi-major axis (sec)");
XLALRegisterUvarMember(maxasini, REAL8, 'A', OPTIONAL, "The maximum orbital semi-major axis (sec)");
XLALRegisterUvarMember(tasc, REAL8, 't', REQUIRED, "The best guess orbital time of ascension (rads)");
XLALRegisterUvarMember(deltaorbphase, REAL8, 'T', OPTIONAL, "The orbital phase uncertainty (cycles)");
XLALRegisterUvarMember(mismatch, REAL8, 'm', OPTIONAL, "The grid mismatch (0->1)");
XLALRegisterUvarMember(coverage, REAL8, 'c', OPTIONAL, "The random template coverage (0->1)");
XLALRegisterUvarMember(blocksize, INT4, 'r', OPTIONAL, "The running median block size");
XLALRegisterUvarMember(tsft, INT4, 'S', OPTIONAL, "The length of the input SFTs in seconds");
XLALRegisterUvarMember(ntoplist, INT4, 'x', OPTIONAL, "output the top N results");
XLALRegisterUvarMember(seed, INT4, 'X', OPTIONAL, "The random number seed (0 = clock)");
XLALRegisterUvarMember(gpsstart, INT4, 's', OPTIONAL, "The minimum start time (GPS sec)");
XLALRegisterUvarMember(gpsend, INT4, 'e', OPTIONAL, "The maximum end time (GPS sec)");
XLALRegisterUvarMember(version, BOOLEAN, 'V', SPECIAL, "Output code version");
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if (XLALUserVarReadAllInput(&should_exit, argc, argv)) {
LogPrintf(LOG_CRITICAL,"%s : XLALUserVarReadAllInput failed with error = %d\n",__func__,xlalErrno);
return XLAL_EFAULT;
}
if (should_exit) exit(1);
if ((version_string = XLALGetVersionString(0)) == NULL) {
XLALPrintError("XLALGetVersionString(0) failed.\n");
exit(1);
}
if (uvar->version) {
printf("%s\n",version_string);
exit(0);
}
XLALFree(version_string);
/* put clargs into string */
*clargs = XLALCalloc(1,sizeof(CHAR));
for (i=0;i<argc;i++) {
INT4 len = 2 + strlen(argv[i]) + strlen(*clargs);
*clargs = XLALRealloc(*clargs,len*sizeof(CHAR));
strcat(*clargs,argv[i]);
strcat(*clargs," ");
}
LogPrintf(LOG_DEBUG,"%s : leaving.\n",__func__);
return XLAL_SUCCESS;
}
/**
* MAIN function of PredictFStat code.
* Calculates the F-statistic for a given position in the sky and detector
* semi-analytically and outputs the final 2F value.
*/
int main(int argc,char *argv[])
{
LALStatus status = blank_status; /* initialize status */
REAL8 rho2; /* SNR^2 */
UserInput_t uvar = empty_UserInput;
CHAR *VCSInfoString; /**< LAL + LALapps Git version string */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
/* register all user-variable */
LAL_CALL (initUserVars(&status, &uvar), &status);
/* do ALL cmdline and cfgfile handling */
LAL_CALL (LALUserVarReadAllInput(&status, argc, argv), &status);
if (uvar.help) /* if help was requested, we're done here */
exit (0);
if ( (VCSInfoString = XLALGetVersionString(0)) == NULL ) {
XLALPrintError("XLALGetVersionString(0) failed.\n");
exit(1);
}
if ( uvar.version ) {
printf ("%s\n", VCSInfoString );
exit(0);
}
/* Initialize code-setup */
LAL_CALL ( InitPFS(&status, &GV, &uvar ), &status);
{ /* Calculating the F-Statistic */
REAL8 al1, al2, al3;
REAL8 Ap2 = SQ(GV.aPlus);
REAL8 Ac2 = SQ(GV.aCross);
REAL8 cos2psi2 = SQ( cos(2*uvar.psi) );
REAL8 sin2psi2 = SQ( sin(2*uvar.psi) );
al1 = Ap2 * cos2psi2 + Ac2 * sin2psi2; /* A1^2 + A3^2 */
al2 = Ap2 * sin2psi2 + Ac2 * cos2psi2; /* A2^2 + A4^2 */
al3 = ( Ap2 - Ac2 ) * sin(2.0*uvar.psi) * cos(2.0*uvar.psi); /* A1 A2 + A3 A4 */
/* SNR^2 */
rho2 = GV.Mmunu.Sinv_Tsft * (GV.Mmunu.Ad * al1 + GV.Mmunu.Bd * al2 + 2.0 * GV.Mmunu.Cd * al3 );
}
if (uvar.printFstat)
fprintf(stdout, "\n%.1f\n", 4.0 + rho2);
/* output predicted Fstat-value into file, if requested */
if (uvar.outputFstat)
{
FILE *fpFstat = NULL;
CHAR *logstr = NULL;
if ( (fpFstat = fopen (uvar.outputFstat, "wb")) == NULL)
{
XLALPrintError ("\nError opening file '%s' for writing..\n\n", uvar.outputFstat);
return (PREDICTFSTAT_ESYS);
}
/* log search-footprint at head of output-file */
LAL_CALL( LALUserVarGetLog (&status, &logstr, UVAR_LOGFMT_CMDLINE ), &status );
fprintf(fpFstat, "%%%% cmdline: %s\n", logstr );
LALFree ( logstr );
fprintf ( fpFstat, "%s\n", VCSInfoString );
/* append 'dataSummary' */
fprintf (fpFstat, "%s", GV.dataSummary );
/* output E[2F] and std[2F] */
fprintf (fpFstat, "twoF_expected = %g;\n", 4.0 + rho2);
fprintf (fpFstat, "twoF_sigma = %g;\n", sqrt( 4.0 * ( 2.0 + rho2 ) ) );
/* output antenna-pattern matrix MNat_mu_nu = matrix(A, B, C) */
{
/* compute A = <a^2>, B=<b^2>, C=<ab> from the 'discretized versions Ad, Bc, Cd */
REAL8 A = GV.Mmunu.Ad / GV.numSFTs;
REAL8 B = GV.Mmunu.Bd / GV.numSFTs;
REAL8 C = GV.Mmunu.Cd / GV.numSFTs;
REAL8 D = A * B - C * C;
fprintf (fpFstat, "A = %f;\n", A );
fprintf (fpFstat, "B = %f;\n", B );
fprintf (fpFstat, "C = %f;\n", C );
fprintf (fpFstat, "D = %f;\n", D );
}
fclose (fpFstat);
} /* if outputFstat */
/* Free config-Variables and userInput stuff */
LAL_CALL (LALDestroyUserVars (&status), &status);
LALFree ( GV.dataSummary );
XLALFree ( VCSInfoString );
/* did we forget anything ? */
LALCheckMemoryLeaks();
return 0;
} /* main() */
