/** 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 ); }