/**
* Test various StringVector functions
*/
int
XLALStringVector_TEST ( void )
{
LALStringVector *strVect1 = NULL, *strVectCmp = NULL;
#define STR1 "Hello"
#define STR2 "World"
#define STR3 "foo"
#define STR4 "H1"
#define STR5 "H2"
#define STR6 "L1"
if ( (strVect1 = XLALCreateStringVector ( STR1, STR2, STR3, STR4, STR5, NULL )) == NULL )
XLAL_ERROR ( XLAL_EFUNC );
if ( ( strVect1 = XLALAppendString2Vector ( strVect1, STR6 )) == NULL )
XLAL_ERROR ( XLAL_EFUNC );
// now sort string-vector according to strcmp()
if ( XLALSortStringVector ( strVect1 ) != XLAL_SUCCESS ) {
XLALDestroyStringVector ( strVect1 );
XLAL_ERROR ( XLAL_EFUNC );
}
// generate 'manually' sorted string-vector, using CSV function instead
// sort-order according to "LC_ALL=C sort"
if ( ( strVectCmp = XLALParseCSV2StringVector ( STR4 "," STR5 "," STR1 "," STR6 "," STR2 "," STR3 )) == NULL ) {
XLALDestroyStringVector ( strVect1 );
XLAL_ERROR ( XLAL_EFUNC );
}
/* compare results */
UINT4 len1 = strVect1->length;
UINT4 len2 = strVectCmp->length;
if ( len1 != len2 ) {
XLALDestroyStringVector ( strVect1 );
XLALDestroyStringVector ( strVectCmp );
XLAL_ERROR ( XLAL_EFAILED, "String vectors have different lengths (%d != %d )\n", len1, len2 );
}
for ( UINT4 i = 0; i < len1; i++ )
{
if ( 0 != strcmp ( strVect1->data[i], strVectCmp->data[i] ) )
{
XLALPrintError ( "%s: Sorted string-vector differs from expectation!\n", __func__ );
for ( UINT4 j=0; j < len1; j ++ )
XLALPrintError ("j = %d: s1[j] = %6s, s2[j] = %6s\n", j, strVect1->data[j], strVectCmp->data[j] );
/* clean up memory, and return with error */
XLALDestroyStringVector ( strVect1 );
XLALDestroyStringVector ( strVectCmp );
XLAL_ERROR ( XLAL_EFAILED, "String sorting failed.\n");
} /* if s1[i] != s2[i] */
} /* for i < len */
/* clean up memory */
XLALDestroyStringVector ( strVect1 );
XLALDestroyStringVector ( strVectCmp );
return XLAL_SUCCESS;
} /* XLALStringVector_TEST() */
// test string-vector parsing function XLALParseStringValueAsStringVector()
int
test_ParseStringVector(void)
{
#define STR1 "Hello, world!"
#define STR2 "xyda 3!#4134"
#define STR3 "&\\//.. :: some junk"
#define STR4 "H1"
#define STR5 "H2"
#define STR6 "L1"
LALStringVector *strVect1;
XLAL_CHECK ( (strVect1 = XLALCreateStringVector ( STR1, STR2, STR3, STR4, STR5, NULL )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (strVect1 = XLALAppendString2Vector ( strVect1, STR6 )) != NULL, XLAL_EFUNC );
// now 'print' this string-vector as a 'string-value', then re-parse back into a vector:
CHAR *strValue1 = NULL;
LALStringVector *strVect2 = NULL;
XLAL_CHECK ( (strValue1 = XLALPrintStringValueOfSTRINGVector ( &strVect1 )) != NULL, XLAL_EFUNC );
XLALPrintInfo ("String value of initial string-vector: %s\n", strValue1 );
XLAL_CHECK ( XLALParseStringValueAsSTRINGVector ( &strVect2, strValue1 ) == XLAL_SUCCESS, XLAL_EFUNC );
CHAR *strValue2 = NULL;
XLAL_CHECK ( (strValue2 = XLALPrintStringValueOfSTRINGVector ( &strVect2 )) != NULL, XLAL_EFUNC );
XLALPrintInfo ("String value of re-parsed string-vector: %s\n", strValue2 );
// ----- compare results
// 1) compare string values
XLAL_CHECK ( strcmp ( strValue1, strValue2 ) == 0, XLAL_EFAILED, "String values differ:\nstrValue1 = %s\nstrValue2 = %s\n", strValue1, strValue2 );
// 2) compare string vectors
UINT4 len1 = strVect1->length;
UINT4 len2 = strVect2->length;
XLAL_CHECK ( len1 == len2, XLAL_EFAILED, "String vectors vect1 and vect2 have different lengths (%d != %d )\n", len1, len2 );
for ( UINT4 i = 0; i < len1; i++ )
{
if ( strcmp ( strVect1->data[i], strVect2->data[i] ) != 0 )
{
for ( UINT4 j=0; j < len1; j ++ ) {
XLALPrintError ("j = %d: s1[j] = %6s, s2[j] = %6s\n", j, strVect1->data[j], strVect2->data[j] );
}
XLAL_ERROR ( XLAL_EFAILED, "Printed and re-parsed string-vector differ!\n" );
} // if s1[i] != s2[i]
} // for i < len
// clean up memory
XLALFree ( strValue1 );
XLALFree ( strValue2 );
XLALDestroyStringVector ( strVect1 );
XLALDestroyStringVector ( strVect2 );
return XLAL_SUCCESS;
} // test_ParseStringVector()
/** register all "user-variables" */
int
XLALInitUserVars ( UserVariables_t *uvar )
{
XLAL_CHECK ( uvar != NULL, XLAL_EINVAL );
/* set a few defaults */
uvar->help = 0;
XLAL_CHECK ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) != NULL, XLAL_ENOMEM, "Call to XLALCreateStringVector() failed." );
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->Alpha = 0.0;
uvar->Delta = 0.0;
uvar->skyGridFile = NULL;
uvar->timeGPS = NULL;
uvar->timeStampsFile = NULL;
uvar->outab = 0;
uvar->outABCD = 0;
uvar->Tsft = 1800;
uvar->noiseSqrtShX = NULL;
/* register all user-variables */
XLALregBOOLUserStruct( help, 'h', UVAR_HELP, "Print this help/usage message");
XLALregLISTUserStruct( IFOs, 'I', UVAR_OPTIONAL, "Comma-separated list of detectors, eg. \"H1,H2,L1,G1, ...\" [only 1 detector supported at the moment] ");
XLALregREALUserStruct( Alpha, 'a', UVAR_OPTIONAL, "single skyposition Alpha in radians, equatorial coords.");
XLALregREALUserStruct( Delta, 'd', UVAR_OPTIONAL, "single skyposition Delta in radians, equatorial coords.");
XLALregSTRINGUserStruct( skyGridFile, 's', UVAR_OPTIONAL, "Alternatively: sky-grid file");
XLALregLISTUserStruct( timeGPS, 't', UVAR_OPTIONAL, "GPS time at which to compute detector states (separate multiple timestamps by commata)");
XLALregLISTUserStruct( timeStampsFiles, 'T', UVAR_OPTIONAL, "Alternative: time-stamps file(s) (comma-separated list per IFO, or one for all)");
XLALregINTUserStruct( Tsft, 0, UVAR_OPTIONAL, "Assumed length of one SFT in seconds; needed for timestamps offset consistency with F-stat based codes");
XLALregLISTUserStruct ( noiseSqrtShX, 0, UVAR_OPTIONAL, "Per-detector noise PSD sqrt(SX). Only ratios relevant to compute noise weights. Defaults to 1,1,...");
XLALregSTRINGUserStruct ( ephemEarth, 0, UVAR_OPTIONAL, "Earth ephemeris file to use");
XLALregSTRINGUserStruct ( ephemSun, 0, UVAR_OPTIONAL, "Sun ephemeris file to use");
XLALregSTRINGUserStruct( outab, 'o', UVAR_OPTIONAL, "output file for antenna pattern functions a(t), b(t) at each timestamp");
XLALregSTRINGUserStruct( outABCD, 'O', UVAR_OPTIONAL, "output file for antenna pattern matrix elements A, B, C, D averaged over timestamps");
XLALregBOOLUserStruct( version, 'V', UVAR_SPECIAL, "Output code version");
/* developer user variables */
XLALregSTRINGUserStruct( timeStampsFile, 0, UVAR_OPTIONAL, "Alternative: single time-stamps file (deprecated, use --timeStampsFiles instead");
return XLAL_SUCCESS;
} /* XLALInitUserVars() */
/**
* Register all our "user-variables" that can be specified from cmd-line and/or config-file.
* Here we set defaults for some user-variables and register them with the UserInput module.
*/
int
XLALInitUserVars ( UserInput_t *uvar )
{
/* set a few defaults */
uvar->outputStats = NULL;
uvar->Alpha = -1; /* Alpha < 0 indicates "allsky" */
uvar->Delta = 0;
uvar->phi0 = 0;
uvar->psi = 0;
uvar->dataStartGPS = 814838413; /* 1 Nov 2005, ~ start of S5 */
uvar->dataDuration = (INT4) round ( LAL_YRSID_SI ) ; /* 1 year of data */
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->numDraws = 1;
uvar->TAtom = 1800;
uvar->computeBSGL = 1;
uvar->Fstar0 = -LAL_REAL4_MAX; /* corresponding to OSL limit */
uvar->oLGX = NULL;
uvar->sqrtSX = NULL;
uvar->useFReg = 0;
uvar->fixedh0Nat = -1;
uvar->fixedSNR = -1;
uvar->fixedh0NatMax = -1;
uvar->fixedRhohMax = -1;
if ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Call to XLALCreateStringVector() failed with xlalErrno = %d\n", xlalErrno );
XLAL_ERROR ( XLAL_ENOMEM );
}
uvar->lineIFO = NULL;
/* ---------- transient window defaults ---------- */
#define DEFAULT_TRANSIENT "rect"
/* register all our user-variables */
/* signal Doppler parameters */
XLALRegisterUvarMember( Alpha, REAL8, 'a', OPTIONAL, "Sky position alpha (equatorial coordinates) in radians [Default:allsky]");
XLALRegisterUvarMember( Delta, REAL8, 'd', OPTIONAL, "Sky position delta (equatorial coordinates) in radians [Default:allsky]");
/* signal amplitude parameters */
XLALRegisterUvarMember( fixedh0Nat, REAL8, 0, OPTIONAL, "Alternative 1: if >=0 fix the GW amplitude: h0/sqrt(Sn)");
XLALRegisterUvarMember( fixedSNR, REAL8, 0, OPTIONAL, "Alternative 2: if >=0 fix the optimal SNR of the injected signals");
XLALRegisterUvarMember( fixedh0NatMax, REAL8, 0, OPTIONAL, "Alternative 3: if >=0 draw GW amplitude h0 in [0, h0NatMax ] (FReg prior)");
XLALRegisterUvarMember( fixedRhohMax, REAL8, 0, OPTIONAL, "Alternative 4: if >=0 draw rhoh=h0*(detM)^(1/8) in [0, rhohMax] (canonical F-stat prior)");
XLALRegisterUvarMember( cosi, REAL8, 'i', OPTIONAL, "cos(inclination angle). If not set: randomize within [-1,1].");
XLALRegisterUvarMember( psi, REAL8, 0, OPTIONAL, "polarization angle psi. If not set: randomize within [-pi/4,pi/4].");
XLALRegisterUvarMember( phi0, REAL8, 0, OPTIONAL, "initial GW phase phi_0. If not set: randomize within [0, 2pi]");
XLALRegisterUvarMember( AmpPriorType, INT4, 0, OPTIONAL, "Enumeration of types of amplitude-priors: 0=physical, 1=canonical");
XLALRegisterUvarMember( IFOs, STRINGVector, 'I', OPTIONAL, "Comma-separated list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALRegisterUvarMember( lineIFO, STRING, 0, OPTIONAL, "Insert a line (signal in this one IFO, pure gaussian noise in others), e.g. \"H1\"");
XLALRegisterUvarMember( dataStartGPS, INT4, 0, OPTIONAL, "data start-time in GPS seconds");
XLALRegisterUvarMember( dataDuration, INT4, 0, OPTIONAL, "data-span to generate (in seconds)");
/* misc params */
XLALRegisterUvarMember( computeBSGL, BOOLEAN, 0, OPTIONAL, "Compute line-robust statistic (BSGL)");
XLALRegisterUvarMember( Fstar0, REAL8, 0, OPTIONAL, "BSGL: transition-scale parameter 'Fstar0'");
XLALRegisterUvarMember( oLGX, STRINGVector, 0, OPTIONAL, "BSGL: prior per-detector line-vs-Gauss odds, length must be numDetectors. (Defaults to oLGX=1/Ndet)");
XLALRegisterUvarMember( sqrtSX, STRINGVector, 0, OPTIONAL, "Per-detector noise PSD sqrt(SX). Only ratios relevant to compute noise weights. Defaults to 1,1,...");
XLALRegisterUvarMember( numDraws, INT4, 'N', OPTIONAL,"Number of random 'draws' to simulate");
XLALRegisterUvarMember( randSeed, INT4, 0, OPTIONAL, "GSL random-number generator seed value to use");
XLALRegisterUvarMember( outputStats, STRING, 'o', OPTIONAL, "Output file containing 'numDraws' random draws of stats");
XLALRegisterUvarMember( outputAtoms, STRING, 0, OPTIONAL, "Output F-statistic atoms into a file with this basename");
XLALRegisterUvarMember( outputInjParams, STRING, 0, OPTIONAL, "Output injection parameters into this file");
XLALRegisterUvarMember( outputMmunuX, BOOLEAN, 0, OPTIONAL, "Write the per-IFO antenna pattern matrices into the parameter file");
XLALRegisterUvarMember( SignalOnly, BOOLEAN, 'S', OPTIONAL, "Signal only: generate pure signal without noise");
XLALRegisterUvarMember( useFReg, BOOLEAN, 0, OPTIONAL, "use 'regularized' Fstat (1/D)*e^F (if TRUE) for marginalization, or 'standard' e^F (if FALSE)");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember( version, BOOLEAN, 'V', SPECIAL, "Output code version");
/* 'hidden' stuff */
XLALRegisterUvarMember( TAtom, INT4, 0, DEVELOPER, "Time baseline for Fstat-atoms (typically Tsft) in seconds." );
if ( xlalErrno ) {
XLALPrintError ("%s: something failed in initializing user variabels .. errno = %d.\n", __func__, xlalErrno );
XLAL_ERROR ( XLAL_EFUNC );
}
return XLAL_SUCCESS;
} /* XLALInitUserVars() */
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
// ---------- handle user input ----------
UserInput_t XLAL_INIT_DECL(uvar_s);
UserInput_t *uvar = &uvar_s;
uvar->FstatMethod = XLALStringDuplicate("ResampBest");
uvar->Freq = 100;
uvar->f1dot = -3e-9;
uvar->FreqResolution = XLALCreateREAL8Vector ( 2 );
uvar->FreqResolution->data[0] = 1;
uvar->FreqResolution->data[1] = 10;
uvar->numFreqBins = XLALCreateINT4Vector ( 2 );
uvar->numFreqBins->data[0] = 1000;
uvar->numFreqBins->data[1] = 100000;
uvar->Tseg = 60 * 3600;
uvar->numSegments = 90;
uvar->numTrials = 1;
uvar->Tsft = 1800;
uvar->runBuffered = 0;
XLAL_CHECK ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) != NULL, XLAL_EFUNC );
uvar->outputInfo = NULL;
XLAL_CHECK ( XLALRegisterUvarMember ( help, BOOLEAN, 'h', HELP, "Print help message" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FstatMethod, STRING, 0, OPTIONAL, XLALFstatMethodHelpString() ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Freq, REAL8, 0, OPTIONAL, "Search frequency in Hz" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( f1dot, REAL8, 0, OPTIONAL, "Search spindown f1dot in Hz/s" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( FreqResolution, REAL8Vector, 0, OPTIONAL, "Range of frequency resolution factor 'r' (st dFreq = 1/(r*T)) [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tseg, REAL8, 0, OPTIONAL, "Coherent segment length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numSegments, INT4, 0, OPTIONAL, "Number of semi-coherent segment" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numFreqBins, INT4Vector, 0, OPTIONAL, "Range of number of frequency bins to search [2-number range input]" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( IFOs, STRINGVector, 0, OPTIONAL, "IFOs to use" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( numTrials, INT4, 0, OPTIONAL, "Number of repeated trials to run (with potentially randomized parameters)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( outputInfo, STRING, 0, OPTIONAL, "Append Resampling internal info into this file") == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( Tsft, REAL8, 0, DEVELOPER, "SFT length" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALRegisterUvarMember ( runBuffered, BOOLEAN, 0, DEVELOPER, "Explicitly time buffered Fstat call (only useful for double-checking and Demod timing)" ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALUserVarReadAllInput(argc, argv) == XLAL_SUCCESS, XLAL_EFUNC );
if (uvar->help) { // if help was requested, we're done here
return XLAL_SUCCESS;
}
// check user input
XLAL_CHECK ( uvar->numSegments >= 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->FreqResolution->length == 1) || (uvar->FreqResolution->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[0] > 0, XLAL_EINVAL );
REAL8 FreqResolutionMin, FreqResolutionMax;
FreqResolutionMin = FreqResolutionMax = uvar->FreqResolution->data[0];
if ( uvar->FreqResolution->length == 2 )
{
XLAL_CHECK ( uvar->FreqResolution->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->FreqResolution->data[1] > uvar->FreqResolution->data[0], XLAL_EINVAL );
FreqResolutionMax = uvar->FreqResolution->data[1];
}
XLAL_CHECK ( uvar->Freq > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tseg > uvar->Tsft, XLAL_EINVAL );
XLAL_CHECK ( uvar->Tsft > 1, XLAL_EINVAL );
XLAL_CHECK ( (uvar->numFreqBins->length == 1) || (uvar->numFreqBins->length == 2), XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[0] > 0, XLAL_EINVAL );
UINT4 numFreqBinsMax, numFreqBinsMin;
numFreqBinsMin = numFreqBinsMax = uvar->numFreqBins->data[0];
if ( uvar->numFreqBins->length == 2 )
{
XLAL_CHECK ( uvar->numFreqBins->data[1] > 0, XLAL_EINVAL );
XLAL_CHECK ( uvar->numFreqBins->data[1] > uvar->numFreqBins->data[0], XLAL_EINVAL );
numFreqBinsMax = uvar->numFreqBins->data[1];
}
XLAL_CHECK ( uvar->numTrials >= 1, XLAL_EINVAL );
// ---------- end: handle user input ----------
// common setup over repeated trials
FstatMethodType FstatMethod;
XLAL_CHECK ( XLALParseFstatMethodString ( &FstatMethod, uvar->FstatMethod ) == XLAL_SUCCESS, XLAL_EFUNC );
EphemerisData *ephem;
XLAL_CHECK ( (ephem = XLALInitBarycenter ( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" )) != NULL, XLAL_EFUNC );
REAL8 memBase = XLALGetPeakHeapUsageMB();
UINT4 numDetectors = uvar->IFOs->length;
// ----- setup injection and data parameters
LIGOTimeGPS startTime = {711595934, 0};
LIGOTimeGPS startTime_l = startTime;
LIGOTimeGPS endTime_l;
SFTCatalog **catalogs;
XLAL_CHECK ( (catalogs = XLALCalloc ( uvar->numSegments, sizeof( catalogs[0] ))) != NULL, XLAL_ENOMEM );
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
endTime_l = startTime_l;
XLALGPSAdd( &endTime_l, uvar->Tseg );
MultiLIGOTimeGPSVector *multiTimestamps;
XLAL_CHECK ( (multiTimestamps = XLALMakeMultiTimestamps ( startTime_l, uvar->Tseg, uvar->Tsft, 0, numDetectors )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (catalogs[l] = XLALMultiAddToFakeSFTCatalog ( NULL, uvar->IFOs, multiTimestamps )) != NULL, XLAL_EFUNC );
XLALDestroyMultiTimestamps ( multiTimestamps );
startTime_l = endTime_l;
} // for l < numSegments
LIGOTimeGPS endTime = endTime_l;
UINT4 numSFTsPerSeg = catalogs[0]->length;
FILE *fpInfo = NULL;
if ( (uvar->outputInfo != NULL) && (FstatMethod == FMETHOD_RESAMP_GENERIC) )
{
XLAL_CHECK ( (fpInfo = fopen (uvar->outputInfo, "ab")) != NULL, XLAL_ESYS, "Failed to open '%s' for appending\n", uvar->outputInfo );
XLALAppendResampInfo2File ( fpInfo, NULL ); // create header comment line
}
PulsarSpinRange XLAL_INIT_DECL(spinRange);
LIGOTimeGPS refTime = { startTime.gpsSeconds - 2.3 * uvar->Tseg, 0 };
spinRange.refTime = refTime;
spinRange.fkdot[0] = uvar->Freq;
spinRange.fkdot[1] = uvar->f1dot;
spinRange.fkdotBand[1] = 0;
REAL8 asini = 0, Period = 0, ecc = 0;
REAL8 minCoverFreq, maxCoverFreq;
PulsarDopplerParams XLAL_INIT_DECL(Doppler);
Doppler.refTime = refTime;
Doppler.Alpha = 0.5;
Doppler.Delta = 0.5;
memcpy ( &Doppler.fkdot, &spinRange.fkdot, sizeof(Doppler.fkdot) );;
Doppler.period = Period;
Doppler.ecc = ecc;
Doppler.asini = asini;
// ----- setup optional Fstat arguments
FstatOptionalArgs optionalArgs = FstatOptionalArgsDefaults;
MultiNoiseFloor XLAL_INIT_DECL(injectSqrtSX);
injectSqrtSX.length = numDetectors;
for ( UINT4 X=0; X < numDetectors; X ++ ) {
injectSqrtSX.sqrtSn[X] = 1;
}
optionalArgs.injectSqrtSX = &injectSqrtSX;
optionalArgs.FstatMethod = FstatMethod;
FstatWorkspace *sharedWorkspace = NULL;
FstatInputVector *inputs;
FstatQuantities whatToCompute = (FSTATQ_2F | FSTATQ_2F_PER_DET);
FstatResults *results = NULL;
REAL8 tauF1NoBuf = 0;
REAL8 tauF1Buf = 0;
// ---------- main loop over repeated trials ----------
for ( INT4 i = 0; i < uvar->numTrials; i ++ )
{
// randomize numFreqBins
UINT4 numFreqBins_i = numFreqBinsMin + (UINT4)round ( 1.0 * (numFreqBinsMax - numFreqBinsMin) * rand() / RAND_MAX );
// randomize FreqResolution
REAL8 FreqResolution_i = FreqResolutionMin + 1.0 * ( FreqResolutionMax - FreqResolutionMin ) * rand() / RAND_MAX;
XLAL_CHECK ( (inputs = XLALCreateFstatInputVector ( uvar->numSegments )) != NULL, XLAL_EFUNC );
REAL8 dFreq = 1.0 / ( FreqResolution_i * uvar->Tseg );
REAL8 FreqBand = numFreqBins_i * dFreq;
fprintf ( stderr, "trial %d/%d: Tseg = %.1f d, numSegments = %d, Freq = %.1f Hz, f1dot = %.1e Hz/s, FreqResolution r = %f, numFreqBins = %d [dFreq = %.2e Hz, FreqBand = %.2e Hz]\n",
i+1, uvar->numTrials, uvar->Tseg / 86400.0, uvar->numSegments, uvar->Freq, uvar->f1dot, FreqResolution_i, numFreqBins_i, dFreq, FreqBand );
spinRange.fkdotBand[0] = FreqBand;
XLAL_CHECK ( XLALCWSignalCoveringBand ( &minCoverFreq, &maxCoverFreq, &startTime, &endTime, &spinRange, asini, Period, ecc ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numBinsSFT = ceil ( (maxCoverFreq - minCoverFreq) * uvar->Tsft + 2 * 8 );
REAL8 memSFTs = uvar->numSegments * numSFTsPerSeg * ( sizeof(SFTtype) + numBinsSFT * sizeof(COMPLEX8)) / 1e6;
// create per-segment input structs
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( (inputs->data[l] = XLALCreateFstatInput ( catalogs[l], minCoverFreq, maxCoverFreq, dFreq, ephem, &optionalArgs )) != NULL, XLAL_EFUNC );
if ( l == 0 ) {
sharedWorkspace = XLALGetSharedFstatWorkspace ( inputs->data[0] );
}
optionalArgs.sharedWorkspace = sharedWorkspace;
}
// ----- compute Fstatistics over segments
REAL8 tauF1NoBuf_i = 0;
REAL8 tauF1Buf_i = 0;
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLAL_CHECK ( XLALComputeFstat ( &results, inputs->data[l], &Doppler, numFreqBins_i, whatToCompute ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- output timing details if requested
if ( (fpInfo != NULL) ) {
XLALAppendResampInfo2File ( fpInfo, inputs->data[l] );
}
REAL8 tauF1NoBuf_il, tauF1Buf_il;
XLAL_CHECK ( XLALGetResampTimingInfo ( &tauF1NoBuf_il, &tauF1Buf_il, inputs->data[l] ) == XLAL_SUCCESS, XLAL_EFUNC );
tauF1NoBuf_i += tauF1NoBuf_il;
tauF1Buf_i += tauF1Buf_il;
} // for l < numSegments
tauF1NoBuf_i /= uvar->numSegments;
tauF1Buf_i /= uvar->numSegments;
REAL8 memMaxCompute = XLALGetPeakHeapUsageMB() - memBase;
tauF1Buf += tauF1Buf_i;
tauF1NoBuf += tauF1NoBuf_i;
fprintf (stderr, "%-15s: tauF1Buf = %.2g s, tauF1NoBuf = %.2g s, memSFTs = %.1f MB, memMaxCompute = %.1f MB\n",
XLALGetFstatMethodName ( FstatMethod ), tauF1Buf_i, tauF1NoBuf_i, memSFTs, memMaxCompute );
XLALDestroyFstatInputVector ( inputs );
XLALDestroyFstatWorkspace ( sharedWorkspace );
optionalArgs.sharedWorkspace = NULL;
} // for i < numTrials
tauF1Buf /= uvar->numTrials;
tauF1NoBuf /= uvar->numTrials;
fprintf (stderr, "\nAveraged timings: <tauF1Buf> = %.2g s, <tauF1NoBuf> = %.2g s\n", tauF1Buf, tauF1NoBuf );
// ----- free memory ----------
if ( fpInfo != NULL ) {
fclose ( fpInfo );
}
for ( INT4 l = 0; l < uvar->numSegments; l ++ )
{
XLALDestroySFTCatalog ( catalogs[l] );
}
XLALFree ( catalogs );
XLALDestroyFstatResults ( results );
XLALDestroyUserVars();
XLALDestroyEphemerisData ( ephem );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/** register all "user-variables" */
int
initUserVars (UserVariables_t *uvar)
{
/* set a few defaults */
uvar->help = FALSE;
uvar->ephemEarth = XLALStringDuplicate("earth00-19-DE405.dat.gz");
uvar->ephemSun = XLALStringDuplicate("sun00-19-DE405.dat.gz");
uvar->Freq = 100;
uvar->f1dot = 0.0;
uvar->f2dot = 0.0;
uvar->f3dot = 0.0;
uvar->h0 = 1;
uvar->phi0 = 0;
uvar->startTime.gpsSeconds = 714180733;
uvar->duration = 10 * 3600;
uvar->Nseg = 1;
uvar->segmentList = NULL;
uvar->refTime.gpsSeconds = -1; /* default: use mid-time */
uvar->projection = 0;
if ( (uvar->IFOs = XLALCreateStringVector ( "H1", NULL )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Call to XLALCreateStringVector() failed with xlalErrno = %d\n", xlalErrno );
XLAL_ERROR ( XLAL_ENOMEM );
}
uvar->sqrtSX = NULL;
uvar->detMotionStr = XLALStringDuplicate(XLALDetectorMotionName(DETMOTION_SPIN | DETMOTION_ORBIT));
uvar->metricType = 0; /* by default: compute only phase metric */
if ( (uvar->coords = XLALCreateStringVector ( "freq", "alpha", "delta", "f1dot", NULL )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Call to XLALCreateStringVector() failed with xlalErrno = %d\n", xlalErrno );
XLAL_ERROR ( XLAL_ENOMEM );
}
uvar->approxPhase = FALSE;
/* register all our user-variables */
XLALRegisterUvarMember(help, BOOLEAN, 'h', HELP, "Print this help/usage message");
XLALRegisterUvarMember(IFOs, STRINGVector, 'I', OPTIONAL, "CSV list of detectors, eg. \"H1,H2,L1,G1, ...\" ");
XLALRegisterUvarMember(sqrtSX, STRINGVector, 0, OPTIONAL, "[for F-metric weights] CSV list of detectors' noise-floors sqrt{Sn}");
XLALRegisterUvarMember(Alpha, RAJ, 'a', OPTIONAL, "Sky: equatorial J2000 right ascension (in radians or hours:minutes:seconds)");
XLALRegisterUvarMember(Delta, DECJ, 'd', OPTIONAL, "Sky: equatorial J2000 declination (in radians or degrees:minutes:seconds)");
XLALRegisterUvarMember(Freq, REAL8, 'f', OPTIONAL, "Target frequency");
XLALRegisterUvarMember(f1dot, REAL8, 's', OPTIONAL, "First spindown-value df/dt");
XLALRegisterUvarMember(f2dot, REAL8, 0 , OPTIONAL, "Second spindown-value d2f/dt2");
XLALRegisterUvarMember(f3dot, REAL8, 0 , OPTIONAL, "Third spindown-value d3f/dt3");
XLALRegisterUvarMember ( orbitasini, REAL8, 0, OPTIONAL, "Target projected semimajor axis of binary orbit (Units: light seconds)");
XLALRegisterUvarMember ( orbitPeriod, REAL8, 0, OPTIONAL, "Target period of binary orbit (Units: s).");
XLALRegisterUvarMember ( orbitTp, EPOCH, 0, OPTIONAL, "Target time of periapse passage of the CW source in a binary orbit (Units: GPS seconds)");
XLALRegisterUvarMember ( orbitArgp, REAL8, 0, OPTIONAL, "Target argument of periapse of binary orbit (Units: rad)");
XLALRegisterUvarMember ( orbitEcc, REAL8, 0, OPTIONAL, "Target eccentricity of binary orbit (Units: none)");
XLALRegisterUvarMember(refTime, EPOCH, 0, OPTIONAL, "Reference epoch for phase-evolution parameters (format 'xx.yy[GPS|MJD]'). [0=startTime, default=mid-time]");
XLALRegisterUvarMember(startTime, EPOCH, 't', OPTIONAL, "Start time of observation (format 'xx.yy[GPS|MJD]')");
XLALRegisterUvarMember(duration, REAL8, 'T', OPTIONAL, "Duration of observation in seconds");
XLALRegisterUvarMember(Nseg, INT4, 'N', OPTIONAL, "Compute semi-coherent metric for this number of segments within 'duration'" );
XLALRegisterUvarMember(segmentList, STRING, 0, OPTIONAL, "ALTERNATIVE: specify segment file with format: repeated lines <startGPS endGPS duration[h] NumSFTs>");
XLALRegisterUvarMember( ephemEarth, STRING, 0, OPTIONAL, "Earth ephemeris file to use");
XLALRegisterUvarMember( ephemSun, STRING, 0, OPTIONAL, "Sun ephemeris file to use");
XLALRegisterUvarMember(h0, REAL8, 0, OPTIONAL, "GW amplitude h0" );
XLALRegisterUvarMember(cosi, REAL8, 0, OPTIONAL, "Pulsar orientation-angle cos(iota) [-1,1]" );
XLALRegisterUvarMember(psi, REAL8, 0, OPTIONAL, "Wave polarization-angle psi [0, pi]" );
XLALRegisterUvarMember(phi0, REAL8, 0, OPTIONAL, "GW initial phase phi_0 [0, 2pi]" );
XLALRegisterUvarMember(metricType, INT4, 0, OPTIONAL, "type of metric to compute: 0=phase-metric, 1=F-metric(s), 2=both" );
XLALRegisterUvarMember(outputMetric, STRING, 'o', OPTIONAL, "Output the metric components (in octave format) into this file.");
XLALRegisterUvarMember(projection, INT4, 0, OPTIONAL, "Project onto subspace orthogonal to this axis: 0=none, 1=1st-coord, 2=2nd-coord etc");
XLALRegisterUvarMember(coords, STRINGVector, 'c', OPTIONAL, "Doppler-coordinates to compute metric in (see --coordsHelp)");
XLALRegisterUvarMember(coordsHelp, BOOLEAN, 0, OPTIONAL, "output help-string explaining all the possible Doppler-coordinate names for --coords");
XLALRegisterUvarMember(detMotionStr, STRING, 0, DEVELOPER, "Detector-motion string: S|O|S+O where S=spin|spinz|spinxy and O=orbit|ptoleorbit");
XLALRegisterUvarMember(approxPhase, BOOLEAN, 0, DEVELOPER, "Use an approximate phase-model, neglecting Roemer delay in spindown coordinates (or orders >= 1)");
XLALRegisterUvarMember(version, BOOLEAN, 'V', SPECIAL, "Output code version");
return XLAL_SUCCESS;
} /* initUserVars() */
// ---------- main ----------
int
main ( int argc, char *argv[] )
{
XLAL_CHECK ( argc == 1, XLAL_EINVAL, "No input arguments allowed.\n" );
XLAL_CHECK ( argv != NULL, XLAL_EINVAL );
// ----- load ephemeris
EphemerisData *ephem;
XLAL_CHECK ( (ephem = XLALInitBarycenter ( TEST_DATA_DIR "earth00-19-DE405.dat.gz", TEST_DATA_DIR "sun00-19-DE405.dat.gz" )) != NULL, XLAL_EFUNC );
// ----- setup injection and data parameters
LALStringVector *detNames = NULL;
XLAL_CHECK ( (detNames = XLALCreateStringVector ( "H1", "L1", NULL )) != NULL, XLAL_EFUNC );
UINT4 numDetectors = detNames->length;
// generate and assume some gaussian noise floors
MultiNoiseFloor XLAL_INIT_DECL(injectSqrtSX);
MultiNoiseFloor XLAL_INIT_DECL(assumeSqrtSX);
injectSqrtSX.length = numDetectors;
assumeSqrtSX.length = numDetectors;
for ( UINT4 X = 0; X < numDetectors; X ++ )
{
injectSqrtSX.sqrtSn[X] = 0; // don't inject random noise to keep errors deterministic and informative (resampling differs much more on noise)
assumeSqrtSX.sqrtSn[X] = 1.0 + 2.0*X;
}
LIGOTimeGPS startTime = {711595934, 0};
REAL8 Tspan = 20 * 3600;
LIGOTimeGPS endTime = startTime;
XLALGPSAdd( &endTime, Tspan );
REAL8 Tsft = 1800;
LIGOTimeGPS refTime = { startTime.gpsSeconds - 2.3 * Tspan, 0 };
MultiLIGOTimeGPSVector *multiTimestamps;
XLAL_CHECK ( ( multiTimestamps = XLALCalloc ( 1, sizeof(*multiTimestamps))) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( ( multiTimestamps->data = XLALCalloc ( numDetectors, sizeof(multiTimestamps->data[0]) )) != NULL, XLAL_ENOMEM );
multiTimestamps->length = numDetectors;
LIGOTimeGPS startTimeX = startTime;
for ( UINT4 X=0; X < numDetectors; X ++ )
{
XLAL_CHECK ( (multiTimestamps->data[X] = XLALMakeTimestamps ( startTimeX, Tspan, Tsft, 0 ) ) != NULL, XLAL_EFUNC );
XLALGPSAdd ( &startTimeX, 0.5 * Tspan ); // shift start-times by 1/2 Tspan for each detector
Tspan *= 2.0;
} // for X < numDetectors
// shift a few timestamps around to create gaps
UINT4 numSFTsPerDet = multiTimestamps->data[0]->length;
multiTimestamps->data[0]->data[numSFTsPerDet-1].gpsSeconds += 10000;
multiTimestamps->data[0]->data[numSFTsPerDet-2].gpsSeconds += 5000;
multiTimestamps->data[1]->data[0].gpsSeconds -= 10000;
multiTimestamps->data[1]->data[1].gpsSeconds -= 5000;
SFTCatalog *catalog;
XLAL_CHECK ( (catalog = XLALMultiAddToFakeSFTCatalog ( NULL, detNames, multiTimestamps )) != NULL, XLAL_EFUNC );
// ----- CW sources to injet ----------
REAL8 Freq = 100.0;
PulsarParamsVector *injectSources;
XLAL_CHECK ( (injectSources = XLALCreatePulsarParamsVector(1)) != NULL, XLAL_EFUNC );
injectSources->data[0].Amp.h0 = 1;
injectSources->data[0].Amp.cosi = 0.5;
injectSources->data[0].Amp.psi = 0.1;
injectSources->data[0].Amp.phi0 = 1.2;
REAL8 asini = 0; // 1.4; // sco-X1 like
REAL8 Period = 0; // 19 * 3600;// sco-X1 like
REAL8 ecc = 0; // 0.1; // much larger than ScoX1
PulsarDopplerParams XLAL_INIT_DECL(Doppler);
Doppler.Alpha = 0.5;
Doppler.Delta = -0.5;
Doppler.fkdot[0] = Freq;
Doppler.fkdot[1] = -1e-9;
Doppler.refTime = refTime;
Doppler.asini = asini;
Doppler.ecc = ecc;
Doppler.tp = startTime;
Doppler.period = Period;
Doppler.argp = 0.5;
injectSources->data[0].Doppler = Doppler;
REAL8 dFreq = 0.1 / Tspan; // 10x finer than native FFT resolution
REAL8 mis = 0.5;
REAL8 df1dot = sqrt( 720.0 * mis ) / (LAL_PI * Tspan * Tspan); // metric (f-projected) stepsize for given mismatch mis
REAL8 dSky = 1e4 / (Freq * Tspan); // rough estimate of a 'metric' sky step, eg. Eq.(118) in \cite Prix07
REAL8 dPeriod = 3600;
UINT4 numFreqBins = 1000;
UINT4 numf1dotPoints = 2;
UINT4 numSkyPoints = 2;
UINT4 numPeriodPoints = 2;
PulsarSpinRange XLAL_INIT_DECL(spinRange);
spinRange.refTime = refTime;
memcpy ( &spinRange.fkdot, &injectSources->data[0].Doppler.fkdot, sizeof(spinRange.fkdot) );
spinRange.fkdotBand[0] = (numFreqBins - 1)*dFreq - 10*LAL_REAL8_EPS;
spinRange.fkdotBand[1] = (numf1dotPoints - 1)*df1dot - 10*LAL_REAL8_EPS;
Doppler.fkdot[0] -= 0.4 * spinRange.fkdotBand[0];
REAL8 minCoverFreq, maxCoverFreq;
XLAL_CHECK ( XLALCWSignalCoveringBand ( &minCoverFreq, &maxCoverFreq, &startTime, &endTime, &spinRange, asini, Period, ecc ) == XLAL_SUCCESS, XLAL_EFUNC );
// ----- setup optional Fstat arguments
FstatOptionalArgs optionalArgs = FstatOptionalArgsDefaults;
optionalArgs.injectSources = injectSources;
optionalArgs.injectSqrtSX = &injectSqrtSX;
optionalArgs.assumeSqrtSX = &assumeSqrtSX;
// ----- prepare input data with injection for all available methods
FstatInput *input[FMETHOD_END];
FstatResults *results[FMETHOD_END];
for ( UINT4 iMethod = FMETHOD_START; iMethod < FMETHOD_END; iMethod ++ )
{
results[iMethod] = NULL;
if ( !XLALFstatMethodIsAvailable(iMethod) ) {
continue;
}
optionalArgs.FstatMethod = iMethod;
XLAL_CHECK ( (input[iMethod] = XLALCreateFstatInput ( catalog, minCoverFreq, maxCoverFreq, dFreq, ephem, &optionalArgs )) != NULL, XLAL_EFUNC );
}
FstatQuantities whatToCompute = (FSTATQ_2F | FSTATQ_FAFB);
// ----- loop over all templates {sky, f1dot, period}
for ( UINT4 iSky = 0; iSky < numSkyPoints; iSky ++ )
{
for ( UINT4 if1dot = 0; if1dot < numf1dotPoints; if1dot ++ )
{
for ( UINT4 iPeriod = 0; iPeriod < numPeriodPoints; iPeriod ++ )
{
// ----- loop over all available methods and compare Fstat results
FstatMethodType firstMethod = FMETHOD_START;
for ( UINT4 iMethod = FMETHOD_START; iMethod < FMETHOD_END; iMethod ++ )
{
if ( !XLALFstatMethodIsAvailable(iMethod) ) {
continue;
}
if ( firstMethod == FMETHOD_START ) { // keep track of first available method found
firstMethod = iMethod;
}
XLAL_CHECK ( XLALComputeFstat ( &results[iMethod], input[iMethod], &Doppler, numFreqBins, whatToCompute ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( lalDebugLevel & LALINFOBIT )
{
FILE *fp;
char fname[1024]; XLAL_INIT_MEM ( fname );
snprintf ( fname, sizeof(fname)-1, "twoF%s-iSky%02d-if1dot%02d-iPeriod%02d.dat", XLALGetFstatMethodName(iMethod), iSky, if1dot, iPeriod );
XLAL_CHECK ( (fp = fopen ( fname, "wb" )) != NULL, XLAL_EFUNC );
for ( UINT4 k = 0; k < results[iMethod]->numFreqBins; k ++ )
{
REAL8 Freq0 = results[iMethod]->doppler.fkdot[0];
REAL8 Freq_k = Freq0 + k * results[iMethod]->dFreq;
if ( whatToCompute & FSTATQ_FAFB ) {
fprintf ( fp, "%20.16g %10.4g %10.4g %10.4g %10.4g %10.4g\n",
Freq_k, results[iMethod]->twoF[k],
crealf(results[iMethod]->Fa[k]), cimagf(results[iMethod]->Fa[k]),
crealf(results[iMethod]->Fb[k]), cimagf(results[iMethod]->Fb[k])
);
} else {
fprintf ( fp, "%20.16g %10.4g\n",
Freq_k, results[iMethod]->twoF[k] );
}
} // for k < numFreqBins
fclose(fp);
} // if info
// compare to first result
if ( iMethod != firstMethod )
{
XLALPrintInfo ("Comparing results between method '%s' and '%s'\n", XLALGetFstatMethodName(firstMethod), XLALGetFstatMethodName(iMethod) );
if ( compareFstatResults ( results[firstMethod], results[iMethod] ) != XLAL_SUCCESS )
{
XLALPrintError ("Comparison between method '%s' and '%s' failed\n", XLALGetFstatMethodName(firstMethod), XLALGetFstatMethodName(iMethod) );
XLAL_ERROR ( XLAL_EFUNC );
}
}
} // for i < FMETHOD_END
Doppler.period += dPeriod;
} // for iPeriod < numPeriodPoints
Doppler.fkdot[1] += df1dot;
} // for if1dot < numf1dotPoints
Doppler.Alpha += dSky;
} // for iSky < numSkyPoints
// free remaining memory
for ( UINT4 iMethod=FMETHOD_START; iMethod < FMETHOD_END; iMethod ++ )
{
if ( !XLALFstatMethodIsAvailable(iMethod) ) {
continue;
}
XLALDestroyFstatInput ( input[iMethod] );
XLALDestroyFstatResults ( results[iMethod] );
} // for i < FMETHOD_END
XLALDestroyPulsarParamsVector ( injectSources );
XLALDestroySFTCatalog ( catalog );
XLALDestroyMultiTimestamps ( multiTimestamps );
XLALDestroyStringVector ( detNames );
XLALDestroyEphemerisData ( ephem );
LALCheckMemoryLeaks();
return XLAL_SUCCESS;
} // main()
/**
* Unit test for metric functions XLALComputeDopplerPhaseMetric()
* and XLALComputeDopplerFstatMetric()
*
* Initially modelled afer testMetricCodes.py script:
* Check metric codes 'getMetric' 'FstatMetric' and 'FstatMetric_v2' by
* comparing them against each other.
* Given that they represent 3 very different implementations of
* metric calculations, this provides a very powerful consistency test
*
*/
static int
test_XLALComputeDopplerMetrics ( void )
{
int ret;
const REAL8 tolPh = 0.01; // 1% tolerance on phase metrics [taken from testMetricCodes.py]
// ----- load ephemeris
const char earthEphem[] = TEST_DATA_DIR "earth00-19-DE200.dat.gz";
const char sunEphem[] = TEST_DATA_DIR "sun00-19-DE200.dat.gz";
EphemerisData *edat = XLALInitBarycenter ( earthEphem, sunEphem );
XLAL_CHECK ( edat != NULL, XLAL_EFUNC, "XLALInitBarycenter('%s','%s') failed with xlalErrno = %d\n", earthEphem, sunEphem, xlalErrno );
// ----- set test-parameters ----------
const LIGOTimeGPS startTimeGPS = { 792576013, 0 };
const REAL8 Tseg = 60000;
const REAL8 Alpha = 1.0;
const REAL8 Delta = 0.5;
const REAL8 Freq = 100;
const REAL8 f1dot = 0;// -1e-8;
LALStringVector *detNames = XLALCreateStringVector ( "H1", "L1", "V1", NULL );
LALStringVector *sqrtSX = XLALCreateStringVector ( "1.0", "0.5", "1.5", NULL );
MultiLALDetector multiIFO;
XLAL_CHECK ( XLALParseMultiLALDetector ( &multiIFO, detNames ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyStringVector ( detNames );
MultiNoiseFloor multiNoiseFloor;
XLAL_CHECK ( XLALParseMultiNoiseFloor ( &multiNoiseFloor, sqrtSX, multiIFO.length ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyStringVector ( sqrtSX );
// prepare metric parameters for modern XLALComputeDopplerFstatMetric() and mid-old XLALOldDopplerFstatMetric()
const DopplerCoordinateSystem coordSys = { 4, { DOPPLERCOORD_FREQ, DOPPLERCOORD_ALPHA, DOPPLERCOORD_DELTA, DOPPLERCOORD_F1DOT } };
const PulsarAmplitudeParams Amp = { 0.03, -0.3, 0.5, 0.0 }; // h0, cosi, psi, phi0
const PulsarDopplerParams dop = {
.refTime = startTimeGPS,
.Alpha = Alpha,
.Delta = Delta,
.fkdot = { Freq, f1dot },
};
LALSegList XLAL_INIT_DECL(segList);
ret = XLALSegListInitSimpleSegments ( &segList, startTimeGPS, 1, Tseg );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALSegListInitSimpleSegments() failed with xlalErrno = %d\n", xlalErrno );
const DopplerMetricParams master_pars2 = {
.coordSys = coordSys,
.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT,
.segmentList = segList,
.multiIFO = multiIFO,
.multiNoiseFloor = multiNoiseFloor,
.signalParams = { .Amp = Amp, .Doppler = dop },
.projectCoord = - 1, // -1==no projection
.approxPhase = 0,
};
// ========== BEGINNING OF TEST CALLS ==========
XLALPrintWarning("\n---------- ROUND 1: ephemeris-based, single-IFO phase metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.multiIFO.length = 1; // truncate to first detector
pars2.multiNoiseFloor.length = 1; // truncate to first detector
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
XLAL_CHECK ( (metric1 = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_PHASE, &pars2, edat )) != NULL, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
// compare metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2P->g_ij, metric1->g_ij )) < tolPh, XLAL_ETOL, "Error(g2,g1)= %g exceeds tolerance of %g\n", diff_2_1, tolPh );
XLALPrintWarning ("diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
}
XLALPrintWarning("\n---------- ROUND 2: Ptolemaic-based, single-IFO phase metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.multiIFO.length = 1; // truncate to first detector
pars2.multiNoiseFloor.length = 1; // truncate to first detector
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_PTOLEORBIT;
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
XLAL_CHECK ( (metric1 = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_PHASE, &pars2, edat )) != NULL, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
// compare all 3 metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2P->g_ij, metric1->g_ij )) < tolPh, XLAL_ETOL, "Error(g2,g1)= %g exceeds tolerance of %g\n", diff_2_1, tolPh );
XLALPrintWarning ("diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
}
XLALPrintWarning("\n---------- ROUND 3: ephemeris-based, multi-IFO F-stat metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerFstatMetric *metric2F;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT;
pars2.multiIFO = multiIFO; // 3 IFOs
pars2.multiNoiseFloor = multiNoiseFloor;// 3 IFOs
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
XLAL_CHECK ( (metric1 = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_FSTAT, &pars2, edat )) != NULL, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2F = XLALComputeDopplerFstatMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
// compare both metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2F->gF_ij, metric1->gF_ij )) < tolPh, XLAL_ETOL, "Error(gF2,gF1)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("gF: diff_2_1 = %e\n", diff_2_1 );
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2F->gFav_ij, metric1->gFav_ij )) < tolPh, XLAL_ETOL, "Error(gFav2,gFav1)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("gFav: diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerFstatMetric ( metric2F );
}
XLALPrintWarning("\n---------- ROUND 4: compare analytic {f,f1dot,f2dot,f3dot} phase metric vs XLALComputeDopplerPhaseMetric() ----------\n");
{
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.multiIFO.length = 1; // truncate to 1st detector
pars2.multiNoiseFloor.length = 1; // truncate to 1st detector
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT;
pars2.approxPhase = 1; // use same phase-approximation as in analytic solution to improve comparison
DopplerCoordinateSystem coordSys2 = { 4, { DOPPLERCOORD_FREQ, DOPPLERCOORD_F1DOT, DOPPLERCOORD_F2DOT, DOPPLERCOORD_F3DOT } };
pars2.coordSys = coordSys2;
gsl_matrix* gN_ij;
// a) compute metric at refTime = startTime
pars2.signalParams.Doppler.refTime = startTimeGPS;
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
gN_ij = NULL;
XLAL_CHECK ( XLALNaturalizeMetric ( &gN_ij, NULL, metric2P->g_ij, &pars2 ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 gStart_ij[] = { 1.0/3, 2.0/3, 6.0/5, 32.0/15, \
2.0/3, 64.0/45, 8.0/3, 512.0/105, \
6.0/5, 8.0/3, 36.0/7, 48.0/5, \
32.0/15, 512.0/105, 48.0/5, 4096.0/225 };
const gsl_matrix_view gStart = gsl_matrix_view_array ( gStart_ij, 4, 4 );
// compare natural-units metric against analytic solution
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( gN_ij, &(gStart.matrix) )) < tolPh, XLAL_ETOL,
"RefTime=StartTime: Error(g_ij,g_analytic)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("Analytic (refTime=startTime): diff_2_1 = %e\n", diff_2_1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
gsl_matrix_free ( gN_ij );
// b) compute metric at refTime = midTime
pars2.signalParams.Doppler.refTime = startTimeGPS;
pars2.signalParams.Doppler.refTime.gpsSeconds += Tseg / 2;
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
gN_ij = NULL;
XLAL_CHECK ( XLALNaturalizeMetric ( &gN_ij, NULL, metric2P->g_ij, &pars2 ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 gMid_ij[] = { 1.0/3, 0, 1.0/5, 0, \
0, 4.0/45, 0, 8.0/105, \
1.0/5, 0, 1.0/7, 0, \
0, 8.0/105, 0, 16.0/225 };
const gsl_matrix_view gMid = gsl_matrix_view_array ( gMid_ij, 4, 4 );
// compare natural-units metric against analytic solution
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( gN_ij, &(gMid.matrix) )) < tolPh, XLAL_ETOL,
"RefTime=MidTime: Error(g_ij,g_analytic)= %e exceeds tolerance of %e\n", diff_2_1, tolPh );
XLALPrintWarning ("Analytic (refTime=midTime): diff_2_1 = %e\n\n", diff_2_1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
gsl_matrix_free ( gN_ij );
}
XLALPrintWarning("\n---------- ROUND 5: ephemeris-based, single-IFO, segment-averaged phase metrics ----------\n");
{
OldDopplerMetric *metric1;
DopplerPhaseMetric *metric2P;
REAL8 diff_2_1;
DopplerMetricParams pars2 = master_pars2;
pars2.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT;
pars2.multiIFO.length = 1; // truncate to first detector
pars2.multiNoiseFloor.length = 1; // truncate to first detector
pars2.approxPhase = 1;
const UINT4 Nseg = 10;
LALSegList XLAL_INIT_DECL(NsegList);
ret = XLALSegListInitSimpleSegments ( &NsegList, startTimeGPS, Nseg, Tseg );
XLAL_CHECK ( ret == XLAL_SUCCESS, XLAL_EFUNC, "XLALSegListInitSimpleSegments() failed with xlalErrno = %d\n", xlalErrno );
pars2.segmentList = NsegList;
LALSegList XLAL_INIT_DECL(segList_k);
LALSeg segment_k;
XLALSegListInit( &segList_k ); // prepare single-segment list containing segment k
segList_k.arraySize = 1;
segList_k.length = 1;
segList_k.segs = &segment_k;
// 1) compute metric using old FstatMetric code, now wrapped into XLALOldDopplerFstatMetric()
metric1 = NULL;
for (UINT4 k = 0; k < Nseg; ++k) {
// setup 1-segment segment-list pointing k-th segment
DopplerMetricParams pars2_k = pars2;
pars2_k.segmentList = segList_k;
pars2_k.segmentList.segs[0] = pars2.segmentList.segs[k];
// XLALOldDopplerFstatMetric() does not agree numerically with UniversalDopplerMetric when using refTime != startTime
pars2_k.signalParams.Doppler.refTime = pars2_k.segmentList.segs[0].start;
OldDopplerMetric *metric1_k; // per-segment coherent metric
XLAL_CHECK ( (metric1_k = XLALOldDopplerFstatMetric ( OLDMETRIC_TYPE_PHASE, &pars2_k, edat )) != NULL, XLAL_EFUNC );
// manually correct reference time of metric1_k->g_ij; see Prix, "Frequency metric for CW searches" (2014-08-17), p. 4
const double dt = XLALGPSDiff( &(pars2_k.signalParams.Doppler.refTime), &(pars2.signalParams.Doppler.refTime) );
const double gFF = gsl_matrix_get( metric1_k->g_ij, 0, 0 );
const double gFA = gsl_matrix_get( metric1_k->g_ij, 0, 1 );
const double gFD = gsl_matrix_get( metric1_k->g_ij, 0, 2 );
const double gFf = gsl_matrix_get( metric1_k->g_ij, 0, 3 );
const double gAf = gsl_matrix_get( metric1_k->g_ij, 1, 3 );
const double gDf = gsl_matrix_get( metric1_k->g_ij, 2, 3 );
const double gff = gsl_matrix_get( metric1_k->g_ij, 3, 3 );
gsl_matrix_set( metric1_k->g_ij, 0, 3, gFf + gFF*dt ); gsl_matrix_set( metric1_k->g_ij, 3, 0, gsl_matrix_get( metric1_k->g_ij, 0, 3 ) );
gsl_matrix_set( metric1_k->g_ij, 1, 3, gAf + gFA*dt ); gsl_matrix_set( metric1_k->g_ij, 3, 1, gsl_matrix_get( metric1_k->g_ij, 1, 3 ) );
gsl_matrix_set( metric1_k->g_ij, 2, 3, gDf + gFD*dt ); gsl_matrix_set( metric1_k->g_ij, 3, 2, gsl_matrix_get( metric1_k->g_ij, 2, 3 ) );
gsl_matrix_set( metric1_k->g_ij, 3, 3, gff + 2*gFf*dt + gFF*dt*dt );
XLAL_CHECK ( XLALAddOldDopplerMetric ( &metric1, metric1_k ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyOldDopplerMetric ( metric1_k );
}
XLAL_CHECK ( XLALScaleOldDopplerMetric ( metric1, 1.0 / Nseg ) == XLAL_SUCCESS, XLAL_EFUNC );
// 2) compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
XLAL_CHECK ( (metric2P = XLALComputeDopplerPhaseMetric ( &pars2, edat )) != NULL, XLAL_EFUNC );
GPMAT( metric1->g_ij, "%0.4e" );
GPMAT( metric2P->g_ij, "%0.4e" );
// compare both metrics against each other:
XLAL_CHECK ( (diff_2_1 = XLALCompareMetrics ( metric2P->g_ij, metric1->g_ij )) < tolPh, XLAL_ETOL, "Error(g2,g1)= %g exceeds tolerance of %g\n", diff_2_1, tolPh );
XLALPrintWarning ("diff_2_1 = %e\n", diff_2_1 );
XLALDestroyOldDopplerMetric ( metric1 );
XLALDestroyDopplerPhaseMetric ( metric2P );
XLALSegListClear ( &NsegList );
}
XLALPrintWarning("\n---------- ROUND 6: directed binary orbital metric ----------\n");
{
REAL8 Period = 68023.70496;
REAL8 Omega = LAL_TWOPI / Period;
REAL8 asini = 1.44;
REAL8 tAsc = 897753994;
REAL8 argp = 0;
LIGOTimeGPS tP; XLALGPSSetREAL8 ( &tP, tAsc + argp / Omega );
const PulsarDopplerParams dopScoX1 = {
.refTime = startTimeGPS,
.Alpha = Alpha,
.Delta = Delta,
.fkdot = { Freq },
.asini = asini,
.period = Period,
.tp = tP
};
REAL8 TspanScoX1 = 20 * 19 * 3600; // 20xPorb for long-segment regime
LALSegList XLAL_INIT_DECL(segListScoX1);
XLAL_CHECK ( XLALSegListInitSimpleSegments ( &segListScoX1, startTimeGPS, 1, TspanScoX1 ) == XLAL_SUCCESS, XLAL_EFUNC );
REAL8 tMid = XLALGPSGetREAL8(&startTimeGPS) + 0.5 * TspanScoX1;
REAL8 DeltaMidAsc = tMid - tAsc;
const DopplerCoordinateSystem coordSysScoX1 = { 6, { DOPPLERCOORD_FREQ, DOPPLERCOORD_ASINI, DOPPLERCOORD_TASC, DOPPLERCOORD_PORB, DOPPLERCOORD_KAPPA, DOPPLERCOORD_ETA } };
DopplerMetricParams pars_ScoX1 = {
.coordSys = coordSysScoX1,
.detMotionType = DETMOTION_SPIN | DETMOTION_ORBIT,
.segmentList = segListScoX1,
.multiIFO = multiIFO,
.multiNoiseFloor = multiNoiseFloor,
.signalParams = { .Amp = Amp, .Doppler = dopScoX1 },
.projectCoord = - 1, // -1==no projection
.approxPhase = 1,
};
pars_ScoX1.multiIFO.length = 1; // truncate to first detector
pars_ScoX1.multiNoiseFloor.length = 1; // truncate to first detector
// compute metric using modern UniversalDopplerMetric module: (used in lalapps_FstatMetric_v2)
DopplerPhaseMetric *metric_ScoX1;
XLAL_CHECK ( (metric_ScoX1 = XLALComputeDopplerPhaseMetric ( &pars_ScoX1, edat )) != NULL, XLAL_EFUNC );
// compute analytic metric computed from Eq.(47) in Leaci,Prix PRD91, 102003 (2015):
gsl_matrix *g0_ij;
XLAL_CHECK ( (g0_ij = gsl_matrix_calloc ( 6, 6 )) != NULL, XLAL_ENOMEM, "Failed to gsl_calloc a 6x6 matrix\n");
gsl_matrix_set ( g0_ij, 0, 0, pow ( LAL_PI * TspanScoX1, 2 ) / 3.0 );
gsl_matrix_set ( g0_ij, 1, 1, 2.0 * pow ( LAL_PI * Freq, 2 ) );
gsl_matrix_set ( g0_ij, 2, 2, 2.0 * pow ( LAL_PI * Freq * asini * Omega, 2 ) );
gsl_matrix_set ( g0_ij, 3, 3, 0.5 * pow ( Omega, 4 ) * pow ( Freq * asini, 2 ) * ( pow ( TspanScoX1, 2 ) / 12.0 + pow ( DeltaMidAsc, 2 ) ) );
REAL8 gPAsc = LAL_PI * pow ( Freq * asini, 2 ) * pow ( Omega, 3 ) * DeltaMidAsc;
gsl_matrix_set ( g0_ij, 2, 3, gPAsc );
gsl_matrix_set ( g0_ij, 3, 2, gPAsc );
gsl_matrix_set ( g0_ij, 4, 4, 0.5 * pow ( LAL_PI * Freq * asini, 2 ) );
gsl_matrix_set ( g0_ij, 5, 5, 0.5 * pow ( LAL_PI * Freq * asini, 2 ) );
GPMAT ( metric_ScoX1->g_ij, "%0.4e" );
GPMAT ( g0_ij, "%0.4e" );
// compare metrics against each other
REAL8 diff, tolScoX1 = 0.05;
XLAL_CHECK ( (diff = XLALCompareMetrics ( metric_ScoX1->g_ij, g0_ij )) < tolScoX1, XLAL_ETOL, "Error(gNum,gAn)= %g exceeds tolerance of %g\n", diff, tolScoX1 );
XLALPrintWarning ("diff_Num_An = %e\n", diff );
gsl_matrix_free ( g0_ij );
XLALDestroyDopplerPhaseMetric ( metric_ScoX1 );
XLALSegListClear ( &segListScoX1 );
}
