/** Destructor for internal configuration struct */
int
XLALDestroyConfig ( ConfigVariables *cfg )
{
if ( !cfg ) {
LogPrintf (LOG_CRITICAL, "%s: invalid NULL input!\n\n", __func__ );
XLAL_ERROR (XLAL_EINVAL );
}
XLALDestroyUserVars ();
XLALDestroyResultHistory ( cfg->history );
XLALDestroyEphemerisData ( cfg->edat );
XLALSegListClear ( &(cfg->segmentList) );
return XLAL_SUCCESS;
} /* XLALDestroyConfig() */
static int SuperskyTest(
const double T,
const double max_mismatch,
const char *lattice_name,
const UINT8 patch_count,
const double freq,
const double freqband,
const UINT8 total_ref,
const double mism_hist_ref[MISM_HIST_BINS]
)
{
// Create lattice tiling
LatticeTiling *tiling = XLALCreateLatticeTiling(3);
XLAL_CHECK(tiling != NULL, XLAL_EFUNC);
// Compute reduced supersky metric
const double Tspan = T * 86400;
LIGOTimeGPS ref_time;
XLALGPSSetREAL8(&ref_time, 900100100);
LALSegList segments;
{
XLAL_CHECK(XLALSegListInit(&segments) == XLAL_SUCCESS, XLAL_EFUNC);
LALSeg segment;
LIGOTimeGPS start_time = ref_time, end_time = ref_time;
XLALGPSAdd(&start_time, -0.5 * Tspan);
XLALGPSAdd(&end_time, 0.5 * Tspan);
XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC);
}
MultiLALDetector detectors = {
.length = 1,
.sites = { lalCachedDetectors[LAL_LLO_4K_DETECTOR] }
};
EphemerisData *edat = XLALInitBarycenter(TEST_DATA_DIR "earth00-19-DE405.dat.gz",
TEST_DATA_DIR "sun00-19-DE405.dat.gz");
XLAL_CHECK(edat != NULL, XLAL_EFUNC);
SuperskyMetrics *metrics = XLALComputeSuperskyMetrics(0, &ref_time, &segments, freq, &detectors, NULL, DETMOTION_SPIN | DETMOTION_PTOLEORBIT, edat);
XLAL_CHECK(metrics != NULL, XLAL_EFUNC);
gsl_matrix *rssky_metric = metrics->semi_rssky_metric, *rssky_transf = metrics->semi_rssky_transf;
metrics->semi_rssky_metric = metrics->semi_rssky_transf = NULL;
XLALDestroySuperskyMetrics(metrics);
XLALSegListClear(&segments);
XLALDestroyEphemerisData(edat);
// Add bounds
printf("Bounds: supersky, sky patch 0/%" LAL_UINT8_FORMAT ", freq=%0.3g, freqband=%0.3g\n", patch_count, freq, freqband);
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSkyPatch(tiling, rssky_metric, rssky_transf, patch_count, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(tiling, rssky_transf, 0, freq, freq + freqband) == XLAL_SUCCESS, XLAL_EFUNC);
GFMAT(rssky_transf);
// Set metric
printf("Lattice type: %s\n", lattice_name);
XLAL_CHECK(XLALSetTilingLatticeAndMetric(tiling, lattice_name, rssky_metric, max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC);
// Perform mismatch test
XLAL_CHECK(MismatchTest(tiling, rssky_metric, max_mismatch, total_ref, mism_hist_ref) == XLAL_SUCCESS, XLAL_EFUNC);
return XLAL_SUCCESS;
}
static int MultiSegSuperskyTest(void)
{
printf("Performing multiple-segment tests ...\n");
// Compute reduced supersky metrics
const double Tspan = 86400;
LIGOTimeGPS ref_time;
XLALGPSSetREAL8(&ref_time, 900100100);
LALSegList segments;
{
XLAL_CHECK(XLALSegListInit(&segments) == XLAL_SUCCESS, XLAL_EFUNC);
LALSeg segment;
{
LIGOTimeGPS start_time = ref_time, end_time = ref_time;
XLALGPSAdd(&start_time, -4 * Tspan);
XLALGPSAdd(&end_time, -3 * Tspan);
XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC);
}
{
LIGOTimeGPS start_time = ref_time, end_time = ref_time;
XLALGPSAdd(&start_time, -0.5 * Tspan);
XLALGPSAdd(&end_time, 0.5 * Tspan);
XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC);
}
{
LIGOTimeGPS start_time = ref_time, end_time = ref_time;
XLALGPSAdd(&start_time, 3.5 * Tspan);
XLALGPSAdd(&end_time, 4.5 * Tspan);
XLAL_CHECK(XLALSegSet(&segment, &start_time, &end_time, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSegListAppend(&segments, &segment) == XLAL_SUCCESS, XLAL_EFUNC);
}
}
MultiLALDetector detectors = {
.length = 1,
.sites = { lalCachedDetectors[LAL_LLO_4K_DETECTOR] }
};
EphemerisData *edat = XLALInitBarycenter(TEST_DATA_DIR "earth00-19-DE405.dat.gz",
TEST_DATA_DIR "sun00-19-DE405.dat.gz");
XLAL_CHECK(edat != NULL, XLAL_EFUNC);
SuperskyMetrics *metrics = XLALComputeSuperskyMetrics(1, &ref_time, &segments, 50, &detectors, NULL, DETMOTION_SPIN | DETMOTION_PTOLEORBIT, edat);
XLAL_CHECK(metrics != NULL, XLAL_EFUNC);
// Project and rescale semicoherent metric to give equal frequency spacings
const double coh_max_mismatch = 0.2, semi_max_mismatch = 0.4;
XLAL_CHECK(XLALEqualizeReducedSuperskyMetricsFreqSpacing(metrics, coh_max_mismatch, semi_max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC);
// Create lattice tilings
LatticeTiling *coh_tiling[metrics->num_segments];
for (size_t n = 0; n < metrics->num_segments; ++n) {
coh_tiling[n] = XLALCreateLatticeTiling(4);
XLAL_CHECK(coh_tiling[n] != NULL, XLAL_EFUNC);
}
LatticeTiling *semi_tiling = XLALCreateLatticeTiling(4);
XLAL_CHECK(semi_tiling != NULL, XLAL_EFUNC);
// Add bounds
for (size_t n = 0; n < metrics->num_segments; ++n) {
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSkyPatch(coh_tiling[n], metrics->coh_rssky_metric[n], metrics->coh_rssky_transf[n], 1, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(coh_tiling[n], metrics->coh_rssky_transf[n], 0, 50, 50 + 1e-4) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(coh_tiling[n], metrics->coh_rssky_transf[n], 1, 0, -5e-10) == XLAL_SUCCESS, XLAL_EFUNC);
}
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSkyPatch(semi_tiling, metrics->semi_rssky_metric, metrics->semi_rssky_transf, 1, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(semi_tiling, metrics->semi_rssky_transf, 0, 50, 50 + 1e-4) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK(XLALSetSuperskyLatticeTilingPhysicalSpinBound(semi_tiling, metrics->semi_rssky_transf, 1, 0, -5e-10) == XLAL_SUCCESS, XLAL_EFUNC);
// Set metric
for (size_t n = 0; n < metrics->num_segments; ++n) {
XLAL_CHECK(XLALSetTilingLatticeAndMetric(coh_tiling[n], "Ans", metrics->coh_rssky_metric[n], coh_max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC);
}
XLAL_CHECK(XLALSetTilingLatticeAndMetric(semi_tiling, "Ans", metrics->semi_rssky_metric, semi_max_mismatch) == XLAL_SUCCESS, XLAL_EFUNC);
// Check lattice step sizes in frequency
const size_t ifreq = 3;
const double semi_dfreq = XLALLatticeTilingStepSizes(semi_tiling, ifreq);
for (size_t n = 0; n < metrics->num_segments; ++n) {
const double coh_dfreq = XLALLatticeTilingStepSizes(coh_tiling[n], ifreq);
const double tol = 1e-8;
XLAL_CHECK(fabs(coh_dfreq - semi_dfreq) < tol * semi_dfreq, XLAL_EFAILED,
" ERROR: semi_dfreq=%0.15e, coh_dfreq[%zu]=%0.15e, |coh_dfreq - semi_dfreq| >= %g * semi_dfreq", semi_dfreq, n, coh_dfreq, tol);
}
// Check computation of spindown range for coherent tilings
for (size_t n = 0; n < metrics->num_segments; ++n) {
PulsarSpinRange spin_range;
XLAL_CHECK(XLALSuperskyLatticePulsarSpinRange(&spin_range, coh_tiling[n], metrics->coh_rssky_transf[n]) == XLAL_SUCCESS, XLAL_EFUNC);
}
// Cleanup
for (size_t n = 0; n < metrics->num_segments; ++n) {
XLALDestroyLatticeTiling(coh_tiling[n]);
}
XLALDestroyLatticeTiling(semi_tiling);
XLALDestroySuperskyMetrics(metrics);
XLALSegListClear(&segments);
XLALDestroyEphemerisData(edat);
LALCheckMemoryLeaks();
printf("\n");
fflush(stdout);
return XLAL_SUCCESS;
}
int main(void)
{
// Perform basic tests
XLAL_CHECK_MAIN(BasicTest(1, 0, 0, 0, 0, "Zn" , 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(1, 1, 1, 1, 1, "Ans", 93, 0, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(1, 1, 1, 1, 1, "Zn" , 93, 0, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(2, 0, 0, 0, 0, "Ans", 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(2, 1, 1, 1, 1, "Ans", 12, 144, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(2, 1, 1, 1, 1, "Zn" , 13, 190, 0, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(3, 0, 0, 0, 0, "Zn" , 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(3, 1, 1, 1, 1, "Ans", 8, 46, 332, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(3, 1, 1, 1, 1, "Zn" , 8, 60, 583, 0) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 0, 0, "Ans", 1, 1, 1, 1) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 0, 1, "Ans", 1, 1, 1, 4) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 1, 0, "Ans", 1, 1, 4, 4) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 0, 1, 1, "Ans", 1, 1, 4, 20) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 0, 0, "Ans", 1, 4, 4, 4) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 0, 1, "Ans", 1, 5, 5, 25) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 1, 0, "Ans", 1, 5, 24, 24) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 0, 1, 1, 1, "Ans", 1, 5, 20, 115) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 0, 0, "Ans", 4, 4, 4, 4) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 0, 1, "Ans", 5, 5, 5, 23) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 1, 0, "Ans", 5, 5, 23, 23) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 0, 1, 1, "Ans", 6, 6, 24, 139) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 0, 0, "Ans", 5, 25, 25, 25) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 0, 1, "Ans", 6, 30, 30, 162) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 1, 0, "Ans", 6, 27, 151, 151) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 1, 1, "Ans", 6, 30, 145, 897) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(BasicTest(4, 1, 1, 1, 1, "Zn" , 7, 46, 287, 2543) == XLAL_SUCCESS, XLAL_EFUNC);
// Perform mismatch tests with a square parameter space
XLAL_CHECK_MAIN(MismatchSquareTest("Zn", 0.03, 0, 0, 21460, Z1_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchSquareTest("Zn", 2e-4, -2e-9, 0, 23763, Z2_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchSquareTest("Zn", 1e-4, -1e-9, 1e-17, 19550, Z3_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchSquareTest("Ans", 0.03, 0, 0, 21460, A1s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchSquareTest("Ans", 2e-4, -2e-9, 0, 18283, A2s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchSquareTest("Ans", 1e-4, -2e-9, 2e-17, 20268, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
// Perform mismatch tests with an age--braking index parameter space
XLAL_CHECK_MAIN(MismatchAgeBrakeTest("Ans", 100, 4.0e-5, 37872, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchAgeBrakeTest("Ans", 200, 1.5e-5, 37232, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(MismatchAgeBrakeTest("Ans", 300, 1.0e-5, 37022, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
// Perform mismatch tests with the reduced supersky parameter space and metric
XLAL_CHECK_MAIN(SuperskyTest(1.1, 0.8, "Ans", 1, 50, 2.0e-5, 20548, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(SuperskyTest(1.5, 0.8, "Ans", 3, 50, 2.0e-5, 20202, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN(SuperskyTest(2.5, 0.8, "Ans", 17, 50, 2.0e-5, 29147, A3s_mism_hist) == XLAL_SUCCESS, XLAL_EFUNC);
// Perform tests with the reduced supersky parameter space metric and multiple segments
XLAL_CHECK_MAIN(MultiSegSuperskyTest() == XLAL_SUCCESS, XLAL_EFUNC);
return EXIT_SUCCESS;
}
/**
* 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 );
}
int main( void )
{
// Load ephemeris data
EphemerisData *edat = XLALInitBarycenter( TEST_DATA_DIR "earth00-19-DE405.dat.gz",
TEST_DATA_DIR "sun00-19-DE405.dat.gz" );
XLAL_CHECK_MAIN( edat != NULL, XLAL_EFUNC );
// Create segment list
LALSegList segments;
XLAL_CHECK_MAIN( XLALSegListInit( &segments ) == XLAL_SUCCESS, XLAL_EFUNC );
for ( size_t n = 0; n < NUM_SEGS; ++n ) {
const double Tspan = 3 * 86400;
const double deltat[NUM_SEGS] = { -8 * 86400, 0, 8 * 86400 };
LALSeg segment;
LIGOTimeGPS start_time = REF_TIME, end_time = REF_TIME;
XLALGPSAdd( &start_time, deltat[n] - 0.5 * Tspan );
XLALGPSAdd( &end_time, deltat[n] + 0.5 * Tspan );
XLAL_CHECK_MAIN( XLALSegSet( &segment, &start_time, &end_time, 0 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_MAIN( XLALSegListAppend( &segments, &segment ) == XLAL_SUCCESS, XLAL_EFUNC );
}
// Compute supersky metrics
SuperskyMetrics *metrics = NULL;
{
const LIGOTimeGPS ref_time = REF_TIME;
const MultiLALDetector detectors = { .length = 1, .sites = { lalCachedDetectors[LAL_LLO_4K_DETECTOR] } };
metrics = XLALComputeSuperskyMetrics( 1, &ref_time, &segments, FIDUCIAL_FREQ, &detectors, NULL, DETMOTION_SPIN | DETMOTION_PTOLEORBIT, edat );
}
XLAL_CHECK_MAIN( metrics != NULL, XLAL_EFUNC );
// Check coherent metrics
for ( size_t n = 0; n < NUM_SEGS; ++n ) {
XLAL_CHECK_MAIN( CheckSuperskyMetrics(
metrics->coh_rssky_metric[n], coh_rssky_metric_refs[n],
metrics->coh_rssky_transf[n], coh_rssky_transf_refs[n],
coh_phys_mismatches[n], 1e-2
) == XLAL_SUCCESS, XLAL_EFUNC );
}
// Check semicoherent metric
XLAL_CHECK_MAIN( CheckSuperskyMetrics(
metrics->semi_rssky_metric, semi_rssky_metric_ref,
metrics->semi_rssky_transf, semi_rssky_transf_ref,
semi_phys_mismatch, 3e-2
) == XLAL_SUCCESS, XLAL_EFUNC );
// Check semicoherent metric after round-trip frequency rescaling
XLAL_CHECK_MAIN( XLALScaleSuperskyMetricsFiducialFreq( metrics, 257.52 ) == XLAL_SUCCESS, XLAL_EFUNC );
{
double semi_rssky_metric_rescale[4][4];
memcpy( semi_rssky_metric_rescale, semi_rssky_metric_ref, sizeof( semi_rssky_metric_ref ) );
gsl_matrix_view semi_rssky_metric_rescale_view = gsl_matrix_view_array( ( double * )semi_rssky_metric_rescale, 4, 4 );
gsl_matrix_view sky_sky = gsl_matrix_submatrix( &semi_rssky_metric_rescale_view.matrix, 0, 0, 2, 2 );
gsl_matrix_scale( &sky_sky.matrix, ( 257.52 / FIDUCIAL_FREQ ) * ( 257.52 / FIDUCIAL_FREQ ) );
const double err = XLALCompareMetrics( metrics->semi_rssky_metric, &semi_rssky_metric_rescale_view.matrix ), err_tol = 1e-6;
XLAL_CHECK( err <= err_tol, XLAL_ETOL, "'rssky_metric' check failed: err = %0.3e > %0.3e = err_tol", err, err_tol );
}
XLAL_CHECK_MAIN( XLALScaleSuperskyMetricsFiducialFreq( metrics, FIDUCIAL_FREQ ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK_MAIN( CheckSuperskyMetrics(
metrics->semi_rssky_metric, semi_rssky_metric_ref,
metrics->semi_rssky_transf, semi_rssky_transf_ref,
semi_phys_mismatch, 3e-2
) == XLAL_SUCCESS, XLAL_EFUNC );
// Cleanup
XLALDestroyEphemerisData( edat );
XLALSegListClear( &segments );
XLALDestroySuperskyMetrics( metrics );
LALCheckMemoryLeaks();
return EXIT_SUCCESS;
}
int main( int argc, char *argv[] )
{
/* lal initialization variables */
LALStatus status = blank_status;
/* program option variables */
CHAR *userTag = NULL;
CHAR comment[LIGOMETA_COMMENT_MAX];
char *ifos = NULL;
char *ifoName = NULL;
char *outputFileName = NULL;
char *summFileName = NULL;
char *injectFileName = NULL;
char *vetoFileName = NULL;
char *missedFileName = NULL;
REAL4 snrStar = -1;
REAL4 rsqVetoThresh = -1;
REAL4 rsqMaxSnr = -1;
REAL4 rsqAboveSnrCoeff = -1;
REAL4 rsqAboveSnrPow = -1;
LALSegList vetoSegs;
MultiInspiralClusterChoice clusterchoice = no_statistic;
INT8 cluster_dt = -1;
INT8 injectWindowNS = -1;
int j;
FILE *fp = NULL;
int numInFiles = 0;
UINT8 triggerInputTimeNS = 0;
MetadataTable proctable;
MetadataTable procparams;
ProcessParamsTable *this_proc_param;
SimInspiralTable *simEventHead = NULL;
SimInspiralTable *thisSimEvent = NULL;
SimInspiralTable *missedSimHead = NULL;
SimInspiralTable *tmpSimEvent = NULL;
SearchSummvarsTable *inputFiles = NULL;
SearchSummaryTable *searchSummList = NULL;
SearchSummaryTable *thisSearchSumm = NULL;
SummValueTable *summValueList = NULL;
int extractSlide = 0;
int numSlides = 0;
int numEvents = 0;
int numEventsKept = 0;
int numEventsInIFO = 0;
int numEventsAboveSNRThresh = 0;
int numEventsBelowRsqThresh = 0;
int numEventsSurvivingVeto = 0;
int numClusteredEvents = 0;
int numEventsInIfos = 0;
int numSimEvents = 0;
int numSimInData = 0;
int numSimFound = 0;
int numMultiFound = 0;
MultiInspiralTable *missedHead = NULL;
MultiInspiralTable *thisEvent = NULL;
MultiInspiralTable *thisInspiralTrigger = NULL;
MultiInspiralTable *inspiralEventList = NULL;
MultiInspiralTable *slideEvent = NULL;
LIGOLwXMLStream xmlStream;
MetadataTable outputTable;
MetadataTable UNUSED savedEvents;
MetadataTable searchSummvarsTable;
/*
*
* initialization
*
*/
/* set up inital debugging values */
lal_errhandler = LAL_ERR_EXIT;
/* create the process and process params tables */
proctable.processTable = (ProcessTable *)
calloc( 1, sizeof(ProcessTable) );
XLALGPSTimeNow(&(proctable.processTable->start_time));
XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME, lalAppsVCSIdentId,
lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0);
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) );
savedEvents.multiInspiralTable = NULL;
/*
*
* parse command line arguments
*
*/
while (1)
{
/* LALgetopt arguments */
static struct LALoption long_options[] =
{
{"verbose", no_argument, &vrbflg, 1 },
{"sort-triggers", no_argument, &sortTriggers, 1 },
{"help", no_argument, 0, 'h'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{"comment", required_argument, 0, 'c'},
{"version", no_argument, 0, 'V'},
{"data-type", required_argument, 0, 'k'},
{"output", required_argument, 0, 'o'},
{"summary-file", required_argument, 0, 'S'},
{"extract-slide", required_argument, 0, 'e'},
{"num-slides", required_argument, 0, 'N'},
{"snr-threshold", required_argument, 0, 's'},
{"rsq-threshold", required_argument, 0, 'r'},
{"rsq-max-snr", required_argument, 0, 'R'},
{"rsq-coeff", required_argument, 0, 'p'},
{"rsq-power", required_argument, 0, 'P'},
{"cluster-algorithm", required_argument, 0, 'C'},
{"cluster-time", required_argument, 0, 't'},
{"ifo-cut", required_argument, 0, 'd'},
{"coinc-cut", required_argument, 0, 'D'},
{"veto-file", required_argument, 0, 'v'},
{"injection-file", required_argument, 0, 'I'},
{"injection-window", required_argument, 0, 'T'},
{"missed-injections", required_argument, 0, 'm'},
{0, 0, 0, 0}
};
int c;
/* LALgetopt_long stores the option index here. */
int option_index = 0;
size_t LALoptarg_len;
c = LALgetopt_long_only ( argc, argv,
"c:d:D:hj:k:m:o:r:s:t:v:C:DH:I:R:ST:VZ:",
long_options, &option_index );
/* detect the end of the options */
if ( c == - 1 )
break;
switch ( c )
{
case 0:
/* if this option set a flag, do nothing else now */
if ( long_options[option_index].flag != 0 )
{
break;
}
else
{
fprintf( stderr, "error parsing option %s with argument %s\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
break;
case 'h':
print_usage(argv[0]);
exit( 0 );
break;
case 'Z':
/* create storage for the usertag */
LALoptarg_len = strlen( LALoptarg ) + 1;
userTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) );
memcpy( userTag, LALoptarg, LALoptarg_len );
this_proc_param = this_proc_param->next = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s",
PROGRAM_NAME );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" );
snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s",
LALoptarg );
break;
case 'c':
if ( strlen( LALoptarg ) > LIGOMETA_COMMENT_MAX - 1 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"comment must be less than %d characters\n",
long_options[option_index].name, LIGOMETA_COMMENT_MAX );
exit( 1 );
}
else
{
snprintf( comment, LIGOMETA_COMMENT_MAX, "%s", LALoptarg);
}
break;
case 'V':
fprintf( stdout, "Coherent Inspiral Reader and Injection Analysis\n"
"Sukanta Bose\n");
XLALOutputVersionString(stderr, 0);
exit( 0 );
break;
case 'o':
/* create storage for the output file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
outputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( outputFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'e':
/* store the number of slides */
extractSlide = atoi( LALoptarg );
if ( extractSlide == 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"extractSlide must be non-zero: "
"(%d specified)\n",
long_options[option_index].name, extractSlide );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%d", extractSlide );
break;
case 'N':
/* store the number of slides */
numSlides = atoi( LALoptarg );
if ( numSlides < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"numSlides >= 0: "
"(%d specified)\n",
long_options[option_index].name, numSlides );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%d", numSlides );
break;
case 'S':
/* create storage for the summ file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
summFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( summFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'k':
/* type of data to analyze */
if ( ! strcmp( "playground_only", LALoptarg ) )
{
dataType = playground_only;
}
else if ( ! strcmp( "exclude_play", LALoptarg ) )
{
dataType = exclude_play;
}
else if ( ! strcmp( "all_data", LALoptarg ) )
{
dataType = all_data;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown data type, %s, specified: "
"(must be playground_only, exclude_play or all_data)\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 's':
snrStar = (REAL4) atof( LALoptarg );
if ( snrStar < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"threshold must be >= 0: "
"(%f specified)\n",
long_options[option_index].name, snrStar );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%e", snrStar );
break;
case 'r':
rsqVetoThresh = (REAL4) atof( LALoptarg );
if ( rsqVetoThresh < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"threshold must be >= 0: "
"(%f specified)\n",
long_options[option_index].name, rsqVetoThresh );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%e", rsqVetoThresh );
break;
case 'R':
rsqMaxSnr = (REAL4) atof( LALoptarg );
if ( rsqMaxSnr < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"threshold must be >= 0: "
"(%f specified)\n",
long_options[option_index].name, rsqMaxSnr );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%e", rsqMaxSnr );
break;
case 'p':
rsqAboveSnrCoeff = (REAL4) atof( LALoptarg );
if ( rsqAboveSnrCoeff < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"coefficient must be >= 0: "
"(%f specified)\n",
long_options[option_index].name, rsqAboveSnrCoeff );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%e", rsqAboveSnrCoeff );
break;
case 'P':
rsqAboveSnrPow = (REAL4) atof( LALoptarg );
if ( rsqAboveSnrPow < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"power must be >= 0: "
"(%f specified)\n",
long_options[option_index].name, rsqAboveSnrPow );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%e", rsqAboveSnrPow );
break;
case 'C':
/* choose the clustering algorithm */
{
if ( ! strcmp( "nullstat", LALoptarg) )
{
clusterchoice = nullstat;
}
else if ( ! strcmp( "cohsnr", LALoptarg) )
{
clusterchoice = cohsnr;
}
else if ( ! strcmp( "effCohSnr", LALoptarg) )
{
clusterchoice = effCohSnr;
}
else if ( ! strcmp( "snrByNullstat", LALoptarg) )
{
clusterchoice = snrByNullstat;
}
else if ( ! strcmp( "autoCorrCohSqByNullstat", LALoptarg) )
{
clusterchoice = autoCorrCohSqByNullstat;
}
else if ( ! strcmp( "crossCorrCohSqByNullstat", LALoptarg) )
{
clusterchoice = autoCorrCohSqByNullstat;
}
else if ( ! strcmp( "autoCorrNullSqByNullstat", LALoptarg) )
{
clusterchoice = autoCorrCohSqByNullstat;
}
else if ( ! strcmp( "crossCorrNullSqByNullstat", LALoptarg) )
{
clusterchoice = crossCorrCohSqByNullstat;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown clustering specified:\n "
"%s (must be one of: cohsnr, effCohSnr, nullstat, snrByNullstat, autoCorrCohSqByNullstat, \n"
"crossCorrCohSqByNullstat, autoCorrNullSqByNullstat, or crossCorrNullSqByNullstat)\n",
long_options[option_index].name, LALoptarg);
exit( 1 );
}
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
}
break;
case 't':
/* cluster time is specified on command line in ms */
cluster_dt = (INT8) atoi( LALoptarg );
if ( cluster_dt <= 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"cluster window must be > 0: "
"(%" LAL_INT8_FORMAT " specified)\n",
long_options[option_index].name, cluster_dt );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT, cluster_dt );
/* convert cluster time from ms to ns */
cluster_dt *= 1000000LL;
break;
case 'v':
/* create storage for the injection file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
vetoFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( vetoFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'I':
/* create storage for the injection file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
injectFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( injectFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'd':
LALoptarg_len = strlen( LALoptarg ) + 1;
ifoName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( ifoName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'D':
/* keep only coincs found in ifos */
LALoptarg_len = strlen( LALoptarg ) + 1;
ifos = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( ifos, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'T':
/* injection coincidence time is specified on command line in ms */
injectWindowNS = (INT8) atoi( LALoptarg );
if ( injectWindowNS < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"injection coincidence window must be >= 0: "
"(%" LAL_INT8_FORMAT " specified)\n",
long_options[option_index].name, injectWindowNS );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT, injectWindowNS );
/* convert inject time from ms to ns */
injectWindowNS *= 1000000LL;
break;
case 'm':
/* create storage for the missed injection file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
missedFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( missedFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case '?':
exit( 1 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
exit( 1 );
}
}
/*
*
* can use LALCalloc() / LALMalloc() from here
*
*/
/* don't buffer stdout if we are in verbose mode */
if ( vrbflg ) setvbuf( stdout, NULL, _IONBF, 0 );
/* fill the comment, if a user has specified it, or leave it blank */
if ( ! *comment )
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
}
else
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX,
"%s", comment );
}
/* check that the output file name has been specified */
if ( ! outputFileName )
{
fprintf( stderr, "--output must be specified\n" );
exit( 1 );
}
/* check that Data Type has been specified */
if ( dataType == unspecified_data_type )
{
fprintf( stderr, "Error: --data-type must be specified\n");
exit(1);
}
/* check that if clustering is being done that we have all the options */
if ( clusterchoice && cluster_dt < 0 )
{
fprintf( stderr, "--cluster-time must be specified if --cluster-algorithm "
"is given\n" );
exit( 1 );
}
else if ( ! clusterchoice && cluster_dt >= 0 )
{
fprintf( stderr, "--cluster-algorithm must be specified if --cluster-time "
"is given\n" );
exit( 1 );
}
/* check that if the rsq veto is being preformed,
we have the required options */
if ( ( (rsqVetoThresh > 0) || (rsqMaxSnr > 0) ) && ( (rsqVetoThresh < 0)
|| (rsqMaxSnr < 0) ) )
{
fprintf( stderr, "--rsq-threshold and --rsq-max-snr and must be "
"specified together" );
exit( 1 );
}
else if ( (rsqAboveSnrCoeff > 0) && ( (rsqMaxSnr < 0) || (rsqVetoThresh < 0)
|| (rsqAboveSnrPow < 0) ) )
{
fprintf( stderr, "--rsq-max-snr --rsq-threshold and --rsq-power "
"must be specified if --rsq-coeff is given\n" );
exit( 1 );
}
else if ( (rsqAboveSnrPow > 0) && ( (rsqMaxSnr < 0) || (rsqVetoThresh < 0)
|| (rsqAboveSnrCoeff < 0) ) )
{
fprintf( stderr, "--rsq-max-snr --rsq-threshold and --rsq-coeff "
"must be specified if --rsq-power is given\n" );
exit( 1 );
}
/* check that we have all the options to do injections */
if ( injectFileName && injectWindowNS < 0 )
{
fprintf( stderr, "--injection-coincidence must be specified if "
"--injection-file is given\n" );
exit( 1 );
}
else if ( ! injectFileName && injectWindowNS >= 0 )
{
fprintf( stderr, "--injection-file must be specified if "
"--injection-coincidence is given\n" );
exit( 1 );
}
if ( numSlides && extractSlide )
{
fprintf( stderr, "--num-slides and --extract-slide both specified\n"
"this doesn't make sense\n" );
exit( 1 );
}
/* save the sort triggers flag */
if ( sortTriggers )
{
this_proc_param = this_proc_param->next = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
snprintf( this_proc_param->program, LIGOMETA_PROGRAM_MAX, "%s",
PROGRAM_NAME );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX,
"--sort-triggers" );
snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, " " );
}
/* read in the veto file (if specified */
if ( vetoFileName )
{
XLALSegListInit( &vetoSegs );
LAL_CALL( LALSegListRead( &status, &vetoSegs, vetoFileName, NULL ),
&status );
XLALSegListCoalesce( &vetoSegs );
}
/*
*
* read in the input triggers from the xml files
*
*/
/* if we have run out of arguments on the command line, throw an error */
if ( ! (LALoptind < argc) )
{
fprintf( stderr, "Error: No input trigger files specified.\n" );
exit( 1 );
}
/* read in the triggers */
for( j = LALoptind; j < argc; ++j )
{
INT4 numFileTriggers = 0;
MultiInspiralTable *inspiralFileList = NULL;
MultiInspiralTable *thisFileTrigger = NULL;
numInFiles++;
numFileTriggers = XLALReadMultiInspiralTriggerFile( &inspiralFileList,
&thisFileTrigger, &searchSummList, &inputFiles, argv[j] );
numEvents += numFileTriggers;
if (numFileTriggers < 0)
{
fprintf(stderr, "Error reading triggers from file %s\n",
argv[j]);
exit( 1 );
}
else
{
if ( vrbflg )
{
fprintf(stdout, "Read %d reading triggers from file %s\n",
numFileTriggers, argv[j]);
}
}
/* read the summ value table as well. */
XLALReadSummValueFile(&summValueList, argv[j]);
/*
*
* keep only relevant triggers
*
*/
if( ifos )
{
numFileTriggers = XLALMultiInspiralIfosCut( &inspiralFileList, ifos );
if ( vrbflg ) fprintf( stdout,
"Kept %d coincs from %s instruments\n", numFileTriggers, ifos );
numEventsInIfos += numFileTriggers;
}
/* Do playground_only or exclude_play cut */
if ( dataType != all_data )
{
inspiralFileList = XLALPlayTestMultiInspiral( inspiralFileList,
&dataType );
/* count the triggers */
numFileTriggers = XLALCountMultiInspiralTable( inspiralFileList );
if ( dataType == playground_only && vrbflg ) fprintf( stdout,
"Have %d playground triggers\n", numFileTriggers );
else if ( dataType == exclude_play && vrbflg ) fprintf( stdout,
"Have %d non-playground triggers\n", numFileTriggers );
}
numEventsKept += numFileTriggers;
/* Do snr cut */
if ( snrStar > 0 )
{
inspiralFileList = XLALSNRCutMultiInspiral( inspiralFileList,
snrStar );
/* count the triggers */
numFileTriggers = XLALCountMultiInspiral( inspiralFileList );
if ( vrbflg ) fprintf( stdout, "Have %d triggers after snr cut\n",
numFileTriggers );
numEventsAboveSNRThresh += numFileTriggers;
}
/* NOTE: Add vetoing:
if ( vetoFileName )
{
inspiralFileList = XLALVetoMultiInspiral( inspiralFileList, &vetoSegs , ifoName);
count the triggers
numFileTriggers = XLALCountMultiInspiral( inspiralFileList );
if ( vrbflg ) fprintf( stdout, "Have %d triggers after applying veto\n",
numFileTriggers );
numEventsSurvivingVeto += numFileTriggers;
}
*/
/* If there are any remaining triggers ... */
if ( inspiralFileList )
{
/* add inspirals to list */
if ( thisInspiralTrigger )
{
thisInspiralTrigger->next = inspiralFileList;
}
else
{
inspiralEventList = thisInspiralTrigger = inspiralFileList;
}
for( ; thisInspiralTrigger->next;
thisInspiralTrigger = thisInspiralTrigger->next);
}
}
for ( thisSearchSumm = searchSummList; thisSearchSumm;
thisSearchSumm = thisSearchSumm->next )
{
UINT8 outPlayNS, outStartNS, outEndNS, triggerTimeNS;
LIGOTimeGPS inPlay, outPlay;
outStartNS = XLALGPSToINT8NS( &(thisSearchSumm->out_start_time) );
outEndNS = XLALGPSToINT8NS( &(thisSearchSumm->out_end_time) );
triggerTimeNS = outEndNS - outStartNS;
/* check for events and playground */
if ( dataType != all_data )
{
XLALPlaygroundInSearchSummary( thisSearchSumm, &inPlay, &outPlay );
outPlayNS = XLALGPSToINT8NS( &outPlay );
if ( dataType == playground_only )
{
/* increment the total trigger time by the amount of playground */
triggerInputTimeNS += outPlayNS;
}
else if ( dataType == exclude_play )
{
/* increment the total trigger time by the out time minus */
/* the time that is in the playground */
triggerInputTimeNS += triggerTimeNS - outPlayNS;
}
}
else
{
/* increment the total trigger time by the out time minus */
triggerInputTimeNS += triggerTimeNS;
}
}
/*
*
* sort the inspiral events by time
*
*/
if ( injectFileName || sortTriggers )
{
inspiralEventList = XLALSortMultiInspiral( inspiralEventList,
*LALCompareMultiInspiralByTime );
}
/*
*
* read in the injection XML file, if we are doing an injection analysis
*
*/
if ( injectFileName )
{
if ( vrbflg )
fprintf( stdout, "reading injections from %s... ", injectFileName );
numSimEvents = SimInspiralTableFromLIGOLw( &simEventHead,
injectFileName, 0, 0 );
if ( vrbflg ) fprintf( stdout, "got %d injections\n", numSimEvents );
if ( numSimEvents < 0 )
{
fprintf( stderr, "error: unable to read sim_inspiral table from %s\n",
injectFileName );
exit( 1 );
}
/* keep play/non-play/all injections */
if ( dataType == playground_only && vrbflg ) fprintf( stdout,
"Keeping only playground injections\n" );
else if ( dataType == exclude_play && vrbflg ) fprintf( stdout,
"Keeping only non-playground injections\n" );
else if ( dataType == all_data && vrbflg ) fprintf( stdout,
"Keeping all injections\n" );
XLALPlayTestSimInspiral( &simEventHead, &dataType );
/* keep only injections in times analyzed */
numSimInData = XLALSimInspiralInSearchedData( &simEventHead,
&searchSummList );
if ( vrbflg ) fprintf( stdout, "%d injections in analyzed data\n",
numSimInData );
/* check for events that are coincident with injections */
numSimFound = XLALMultiSimInspiralTest( &simEventHead,
&inspiralEventList, &missedSimHead, &missedHead, injectWindowNS );
if ( vrbflg ) fprintf( stdout, "%d injections found in the ifos\n",
numSimFound );
if ( numSimFound )
{
for ( thisEvent = inspiralEventList; thisEvent;
thisEvent = thisEvent->next, numMultiFound++ );
if ( vrbflg ) fprintf( stdout,
"%d triggers found at times of injection\n", numMultiFound );
}
/* free the missed singles */
while ( missedHead )
{
thisEvent = missedHead;
missedHead = missedHead->next;
XLALFreeMultiInspiral( &thisEvent );
}
}
/*
*
* extract specified slide
*
*/
if ( extractSlide )
{
slideEvent = XLALMultiInspiralSlideCut( &inspiralEventList, extractSlide );
/* free events from other slides */
while ( inspiralEventList )
{
thisEvent = inspiralEventList;
inspiralEventList = inspiralEventList->next;
XLALFreeMultiInspiral( &thisEvent );
}
/* move events to inspiralEventList */
inspiralEventList = slideEvent;
slideEvent = NULL;
}
/*
*
* cluster the remaining events
*
*/
if ( inspiralEventList && clusterchoice )
{
if ( vrbflg ) fprintf( stdout, "clustering remaining triggers... " );
if ( !numSlides ) {
numClusteredEvents = XLALClusterMultiInspiralTable( &inspiralEventList,
cluster_dt, clusterchoice );
}
else
{
int slide = 0;
int numClusteredSlide = 0;
MultiInspiralTable *tmp_slideEvent = NULL;
MultiInspiralTable *slideClust = NULL;
if ( vrbflg ) fprintf( stdout, "splitting events by slide\n" );
for( slide = -numSlides; slide < (numSlides + 1); slide++)
{
if ( vrbflg ) fprintf( stdout, "slide number %d; ", slide );
/* extract the slide */
tmp_slideEvent = XLALMultiInspiralSlideCut( &inspiralEventList, slide );
/* run clustering */
numClusteredSlide = XLALClusterMultiInspiralTable( &tmp_slideEvent,
cluster_dt, clusterchoice);
if ( vrbflg ) fprintf( stdout, "%d clustered events \n",
numClusteredSlide );
numClusteredEvents += numClusteredSlide;
/* add clustered triggers */
if( tmp_slideEvent )
{
if( slideClust )
{
thisEvent = thisEvent->next = tmp_slideEvent;
}
else
{
slideClust = thisEvent = tmp_slideEvent;
}
/* scroll to end of list */
for( ; thisEvent->next; thisEvent = thisEvent->next);
}
}
/* free inspiralEventList -- although we expect it to be empty */
while ( inspiralEventList )
{
thisEvent = inspiralEventList;
inspiralEventList = inspiralEventList->next;
XLALFreeMultiInspiral( &thisEvent );
}
/* move events to coincHead */
inspiralEventList = slideClust;
slideClust = NULL;
}
if ( vrbflg ) fprintf( stdout, "done\n" );
if ( vrbflg ) fprintf( stdout, "%d clustered events \n",
numClusteredEvents );
}
/*
*
* update search_summary->nevents with an authoritative count of triggers
*
*/
searchSummList->nevents = 0;
thisEvent = inspiralEventList;
while (thisEvent) {
searchSummList->nevents += 1;
thisEvent = thisEvent->next;
}
/*
*
* write output data
*
*/
/* write the main output file containing found injections */
if ( vrbflg ) fprintf( stdout, "writing output xml files... " );
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, outputFileName ), &status );
/* write out the process and process params tables */
if ( vrbflg ) fprintf( stdout, "process... " );
XLALGPSTimeNow(&(proctable.processTable->end_time));
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, process_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, proctable,
process_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
free( proctable.processTable );
/* erase the first empty process params entry */
{
ProcessParamsTable *emptyPPtable = procparams.processParamsTable;
procparams.processParamsTable = procparams.processParamsTable->next;
free( emptyPPtable );
}
/* write the process params table */
if ( vrbflg ) fprintf( stdout, "process_params... " );
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
process_params_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, procparams,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* write search_summary table */
if ( vrbflg ) fprintf( stdout, "search_summary... " );
outputTable.searchSummaryTable = searchSummList;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
search_summary_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
search_summary_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* write the search_summvars table */
if ( vrbflg ) fprintf( stdout, "search_summvars... " );
LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream,
search_summvars_table), &status );
searchSummvarsTable.searchSummvarsTable = inputFiles;
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchSummvarsTable,
search_summvars_table), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status );
/* write summ_value table */
if ( summValueList )
{
if ( vrbflg ) fprintf( stdout, "search_summary... " );
outputTable.summValueTable = summValueList;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
summ_value_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
summ_value_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
}
/* Write the found injections to the sim table */
if ( simEventHead )
{
if ( vrbflg ) fprintf( stdout, "sim_inspiral... " );
outputTable.simInspiralTable = simEventHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
sim_inspiral_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sim_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status );
}
/* Write the results to the inspiral table */
if ( inspiralEventList )
{
if ( vrbflg ) fprintf( stdout, "multi_inspiral... " );
outputTable.multiInspiralTable = inspiralEventList;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
multi_inspiral_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
multi_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status);
}
/* close the output file */
LAL_CALL( LALCloseLIGOLwXMLFile(&status, &xmlStream), &status);
if ( vrbflg ) fprintf( stdout, "done\n" );
if ( missedFileName )
{
/* open the missed injections file and write the missed injections to it */
if ( vrbflg ) fprintf( stdout, "writing missed injections... " );
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlStream, missedFileName ),
&status );
if ( missedSimHead )
{
outputTable.simInspiralTable = missedSimHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_inspiral_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sim_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status );
}
LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream ), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
}
if ( summFileName )
{
LIGOTimeGPS triggerTime;
/* write out a summary file */
fp = fopen( summFileName, "w" );
switch ( dataType )
{
case playground_only:
fprintf( fp, "using data from playground times only\n" );
break;
case exclude_play:
fprintf( fp, "excluding all triggers in playground times\n" );
break;
case all_data:
fprintf( fp, "using all input data\n" );
break;
default:
fprintf( stderr, "data set not defined\n" );
exit( 1 );
}
fprintf( fp, "read triggers from %d files\n", numInFiles );
fprintf( fp, "number of triggers in input files: %d \n", numEvents );
fprintf( fp, "number of triggers in input data %d \n", numEventsKept );
if ( ifoName )
{
fprintf( fp, "number of triggers from %s ifo %d \n", ifoName,
numEventsInIFO );
}
if ( snrStar > 0 )
{
fprintf( fp, "number of triggers in input data with snr above %f: %d \n",
snrStar, numEventsAboveSNRThresh );
}
if ( rsqVetoThresh > 0 )
{
fprintf( fp, "performed R-squared veto on triggers with snr < %f\n",
rsqMaxSnr);
fprintf( fp, "with rsqveto_duration below %f\n",
rsqVetoThresh);
if ( (rsqAboveSnrCoeff > 0) && (rsqAboveSnrPow > 0) )
{
fprintf( fp, "and on triggers with snr > %f\n",
rsqMaxSnr);
fprintf( fp, "with rsqveto_duration above %f * snr ^ %f\n",
rsqAboveSnrCoeff, rsqAboveSnrPow );
}
fprintf( fp, "the number of triggers below the R-squared veto are: %d \n",
numEventsBelowRsqThresh);
}
if ( vetoFileName )
{
fprintf( fp, "number of triggers not vetoed by %s: %d \n",
vetoFileName, numEventsSurvivingVeto );
}
XLALINT8NSToGPS( &triggerTime, triggerInputTimeNS );
fprintf( fp, "amount of time analysed for triggers %d sec %d ns\n",
triggerTime.gpsSeconds, triggerTime.gpsNanoSeconds );
if ( injectFileName )
{
fprintf( fp, "read %d injections from file %s\n",
numSimEvents, injectFileName );
fprintf( fp, "number of injections in input data: %d\n", numSimInData );
fprintf( fp, "number of injections found in input data: %d\n",
numSimFound );
fprintf( fp,
"number of triggers found within %lld msec of injection: %d\n",
(injectWindowNS / 1000000LL), numMultiFound );
fprintf( fp, "efficiency: %f \n",
(REAL4) numSimFound / (REAL4) numSimInData );
}
if ( extractSlide )
{
fprintf( fp, "kept only triggers from slide %d\n", extractSlide );
}
if ( clusterchoice )
{
if ( numSlides )
{
fprintf( fp, "clustering triggers from %d slides separately\n",
numSlides );
}
fprintf( fp, "number of event clusters with %lld msec window: %d\n",
cluster_dt/ 1000000LL, numClusteredEvents );
}
fclose( fp );
}
/*
*
* free memory and exit
*
*/
/* free the inspiral events we saved */
while ( inspiralEventList )
{
thisEvent = inspiralEventList;
inspiralEventList = inspiralEventList->next;
LAL_CALL ( LALFreeMultiInspiral ( &status, &thisEvent ), &status);
}
/* free the process params */
while( procparams.processParamsTable )
{
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
/* free the found injections */
while ( simEventHead )
{
thisSimEvent = simEventHead;
simEventHead = simEventHead->next;
LALFree( thisSimEvent );
}
/* free the temporary memory containing the missed injections */
while ( missedSimHead )
{
tmpSimEvent = missedSimHead;
missedSimHead = missedSimHead->next;
LALFree( tmpSimEvent );
}
/* free search summaries read in */
while ( searchSummList )
{
thisSearchSumm = searchSummList;
searchSummList = searchSummList->next;
LALFree( thisSearchSumm );
}
while ( summValueList )
{
SummValueTable *thisSummValue;
thisSummValue = summValueList;
summValueList = summValueList->next;
LALFree( thisSummValue );
}
if ( vetoFileName )
{
XLALSegListClear( &vetoSegs );
}
if ( vrbflg ) fprintf( stdout, "checking memory leaks and exiting\n" );
LALCheckMemoryLeaks();
exit( 0 );
}
