/**
* Generate a multi-FstatAtomVector for given antenna-pattern functions.
* Simply creates MultiFstatAtomVector and initializes with antenna-pattern function.
*/
MultiFstatAtomVector*
XLALGenerateMultiFstatAtomVector ( const MultiDetectorStateSeries *multiDetStates, /**< [in] multi-detector state series, only used for timestamps */
const MultiAMCoeffs *multiAM /**< input antenna-pattern functions {a_i, b_i} */
)
{
/* check input consistency */
if ( !multiDetStates || !multiDetStates->data ) {
XLALPrintError ("%s: invalid NULL input in 'multiDetStates'\n", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
if ( !multiAM || !multiAM->data || !multiAM->data[0] ) {
XLALPrintError ("%s: invalid NULL input in 'mutiAM'\n", __func__ );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
UINT4 numDet = multiDetStates->length;
if ( numDet != multiAM->length ) {
XLALPrintError ("%s: inconsistent number of detectors in multiDetStates (%d) and multiAM (%d)\n", __func__, multiDetStates->length, multiAM->length );
XLAL_ERROR_NULL ( XLAL_EINVAL );
}
/* create multi-atoms vector */
MultiFstatAtomVector *multiAtoms;
if ( ( multiAtoms = XLALCalloc ( 1, sizeof(*multiAtoms) )) == NULL ) {
XLALPrintError ("%s: XLALCalloc ( 1, %zu) failed.\n", __func__, sizeof(*multiAtoms) );
XLAL_ERROR_NULL ( XLAL_ENOMEM );
}
multiAtoms->length = numDet;
if ( ( multiAtoms->data = XLALCalloc ( numDet, sizeof(*multiAtoms->data) ) ) == NULL ) {
XLALPrintError ("%s: XLALCalloc ( %d, %zu) failed.\n", __func__, numDet, sizeof(*multiAtoms->data) );
XLALFree ( multiAtoms );
XLAL_ERROR_NULL ( XLAL_ENOMEM );
}
/* loop over detectors and generate each atoms-vector individually */
UINT4 X;
for ( X=0; X < numDet; X ++ )
{
if ( ( multiAtoms->data[X] = XLALGenerateFstatAtomVector ( multiDetStates->data[X], multiAM->data[X] )) == NULL ) {
XLALPrintError ("%s: XLALGenerateFstatAtomVector() failed.\n", __func__ );
XLALDestroyMultiFstatAtomVector ( multiAtoms );
XLAL_ERROR_NULL ( XLAL_EFUNC );
}
} /* for X < numDet */
/* return result */
return multiAtoms;
} /* XLALGenerateMultiFstatAtomVector() */
// ----- local function definitions ----------
static int
XLALComputeFstatDemod ( FstatResults* Fstats,
const FstatCommon *common,
void *method_data
)
{
// Check input
XLAL_CHECK(Fstats != NULL, XLAL_EFAULT);
XLAL_CHECK(common != NULL, XLAL_EFAULT);
XLAL_CHECK(method_data != NULL, XLAL_EFAULT);
DemodMethodData *demod = (DemodMethodData*) method_data;
// get internal timing info
DemodTimingInfo *ti = &(demod->timingInfo);
REAL8 tic = 0, toc = 0;
// Get which F-statistic quantities to compute
const FstatQuantities whatToCompute = Fstats->whatWasComputed;
// handy shortcuts
BOOLEAN returnAtoms = (whatToCompute & FSTATQ_ATOMS_PER_DET);
PulsarDopplerParams thisPoint = Fstats->doppler;
const REAL8 fStart = thisPoint.fkdot[0];
const MultiSFTVector *multiSFTs = demod->multiSFTs;
const MultiNoiseWeights *multiWeights = common->multiNoiseWeights;
const MultiDetectorStateSeries *multiDetStates = common->multiDetectorStates;
UINT4 numDetectors = multiSFTs->length;
XLAL_CHECK ( multiDetStates->length == numDetectors, XLAL_EINVAL );
XLAL_CHECK ( multiWeights==NULL || (multiWeights->length == numDetectors), XLAL_EINVAL );
UINT4 numSFTs = 0;
for ( UINT4 X = 0; X < numDetectors; X ++ ) {
numSFTs += multiDetStates->data[X]->length;
}
// initialize timing info struct
if ( ti->collectTiming )
{
XLAL_INIT_MEM ( (*ti) );
ti->collectTiming = 1;
ti->numDetectors = numDetectors;
ti->numFreqBins = Fstats->numFreqBins;
ti->numSFTs = numSFTs;
tic = XLALGetCPUTime();
}
MultiSSBtimes *multiSSB = NULL;
MultiAMCoeffs *multiAMcoef = NULL;
// ----- check if we have buffered SSB+AMcoef for current sky-position
if ( (demod->prevAlpha == thisPoint.Alpha) && (demod->prevDelta == thisPoint.Delta ) &&
(demod->prevMultiSSBtimes != NULL) && ( XLALGPSDiff(&demod->prevRefTime, &thisPoint.refTime) == 0 ) && // have SSB times for same reftime?
(demod->prevMultiAMcoef != NULL)
)
{ // if yes ==> reuse
multiSSB = demod->prevMultiSSBtimes;
multiAMcoef = demod->prevMultiAMcoef;
}
else
{ // if not, compute SSB + AMcoef for this skyposition
SkyPosition skypos;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
skypos.longitude = thisPoint.Alpha;
skypos.latitude = thisPoint.Delta;
XLAL_CHECK ( (multiSSB = XLALGetMultiSSBtimes ( multiDetStates, skypos, thisPoint.refTime, common->SSBprec )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (multiAMcoef = XLALComputeMultiAMCoeffs ( multiDetStates, multiWeights, skypos )) != NULL, XLAL_EFUNC );
// store these for possible later re-use in buffer
XLALDestroyMultiSSBtimes ( demod->prevMultiSSBtimes );
demod->prevMultiSSBtimes = multiSSB;
demod->prevRefTime = thisPoint.refTime;
XLALDestroyMultiAMCoeffs ( demod->prevMultiAMcoef );
demod->prevMultiAMcoef = multiAMcoef;
demod->prevAlpha = thisPoint.Alpha;
demod->prevDelta = thisPoint.Delta;
} // if could not reuse previously buffered quantites
MultiSSBtimes *multiBinary = NULL;
MultiSSBtimes *multiSSBTotal = NULL;
// handle binary-orbital timing corrections, if applicable
if ( thisPoint.asini > 0 )
{
// compute binary time corrections to the SSB time delays and SSB time derivitive
XLAL_CHECK ( XLALAddMultiBinaryTimes ( &multiBinary, multiSSB, &thisPoint ) == XLAL_SUCCESS, XLAL_EFUNC );
multiSSBTotal = multiBinary;
}
else
{
multiSSBTotal = multiSSB;
}
if ( ti->collectTiming ) {
toc = XLALGetCPUTime();
ti->tauBary = (toc - tic);
}
// ----- compute final Fstatistic-value -----
REAL4 Ad = multiAMcoef->Mmunu.Ad;
REAL4 Bd = multiAMcoef->Mmunu.Bd;
REAL4 Cd = multiAMcoef->Mmunu.Cd;
REAL4 Ed = multiAMcoef->Mmunu.Ed;;
REAL4 Dd_inv = 1.0 / multiAMcoef->Mmunu.Dd;
// ---------- Compute F-stat for each frequency bin ----------
for ( UINT4 k = 0; k < Fstats->numFreqBins; k++ )
{
// Set frequency to search at
thisPoint.fkdot[0] = fStart + k * Fstats->dFreq;
COMPLEX8 Fa = 0; // complex amplitude Fa
COMPLEX8 Fb = 0; // complex amplitude Fb
MultiFstatAtomVector *multiFstatAtoms = NULL; // per-IFO, per-SFT arrays of F-stat 'atoms', ie quantities required to compute F-stat
// prepare return of 'FstatAtoms' if requested
if ( returnAtoms )
{
XLAL_CHECK ( (multiFstatAtoms = XLALMalloc ( sizeof(*multiFstatAtoms) )) != NULL, XLAL_ENOMEM );
multiFstatAtoms->length = numDetectors;
XLAL_CHECK ( (multiFstatAtoms->data = XLALMalloc ( numDetectors * sizeof(*multiFstatAtoms->data) )) != NULL, XLAL_ENOMEM );
} // if returnAtoms
// loop over detectors and compute all detector-specific quantities
for ( UINT4 X=0; X < numDetectors; X ++)
{
COMPLEX8 FaX, FbX;
FstatAtomVector *FstatAtoms = NULL;
FstatAtomVector **FstatAtoms_p = returnAtoms ? (&FstatAtoms) : NULL;
// call XLALComputeFaFb_...() function for the user-requested hotloop variant
XLAL_CHECK ( (demod->computefafb_func) ( &FaX, &FbX, FstatAtoms_p, multiSFTs->data[X], thisPoint.fkdot,
multiSSBTotal->data[X], multiAMcoef->data[X], demod->Dterms ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( returnAtoms ) {
multiFstatAtoms->data[X] = FstatAtoms; // copy pointer to IFO-specific Fstat-atoms 'contents'
}
XLAL_CHECK ( isfinite(creal(FaX)) && isfinite(cimag(FaX)) && isfinite(creal(FbX)) && isfinite(cimag(FbX)), XLAL_EFPOVRFLW );
if ( whatToCompute & FSTATQ_FAFB_PER_DET )
{
Fstats->FaPerDet[X][k] = FaX;
Fstats->FbPerDet[X][k] = FbX;
}
// compute single-IFO F-stats, if requested
if ( whatToCompute & FSTATQ_2F_PER_DET )
{
REAL4 AdX = multiAMcoef->data[X]->A;
REAL4 BdX = multiAMcoef->data[X]->B;
REAL4 CdX = multiAMcoef->data[X]->C;
REAL4 EdX = 0;
REAL4 DdX_inv = 1.0 / multiAMcoef->data[X]->D;
// compute final single-IFO F-stat
Fstats->twoFPerDet[X][k] = XLALComputeFstatFromFaFb ( FaX, FbX, AdX, BdX, CdX, EdX, DdX_inv );
} // if FSTATQ_2F_PER_DET
/* Fa = sum_X Fa_X */
Fa += FaX;
/* Fb = sum_X Fb_X */
Fb += FbX;
} // for X < numDetectors
if ( whatToCompute & FSTATQ_2F )
{
Fstats->twoF[k] = XLALComputeFstatFromFaFb ( Fa, Fb, Ad, Bd, Cd, Ed, Dd_inv );
}
// Return multi-detector Fa & Fb
if ( whatToCompute & FSTATQ_FAFB )
{
Fstats->Fa[k] = Fa;
Fstats->Fb[k] = Fb;
}
// Return F-atoms per detector
if ( whatToCompute & FSTATQ_ATOMS_PER_DET )
{
XLALDestroyMultiFstatAtomVector ( Fstats->multiFatoms[k] );
Fstats->multiFatoms[k] = multiFstatAtoms;
}
} // for k < Fstats->numFreqBins
// this needs to be free'ed, as it's currently not buffered
XLALDestroyMultiSSBtimes ( multiBinary );
// Return amplitude modulation coefficients
Fstats->Mmunu = demod->prevMultiAMcoef->Mmunu;
// return per-detector antenna-pattern matrices
for ( UINT4 X=0; X < numDetectors; X ++ )
{
Fstats->MmunuX[X].Ad = multiAMcoef->data[X]->A;
Fstats->MmunuX[X].Bd = multiAMcoef->data[X]->B;
Fstats->MmunuX[X].Cd = multiAMcoef->data[X]->C;
Fstats->MmunuX[X].Dd = multiAMcoef->data[X]->D;
Fstats->MmunuX[X].Ed = 0;
}
if ( ti->collectTiming ) {
toc = XLALGetCPUTime();
ti->tauTotal = (toc - tic);
ti->tauF1NoBuf = ti->tauTotal / ( Fstats->numFreqBins * numDetectors );
ti->tauF1Buf = (ti->tauTotal - ti->tauBary) / ( Fstats->numFreqBins * numDetectors );
}
return XLAL_SUCCESS;
} // XLALComputeFstatDemod()
/**
* MAIN function
* Generates samples of B-stat and F-stat according to their pdfs for given signal-params.
*/
int main(int argc,char *argv[])
{
UserInput_t XLAL_INIT_DECL(uvar);
ConfigVariables XLAL_INIT_DECL(cfg);
vrbflg = 1; /* verbose error-messages */
/* turn off default GSL error handler */
gsl_set_error_handler_off ();
/* ----- register and read all user-variables ----- */
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
/* do ALL cmdline and cfgfile handling */
BOOLEAN should_exit = 0;
if ( XLALUserVarReadAllInput ( &should_exit, argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
if ( should_exit )
return EXIT_FAILURE;
if ( uvar.version ) {
/* output verbose VCS version string if requested */
CHAR *vcs;
if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) {
LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno );
return 1;
}
printf ( "%s\n", vcs );
XLALFree ( vcs );
return 0;
}
/* ---------- Initialize code-setup ---------- */
if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* compare IFO name for line injection with IFO list, find the corresponding index, or throw an error if not found */
UINT4 numDetectors = cfg.multiDetStates->length;
INT4 lineX = -1;
if ( uvar.lineIFO ) {
for ( UINT4 X=0; X < numDetectors; X++ ) {
if ( strcmp( uvar.lineIFO, uvar.IFOs->data[X] ) == 0 )
lineX = X;
}
if ( lineX == -1 ) {
XLALPrintError ("\nError in function %s, line %d : Could not match detector ID \"%s\" for line injection to any detector.\n\n", __func__, __LINE__, uvar.lineIFO);
XLAL_ERROR ( XLAL_EFAILED );
}
}
/* ----- prepare stats output ----- */
FILE *fpStats = NULL;
if ( uvar.outputStats )
{
if ( (fpStats = fopen (uvar.outputStats, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpStats, "%s", cfg.logString ); /* write search log comment */
if ( write_BSGL_candidate_to_fp ( fpStats, NULL, uvar.IFOs, NULL, uvar.computeBSGL ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputStats */
/* ----- prepare injection params output ----- */
FILE *fpInjParams = NULL;
if ( uvar.outputInjParams )
{
if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */
if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, uvar.outputMmunuX, numDetectors ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputInjParams */
multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */
/* ----- prepare BSGL computation */
BSGLSetup *BSGLsetup = NULL;
if ( uvar.computeBSGL )
{
BOOLEAN useLogCorrection = TRUE;
REAL4 *oLGX_p = NULL;
REAL4 oLGX[PULSAR_MAX_DETECTORS];
if ( uvar.oLGX != NULL )
{
XLAL_CHECK ( uvar.oLGX->length == numDetectors, XLAL_EINVAL, "Invalid input: length(oLGX) = %d differs from number of detectors (%d)'\n", uvar.oLGX->length, numDetectors );
XLAL_CHECK ( XLALParseLinePriors ( &oLGX[0], uvar.oLGX ) == XLAL_SUCCESS, XLAL_EFUNC );
oLGX_p = &oLGX[0];
}
XLAL_CHECK ( ( BSGLsetup = XLALCreateBSGLSetup ( numDetectors, uvar.Fstar0, oLGX_p, useLogCorrection ) ) != NULL, XLAL_EFUNC );
} // if computeBSGL
/* ----- main MC loop over numDraws trials ---------- */
INT4 i;
for ( i=0; i < uvar.numDraws; i ++ )
{
InjParams_t XLAL_INIT_DECL(injParamsDrawn);
/* ----- generate signal random draws from ranges and generate Fstat atoms */
MultiFstatAtomVector *multiAtoms;
multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, lineX, cfg.multiNoiseWeights );
XLAL_CHECK ( multiAtoms != NULL, XLAL_EFUNC );
/* ----- if requested, output signal injection parameters into file */
if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, uvar.outputMmunuX, numDetectors ) != XLAL_SUCCESS ) ) {
XLAL_ERROR ( XLAL_EFUNC );
} /* if fpInjParams & failure*/
/* initialise BSGLComponents structure and allocate memory */
BSGLComponents XLAL_INIT_DECL(synthStats); /* struct containing multi-detector Fstat, single-detector Fstats, line-robust stat */
synthStats.numDetectors = numDetectors;
/* compute F- and BSGListics from atoms */
UINT4 X;
for ( X=0; X < numDetectors; X++ ) {
synthStats.TwoFX[X] = XLALComputeFstatFromAtoms ( multiAtoms, X );
if ( xlalErrno != 0 ) {
XLALPrintError ("\nError in function %s, line %d : Failed call to XLALComputeFstatFromAtoms().\n\n", __func__, __LINE__);
XLAL_ERROR ( XLAL_EFUNC );
}
}
synthStats.TwoF = XLALComputeFstatFromAtoms ( multiAtoms, -1 );
if ( xlalErrno != 0 ) {
XLALPrintError ("\nError in function %s, line %d : Failed call to XLALComputeFstatFromAtoms().\n\n", __func__, __LINE__);
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar.computeBSGL ) {
synthStats.log10BSGL = XLALComputeBSGL ( synthStats.TwoF, synthStats.TwoFX, BSGLsetup );
XLAL_CHECK ( xlalErrno == 0, XLAL_EFUNC, "XLALComputeBSGL() failed with xlalErrno = %d\n", xlalErrno );
}
/* ----- if requested, output atoms-vector into file */
if ( uvar.outputAtoms )
{
FILE *fpAtoms;
char *fnameAtoms;
UINT4 len = strlen ( uvar.outputAtoms ) + 20;
if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws );
if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */
if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameAtoms );
fclose (fpAtoms);
} /* if outputAtoms */
/* ----- if requested, output transient-cand statistics */
if ( fpStats && write_BSGL_candidate_to_fp ( fpStats, &synthStats, uvar.IFOs, &injParamsDrawn, uvar.computeBSGL ) != XLAL_SUCCESS ) {
XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- free Memory */
XLALDestroyMultiFstatAtomVector ( multiAtoms );
} /* for i < numDraws */
/* ----- close files ----- */
if ( fpStats ) fclose ( fpStats );
if ( fpInjParams ) fclose ( fpInjParams );
/* ----- free memory ---------- */
XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates );
XLALDestroyMultiNoiseWeights ( cfg.multiNoiseWeights );
XLALDestroyExpLUT();
XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM );
/* ----- free amplitude prior pdfs ----- */
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 );
XLALFree ( BSGLsetup );
BSGLsetup = NULL;
if ( cfg.logString ) {
XLALFree ( cfg.logString );
}
gsl_rng_free ( cfg.rng );
XLALDestroyUserVars();
/* did we forget anything ? (doesn't cover gsl-memory!) */
LALCheckMemoryLeaks();
return 0;
} /* main() */
/**
* MAIN function
* Generates samples of B-stat and F-stat according to their pdfs for given signal-params.
*/
int main(int argc,char *argv[])
{
UserInput_t XLAL_INIT_DECL(uvar);
ConfigVariables XLAL_INIT_DECL(cfg); /**< various derived configuration settings */
vrbflg = 1; /* verbose error-messages */
LogSetLevel(lalDebugLevel);
/* turn off default GSL error handler */
gsl_set_error_handler_off ();
/* ----- register and read all user-variables ----- */
LogSetLevel(lalDebugLevel);
if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
/* do ALL cmdline and cfgfile handling */
if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno );
return 1;
}
if (uvar.help) /* if help was requested, we're done here */
return 0;
if ( uvar.version ) {
/* output verbose VCS version string if requested */
CHAR *vcs;
if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) {
LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno );
return 1;
}
printf ( "%s\n", vcs );
XLALFree ( vcs );
return 0;
}
/* ---------- Initialize code-setup ---------- */
if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) {
LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- prepare stats output ----- */
FILE *fpTransientStats = NULL;
if ( uvar.outputStats )
{
if ( (fpTransientStats = fopen (uvar.outputStats, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpTransientStats, "%s", cfg.logString ); /* write search log comment */
if ( write_transientCandidate_to_fp ( fpTransientStats, NULL ) != XLAL_SUCCESS ) { /* write header-line comment */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputStats */
/* ----- prepare injection params output ----- */
FILE *fpInjParams = NULL;
if ( uvar.outputInjParams )
{
if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL)
{
LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams );
XLAL_ERROR ( XLAL_EIO );
}
fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */
if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, 0, 0 ) != XLAL_SUCCESS ) { /* write header-line comment - options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them */
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if outputInjParams */
/* ----- main MC loop over numDraws trials ---------- */
multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */
INT4 i;
for ( i=0; i < uvar.numDraws; i ++ )
{
InjParams_t XLAL_INIT_DECL(injParamsDrawn);
/* ----- generate signal random draws from ranges and generate Fstat atoms */
MultiFstatAtomVector *multiAtoms;
multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, -1, NULL ); // options lineX and noise_weights not supported here, so pass defaults to deactivate them
if ( multiAtoms ==NULL ) {
LogPrintf ( LOG_CRITICAL, "%s: XLALSynthesizeTransientAtoms() failed with xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- if requested, output signal injection parameters into file */
if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, 0, 0 ) ) != XLAL_SUCCESS ) { // options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them
XLAL_ERROR ( XLAL_EFUNC );
} /* if fpInjParams & failure*/
/* ----- add meta-info on current transient-CW candidate */
transientCandidate_t XLAL_INIT_DECL(cand);
cand.doppler.Alpha = multiAMBuffer.skypos.longitude;
cand.doppler.Delta = multiAMBuffer.skypos.latitude;
cand.windowRange = cfg.transientSearchRange;
/* ----- if needed: compute transient-Bstat search statistic on these atoms */
if ( fpTransientStats || uvar.outputFstatMap || uvar.outputPosteriors )
{
/* compute Fstat map F_mn over {t0, tau} */
if ( (cand.FstatMap = XLALComputeTransientFstatMap ( multiAtoms, cand.windowRange, uvar.useFReg)) == NULL ) {
XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
} /* if we'll need the Fstat-map F_mn */
/* ----- if requested compute marginalized Bayes factor */
if ( fpTransientStats )
{
cand.logBstat = XLALComputeTransientBstat ( cand.windowRange, cand.FstatMap );
UINT4 err = xlalErrno;
if ( err ) {
XLALPrintError ("%s: XLALComputeTransientBstat() failed with xlalErrno = %d\n", __func__, err );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( uvar.SignalOnly )
{
cand.FstatMap->maxF += 2;
cand.logBstat += 2;
}
} /* if Bstat requested */
/* ----- if requested, compute parameter posteriors for {t0, tau} */
pdf1D_t *pdf_t0 = NULL;
pdf1D_t *pdf_tau = NULL;
if ( fpTransientStats || uvar.outputPosteriors )
{
if ( (pdf_t0 = XLALComputeTransientPosterior_t0 ( cand.windowRange, cand.FstatMap )) == NULL ) {
XLALPrintError ("%s: failed to compute t0-posterior\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( (pdf_tau = XLALComputeTransientPosterior_tau ( cand.windowRange, cand.FstatMap )) == NULL ) {
XLALPrintError ("%s: failed to compute tau-posterior\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* get maximum-posterior estimate (MP) from the modes of these pdfs */
cand.t0_MP = XLALFindModeOfPDF1D ( pdf_t0 );
if ( xlalErrno ) {
XLALPrintError ("%s: mode-estimation failed for pdf_t0. xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
cand.tau_MP = XLALFindModeOfPDF1D ( pdf_tau );
if ( xlalErrno ) {
XLALPrintError ("%s: mode-estimation failed for pdf_tau. xlalErrno = %d\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
} // if posteriors required
/* ----- if requested, compute Ftotal over full data-span */
if ( uvar.computeFtotal )
{
transientFstatMap_t *FtotalMap;
/* prepare special window to cover all the data with one F-stat calculation == Ftotal */
transientWindowRange_t XLAL_INIT_DECL(winRangeAll);
winRangeAll.type = TRANSIENT_NONE;
BOOLEAN useFReg = false;
if ( (FtotalMap = XLALComputeTransientFstatMap ( multiAtoms, winRangeAll, useFReg)) == NULL ) {
XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
/* we only use twoFtotal = 2 * maxF from this single-Fstat calculation */
REAL8 twoFtotal = 2.0 * FtotalMap->maxF;
if ( uvar.SignalOnly )
twoFtotal += 4;
/* ugly hack: lacking a good container for twoFtotal, we borrow fkdot[3] for this here ;) [only used for paper-MCs] */
cand.doppler.fkdot[3] = twoFtotal;
/* good riddance .. */
XLALDestroyTransientFstatMap ( FtotalMap );
} /* if computeFtotal */
/* ----- if requested, output atoms-vector into file */
if ( uvar.outputAtoms )
{
FILE *fpAtoms;
char *fnameAtoms;
UINT4 len = strlen ( uvar.outputAtoms ) + 20;
if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws );
if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */
if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameAtoms );
fclose (fpAtoms);
} /* if outputAtoms */
/* ----- if requested, output Fstat-map over {t0, tau} */
if ( uvar.outputFstatMap )
{
FILE *fpFstatMap;
char *fnameFstatMap;
UINT4 len = strlen ( uvar.outputFstatMap ) + 20;
if ( (fnameFstatMap = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnameFstatMap, "%s_%04d_of_%04d.dat", uvar.outputFstatMap, i + 1, uvar.numDraws );
if ( ( fpFstatMap = fopen ( fnameFstatMap, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open Fstat-map output file '%s' for writing.\n", __func__, fnameFstatMap );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpFstatMap, "%s", cfg.logString ); /* output header info */
fprintf (fpFstatMap, "\nFstat_mn = \\\n" );
if ( XLALfprintfGSLmatrix ( fpFstatMap, "%.9g", cand.FstatMap->F_mn ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALfprintfGSLmatrix() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
XLALFree ( fnameFstatMap );
fclose (fpFstatMap);
} /* if outputFstatMap */
/* ----- if requested, output posterior pdfs on transient params {t0, tau} into a file */
if ( uvar.outputPosteriors )
{
FILE *fpPosteriors;
char *fnamePosteriors;
UINT4 len = strlen ( uvar.outputPosteriors ) + 20;
if ( (fnamePosteriors = XLALCalloc ( 1, len )) == NULL ) {
XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len );
XLAL_ERROR ( XLAL_EFUNC );
}
sprintf ( fnamePosteriors, "%s_%04d_of_%04d.dat", uvar.outputPosteriors, i + 1, uvar.numDraws );
if ( ( fpPosteriors = fopen ( fnamePosteriors, "wb" )) == NULL ) {
XLALPrintError ("%s: failed to open posteriors-output file '%s' for writing.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
fprintf ( fpPosteriors, "%s", cfg.logString ); /* output header info */
/* write them to file, using pdf-method */
if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_t0, "pdf_t0" ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to output t0-posterior to file '%s'.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_tau, "pdf_tau" ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: failed to output tau-posterior to file '%s'.\n", __func__, fnamePosteriors );
XLAL_ERROR ( XLAL_EFUNC );
}
/* free mem, close file */
XLALFree ( fnamePosteriors );
fclose (fpPosteriors);
} /* if outputPosteriors */
/* ----- if requested, output transient-cand statistics */
if ( fpTransientStats && write_transientCandidate_to_fp ( fpTransientStats, &cand ) != XLAL_SUCCESS ) {
XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ----- free Memory */
XLALDestroyTransientFstatMap ( cand.FstatMap );
XLALDestroyMultiFstatAtomVector ( multiAtoms );
XLALDestroyPDF1D ( pdf_t0 );
XLALDestroyPDF1D ( pdf_tau );
} /* for i < numDraws */
/* ----- close files ----- */
if ( fpTransientStats) fclose ( fpTransientStats );
if ( fpInjParams ) fclose ( fpInjParams );
/* ----- free memory ---------- */
XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates );
XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM );
XLALDestroyExpLUT();
/* ----- free amplitude prior pdfs ----- */
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi );
XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 );
if ( cfg.logString ) XLALFree ( cfg.logString );
gsl_rng_free ( cfg.rng );
XLALDestroyUserVars();
/* did we forget anything ? (doesn't cover gsl-memory!) */
LALCheckMemoryLeaks();
return 0;
} /* main() */
static int
ComputeFstat_Demod(
FstatResults* Fstats,
const FstatInputData_Common *common,
FstatInputData_Demod* demod
)
{
// Check input
XLAL_CHECK(Fstats != NULL, XLAL_EFAULT);
XLAL_CHECK(common != NULL, XLAL_EFAULT);
XLAL_CHECK(demod != NULL, XLAL_EFAULT);
// Get which F-statistic quantities to compute
const FstatQuantities whatToCompute = Fstats->whatWasComputed;
// Check which quantities can be computed
XLAL_CHECK(!(whatToCompute & FSTATQ_FAFB_PER_DET), XLAL_EINVAL, "Demodulation does not currently support Fa & Fb per detector");
// Set parameters to pass to ComputeFStat()
demod->params.returnSingleF = (whatToCompute & FSTATQ_2F_PER_DET);
demod->params.returnAtoms = (whatToCompute & FSTATQ_ATOMS_PER_DET);
// Save local copy of doppler point and starting frequency
PulsarDopplerParams thisPoint = Fstats->doppler;
const REAL8 fStart = thisPoint.fkdot[0];
// Call ComputeFStat() for each frequency bin
for (UINT4 k = 0; k < Fstats->numFreqBins; ++k) {
// Set frequency to search at
thisPoint.fkdot[0] = fStart + k * Fstats->dFreq;
// Call ComputeFStat()
Fcomponents Fcomp;
XLAL_CHECK ( ComputeFStat( &Fcomp, &thisPoint, demod->multiSFTs, common->multiWeights, demod->multiDetStates, &demod->params, &demod->buffer) == XLAL_SUCCESS, XLAL_EFUNC );
// Return multi-detector 2F
if (whatToCompute & FSTATQ_2F) {
Fstats->twoF[k] = 2.0 * Fcomp.F; // *** Return value of 2F ***
}
// Return multi-detector Fa & Fb
if (whatToCompute & FSTATQ_FAFB) {
Fstats->FaFb[k].Fa = Fcomp.Fa;
Fstats->FaFb[k].Fb = Fcomp.Fb;
}
// Return 2F per detector
if (whatToCompute & FSTATQ_2F_PER_DET) {
for (UINT4 X = 0; X < Fstats->numDetectors; ++X) {
Fstats->twoFPerDet[X][k] = 2.0 * Fcomp.FX[X]; // *** Return value of 2F ***
}
}
// Return Fa & Fb per detector
if (whatToCompute & FSTATQ_FAFB_PER_DET) {
XLAL_ERROR(XLAL_EFAILED, "Unimplemented!");
}
// Return F-atoms per detector
if (whatToCompute & FSTATQ_ATOMS_PER_DET) {
XLALDestroyMultiFstatAtomVector(Fstats->multiFatoms[k]);
Fstats->multiFatoms[k] = Fcomp.multiFstatAtoms;
}
} // for k < Fstats->numFreqBins
// Return amplitude modulation coefficients
if (demod->buffer.multiAMcoef != NULL) {
Fstats->Mmunu.Ad = demod->buffer.multiAMcoef->Mmunu.Ad;
Fstats->Mmunu.Bd = demod->buffer.multiAMcoef->Mmunu.Bd;
Fstats->Mmunu.Cd = demod->buffer.multiAMcoef->Mmunu.Cd;
Fstats->Mmunu.Ed = 0;
Fstats->Mmunu.Dd = demod->buffer.multiAMcoef->Mmunu.Dd;
Fstats->Mmunu.Sinv_Tsft = demod->buffer.multiAMcoef->Mmunu.Sinv_Tsft;
}
return XLAL_SUCCESS;
} // ComputeFstat_Demod()
