int main( int argc, char *argv[] ) { LALStatus status = blank_status; UINT4 k; UINT4 kLow; UINT4 kHi; INT4 numPoints = 524288; REAL4 fSampling = 2048.; REAL4 fLow = 70.; REAL4 fLowInj = 40.; REAL8 deltaT = 1./fSampling; REAL8 deltaF = fSampling / numPoints; REAL4 statValue; /* vars required to make freq series */ LIGOTimeGPS epoch = { 0, 0 }; LIGOTimeGPS gpsStartTime = {0, 0}; REAL8 f0 = 0.; REAL8 offset = 0.; INT8 waveformStartTime = 0; /* files contain PSD info */ CHAR *injectionFile = NULL; CHAR *outputFile = NULL; CHAR *specFileH1 = NULL; CHAR *specFileH2 = NULL; CHAR *specFileL1 = NULL; COMPLEX8Vector *unity = NULL; const LALUnit strainPerCount = {0,{0,0,0,0,0,1,-1},{0,0,0,0,0,0,0}}; int numInjections = 0; int numTriggers = 0; /* template bank simulation variables */ INT4 injSimCount = 0; SimInspiralTable *injectionHead = NULL; SimInspiralTable *thisInjection = NULL; SnglInspiralTable *snglHead = NULL; SearchSummaryTable *searchSummHead = NULL; /*SummValueTable *summValueHead = NULL; */ /* raw input data storage */ REAL8FrequencySeries *specH1 = NULL; REAL8FrequencySeries *specH2 = NULL; REAL8FrequencySeries *specL1 = NULL; REAL8FrequencySeries *thisSpec = NULL; COMPLEX8FrequencySeries *resp = NULL; COMPLEX8FrequencySeries *detTransDummy = NULL; REAL4TimeSeries *chan = NULL; RealFFTPlan *pfwd = NULL; COMPLEX8FrequencySeries *fftData = NULL; REAL8 thisSnrsq = 0; REAL8 thisSnr = 0; REAL8 thisCombSnr = 0; REAL8 snrVec[3]; REAL8 dynRange = 1./(3.0e-23); /* needed for inj */ CoherentGW waveform; PPNParamStruc ppnParams; DetectorResponse detector; InterferometerNumber ifoNumber = LAL_UNKNOWN_IFO; /* output data */ LIGOLwXMLStream xmlStream; MetadataTable proctable; MetadataTable outputTable; MetadataTable procparams; CHAR fname[256]; CHAR comment[LIGOMETA_COMMENT_MAX]; ProcessParamsTable *this_proc_param = NULL; CHAR chanfilename[FILENAME_MAX]; REAL4 sum = 0; REAL4 bitten_H1 = 0; REAL4 bitten_H2 = 0; REAL4 thisCombSnr_H1H2 = 0; /* 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) ); /* look at input args, write process params where required */ while ( 1 ) { /* getopt arguments */ static struct option long_options[] = { /* these options set a flag */ /* these options do not set a flag */ {"help", no_argument, 0, 'h'}, {"verbose", no_argument, &vrbflg, 1 }, {"version", no_argument, 0, 'V'}, {"spectrum-H1", required_argument, 0, 'a'}, {"spectrum-H2", required_argument, 0, 'b'}, {"spectrum-L1", required_argument, 0, 'c'}, {"inj-file", required_argument, 0, 'd'}, {"comment", required_argument, 0, 'e'}, {"output-file", required_argument, 0, 'f'}, {"coire-flag", no_argument, &coireflg, 1 }, {"ligo-srd", no_argument, &ligosrd, 1 }, {"write-chan", no_argument, &writechan, 1 }, {"inject-overhead", no_argument, &injoverhead, 1 }, {"f-lower", required_argument, 0, 'g'}, {0, 0, 0, 0} }; int c; /* * * parse command line arguments * */ /* getopt_long stores long option here */ int option_index = 0; size_t optarg_len; c = getopt_long_only( argc, argv, "a:b:c:d:e:f:g:hV", 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, optarg ); exit( 1 ); } break; case 'h': fprintf( stderr, USAGE ); exit( 0 ); break; case 'a': /* create storage for the spectrum file name */ optarg_len = strlen( optarg ) + 1; specFileH1 = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( specFileH1, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'b': /* create storage for the spectrum file name */ optarg_len = strlen( optarg ) + 1; specFileH2 = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( specFileH2, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'c': /* create storage for the spectrum file name */ optarg_len = strlen( optarg ) + 1; specFileL1 = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( specFileL1, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'd': /* create storage for the injection file name */ optarg_len = strlen( optarg ) + 1; injectionFile = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( injectionFile, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'f': /* create storage for the output file name */ optarg_len = strlen( optarg ) + 1; outputFile = (CHAR *) calloc( optarg_len, sizeof(CHAR)); memcpy( outputFile, optarg, optarg_len ); ADD_PROCESS_PARAM( "string", "%s", optarg ); break; case 'g': fLow = (INT4) atof( optarg ); if ( fLow < 40 ) { fprintf( stderr, "invalid argument to --%s:\n" "f-lower must be > 40Hz (%e specified)\n", long_options[option_index].name, fLow ); exit( 1 ); } ADD_PROCESS_PARAM( "float", "%e", fLow ); break; case 'e': if ( strlen( optarg ) > 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", optarg); } break; case 'V': /* print version information and exit */ fprintf( stdout, "calculation of expected SNR of injections\n" "Gareth Jones\n"); XLALOutputVersionString(stderr, 0); exit( 0 ); break; default: fprintf( stderr, "unknown error while parsing options\n" ); fprintf( stderr, USAGE ); exit( 1 ); } } if ( optind < argc ) { fprintf( stderr, "extraneous command line arguments:\n" ); while ( optind < argc ) { fprintf ( stderr, "%s\n", argv[optind++] ); } exit( 1 ); } /* check the input arguments */ if ( injectionFile == NULL ) { fprintf( stderr, "Must specify the --injection-file\n" ); exit( 1 ); } if ( outputFile == NULL ) { fprintf( stderr, "Must specify the --output-file\n" ); exit( 1 ); } if ( !ligosrd && specFileH1 == NULL ) { fprintf( stderr, "Must specify the --spectrum-H1\n" ); exit( 1 ); } if ( !ligosrd && specFileH2 == NULL ) { fprintf( stderr, "Must specify the --spectrum-H2\n" ); exit( 1 ); } if ( !ligosrd && specFileL1 == NULL ) { fprintf( stderr, "Must specify the --spectrum-L1\n" ); exit( 1 ); } if ( ligosrd && (specFileH1 || specFileH2 || specFileL1 )) { fprintf( stdout, "WARNING: using LIGOI SRD power spectral density \n" ); } if ( vrbflg ){ fprintf( stdout, "injection file is %s\n", injectionFile ); fprintf( stdout, "output file is %s\n", outputFile ); fprintf( stdout, "H1 spec file is %s\n", specFileH1 ); fprintf( stdout, "H2 spec file is %s\n", specFileH2 ); fprintf( stdout, "L1 spec file is %s\n", specFileL1 ); } /* create vector for H1, H2 and L1 spectrums */ specH1 = XLALCreateREAL8FrequencySeries ( "",&epoch, f0, deltaF, &lalADCCountUnit, (numPoints / 2 + 1) ); specH2 = XLALCreateREAL8FrequencySeries ( "",&epoch, f0, deltaF, &lalADCCountUnit, (numPoints / 2 + 1) ); specL1 = XLALCreateREAL8FrequencySeries ( "",&epoch, f0, deltaF, &lalADCCountUnit, (numPoints / 2 + 1) ); if (!specH1 || !specH2 || !specL1){ XLALDestroyREAL8FrequencySeries ( specH1 ); XLALDestroyREAL8FrequencySeries ( specH2 ); XLALDestroyREAL8FrequencySeries ( specL1 ); XLALPrintError("failure allocating H1, H2 and L1 spectra"); exit(1); } if (!ligosrd){ /* read in H1 spectrum */ LAL_CALL( LALDReadFrequencySeries(&status, specH1, specFileH1), &status ); if ( vrbflg ){ fprintf( stdout, "read in H1 spec file\n" ); fflush( stdout ); } /* read in H2 spectrum */ LAL_CALL( LALDReadFrequencySeries(&status, specH2, specFileH2), &status ); if ( vrbflg ){ fprintf( stdout, "read in H2 spec file\n" ); fflush( stdout ); } /* read in L1 spectrum */ LAL_CALL( LALDReadFrequencySeries(&status, specL1, specFileL1), &status ); if ( vrbflg ){ fprintf( stdout, "read in L1 spec file\n" ); fflush( stdout ); } } chan = XLALCreateREAL4TimeSeries( "", &epoch, f0, deltaT, &lalADCCountUnit, numPoints ); if ( !chan ){ XLALPrintError("failure allocating chan"); exit(1); } /* * * set up the response function * */ resp = XLALCreateCOMPLEX8FrequencySeries( chan->name, &chan->epoch, f0, deltaF, &strainPerCount, (numPoints / 2 + 1) ); if ( !resp ){ XLALPrintError("failure allocating response function"); exit(1); } /* create vector that will contain detector.transfer info, since this * is constant I calculate it once outside of all the loops and pass it * in to detector.transfer when required */ detTransDummy = XLALCreateCOMPLEX8FrequencySeries( chan->name, &chan->epoch, f0, deltaF, &strainPerCount, (numPoints / 2 + 1) ); if ( !detTransDummy ){ XLALPrintError("failure allocating detector.transfer info"); exit(1); } /* invert the response function to get the transfer function */ unity = XLALCreateCOMPLEX8Vector( resp->data->length ); for ( k = 0; k < unity->length; ++k ) { unity->data[k] = 1.0; } /* set response */ for ( k = 0; k < resp->data->length; ++k ) { resp->data->data[k] = 1.0; } XLALCCVectorDivide( detTransDummy->data, unity, resp->data ); XLALDestroyCOMPLEX8Vector( unity ); /* read in injections from injection file */ /* set endtime to 0 so that we read in all events */ if ( vrbflg ) fprintf( stdout, "Reading sim_inspiral table of %s\n", injectionFile ); LAL_CALL(numInjections = SimInspiralTableFromLIGOLw( &injectionHead, injectionFile, 0, 0), &status); if ( vrbflg ) fprintf( stdout, "Read %d injections from sim_inspiral table of %s\n", numInjections, injectionFile ); if (coireflg){ if ( vrbflg ) fprintf( stdout, "Reading sngl_inspiral table of %s\n", injectionFile ); LAL_CALL(numTriggers = LALSnglInspiralTableFromLIGOLw(&snglHead, injectionFile, 0, -1), &status); if ( vrbflg ) fprintf( stdout, "Read %d triggers from sngl_inspiral table of %s\n", numTriggers, injectionFile ); if ( vrbflg ) { fprintf( stdout, "Reading search_summary table of %s ...", injectionFile ); fflush( stdout ); } searchSummHead = XLALSearchSummaryTableFromLIGOLw (injectionFile); if ( vrbflg ) fprintf( stdout, " done\n"); } /* make sure we start at head of linked list */ thisInjection = injectionHead; /* setting fixed waveform injection parameters */ memset( &ppnParams, 0, sizeof(PPNParamStruc) ); ppnParams.deltaT = deltaT; ppnParams.lengthIn = 0; ppnParams.ppn = NULL; /* loop over injections */ injSimCount = 0; do { fprintf( stdout, "injection %d/%d\n", injSimCount+1, numInjections ); /* reset waveform structure */ memset( &waveform, 0, sizeof(CoherentGW) ); /* reset chan structure */ memset( chan->data->data, 0, chan->data->length * sizeof(REAL4) ); if (thisInjection->f_lower == 0){ fprintf( stdout, "WARNING: f_lower in sim_inpiral = 0, "); fprintf( stdout, "changing this to %e\n ", fLowInj); thisInjection->f_lower = fLowInj; } /* create the waveform, amp, freq phase etc */ LAL_CALL( LALGenerateInspiral(&status, &waveform, thisInjection, &ppnParams), &status); if (vrbflg) fprintf( stdout, "ppnParams.tc %e\n ", ppnParams.tc); statValue = 0.; /* calc lower index for integration */ kLow = ceil(fLow / deltaF); if ( vrbflg ) { fprintf( stdout, "starting integration to find SNR at frequency %e ", fLow); fprintf( stdout, "at index %d \n", kLow); } /* calc upper index for integration */ kHi = floor(fSampling / (2. * deltaF)); if ( vrbflg ) { fprintf( stdout, "ending integration to find SNR at frequency %e ", fSampling / 2.); fprintf( stdout, "at index %d \n", kHi); } /* loop over ifo */ for ( ifoNumber = 1; ifoNumber < 4; ifoNumber++ ) { /* allocate memory and copy the parameters describing the freq series */ memset( &detector, 0, sizeof( DetectorResponse ) ); detector.site = (LALDetector *) LALMalloc( sizeof(LALDetector) ); if (injoverhead){ if ( vrbflg ) fprintf( stdout, "WARNING: perform overhead injections\n"); /* setting detector.site to NULL causes SimulateCoherentGW to * perform overhead injections */ detector.site = NULL; } else { /* if not overhead, set detector.site using ifonumber */ XLALReturnDetector( detector.site, ifoNumber ); } switch ( ifoNumber ) { case 1: if ( vrbflg ) fprintf( stdout, "looking at H1 \n"); thisSpec = specH1; break; case 2: if ( vrbflg ) fprintf( stdout, "looking at H2 \n"); thisSpec = specH2; break; case 3: if ( vrbflg ) fprintf( stdout, "looking at L1 \n"); thisSpec = specL1; break; default: fprintf( stderr, "Error: ifoNumber %d does not correspond to H1, H2 or L1: \n", ifoNumber ); exit( 1 ); } /* get the gps start time of the signal to inject */ waveformStartTime = XLALGPSToINT8NS( &(thisInjection->geocent_end_time) ); waveformStartTime -= (INT8) ( 1000000000.0 * ppnParams.tc ); offset = (chan->data->length / 2.0) * chan->deltaT; gpsStartTime.gpsSeconds = thisInjection->geocent_end_time.gpsSeconds - offset; gpsStartTime.gpsNanoSeconds = thisInjection->geocent_end_time.gpsNanoSeconds; chan->epoch = gpsStartTime; if (vrbflg) fprintf(stdout, "offset start time of injection by %f seconds \n", offset ); /* is this okay? copying in detector transfer which so far only contains response info */ detector.transfer = detTransDummy; XLALUnitInvert( &(detector.transfer->sampleUnits), &(resp->sampleUnits) ); /* set the start times for injection */ XLALINT8NSToGPS( &(waveform.a->epoch), waveformStartTime ); memcpy(&(waveform.f->epoch), &(waveform.a->epoch), sizeof(LIGOTimeGPS) ); memcpy(&(waveform.phi->epoch), &(waveform.a->epoch), sizeof(LIGOTimeGPS) ); /* perform the injection */ LAL_CALL( LALSimulateCoherentGW(&status, chan, &waveform, &detector ), &status); if (writechan){ /* write out channel data */ if (vrbflg) fprintf(stdout, "writing channel data to file... \n" ); switch ( ifoNumber ) { case 1: snprintf( chanfilename, FILENAME_MAX, "chanTest_H1_inj%d.dat", injSimCount+1); if (vrbflg) fprintf( stdout, "writing H1 channel time series out to %s\n", chanfilename ); LALSPrintTimeSeries(chan, chanfilename ); break; case 2: snprintf( chanfilename, FILENAME_MAX, "chanTest_H2_inj%d.dat", injSimCount+1); if (vrbflg) fprintf( stdout, "writing H2 channel time series out to %s\n", chanfilename ); LALSPrintTimeSeries(chan, chanfilename ); break; case 3: snprintf( chanfilename, FILENAME_MAX, "chanTest_L1_inj%d.dat", injSimCount+1); if (vrbflg) fprintf( stdout, "writing L1 channel time series out to %s\n", chanfilename ); LALSPrintTimeSeries(chan, chanfilename ); break; default: fprintf( stderr, "Error: ifoNumber %d does not correspond to H1, H2 or L1: \n", ifoNumber ); exit( 1 ); } } LAL_CALL( LALCreateForwardRealFFTPlan( &status, &pfwd, chan->data->length, 0), &status); fftData = XLALCreateCOMPLEX8FrequencySeries( chan->name, &chan->epoch, f0, deltaF, &lalDimensionlessUnit, (numPoints / 2 + 1) ); if ( !fftData ){ XLALPrintError("failure allocating fftData"); exit(1); } LAL_CALL( LALTimeFreqRealFFT( &status, fftData, chan, pfwd ), &status); LAL_CALL( LALDestroyRealFFTPlan( &status, &pfwd ), &status); pfwd = NULL; /* compute the SNR */ thisSnrsq = 0; /* avoid f=0 part of psd */ if (ligosrd){ if (vrbflg) fprintf( stdout, "using LIGOI PSD \n"); for ( k = kLow; k < kHi; k++ ) { REAL8 freq; REAL8 sim_psd_value; freq = fftData->deltaF * k; LALLIGOIPsd( NULL, &sim_psd_value, freq ); thisSnrsq += ((crealf(fftData->data->data[k]) * dynRange) * (crealf(fftData->data->data[k]) * dynRange)) / sim_psd_value; thisSnrsq += ((cimagf(fftData->data->data[k]) * dynRange) * (cimagf(fftData->data->data[k]) * dynRange)) / sim_psd_value; } } else { if (vrbflg) fprintf( stdout, "using input spectra \n"); for ( k = kLow; k < kHi; k++ ) { thisSnrsq += ((crealf(fftData->data->data[k]) * dynRange) * (crealf(fftData->data->data[k]) * dynRange)) / (thisSpec->data->data[k] * dynRange * dynRange); thisSnrsq += ((cimagf(fftData->data->data[k]) * dynRange) * (cimagf(fftData->data->data[k]) * dynRange)) / (thisSpec->data->data[k] * dynRange * dynRange); } } thisSnrsq *= 4*fftData->deltaF; thisSnr = pow(thisSnrsq, 0.5); /* Note indexing on snrVec, ifoNumber runs from 1..3 to get source correct, * we must index snrVec 0..2 */ snrVec[ifoNumber-1] = thisSnr; XLALDestroyCOMPLEX8FrequencySeries(fftData); if ( vrbflg ){ fprintf( stdout, "thisSnrsq %e\n", thisSnrsq ); fprintf( stdout, "snrVec %e\n", snrVec[ifoNumber-1] ); fflush( stdout ); } /* sum thisSnrsq to eventually get combined snr*/ statValue += thisSnrsq; /* free some memory */ if (detector.transfer) detector.transfer = NULL; if ( detector.site ) {LALFree( detector.site); detector.site = NULL;} } /* end loop over ifo */ destroyCoherentGW( &waveform ); /* store inverse eff snrs in eff_dist columns */ thisInjection->eff_dist_h = 1./snrVec[0]; thisInjection->eff_dist_g = 1./snrVec[1]; thisInjection->eff_dist_l = 1./snrVec[2]; /* store inverse sum of squares snr in eff_dist_t */ thisCombSnr = pow(statValue, 0.5); if ( vrbflg ) fprintf( stdout, "thisCombSnr %e\n", thisCombSnr); thisInjection->eff_dist_t = 1./thisCombSnr; /* calc inverse bittenL snr for H1H2 and store in eff_dist_v */ thisCombSnr_H1H2 = 0.; sum = snrVec[0] * snrVec[0] + snrVec[1] * snrVec[1]; bitten_H1 = 3 * snrVec[0] -3; bitten_H2 = 3 * snrVec[1] -3; if (sum < bitten_H1){ thisCombSnr_H1H2 = sum; } else { thisCombSnr_H1H2 = bitten_H1; } if (bitten_H2 < thisCombSnr_H1H2){ thisCombSnr_H1H2 = bitten_H2; } thisInjection->eff_dist_v = 1./thisCombSnr_H1H2; /* increment the bank sim sim_inspiral table if necessary */ if ( injectionHead ) { thisInjection = thisInjection->next; } } while ( ++injSimCount < numInjections ); /* end loop over injections */ /* try opening, writing and closing an xml file */ /* open the output xml file */ memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) ); snprintf( fname, sizeof(fname), "%s", outputFile); LAL_CALL( LALOpenLIGOLwXMLFile ( &status, &xmlStream, fname), &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 ); /* Just being pedantic here ... */ proctable.processTable = NULL; /* free the unused process param entry */ this_proc_param = procparams.processParamsTable; procparams.processParamsTable = procparams.processParamsTable->next; free( this_proc_param ); this_proc_param = NULL; /* 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 the search summary table */ if ( coireflg ){ if ( vrbflg ) fprintf( stdout, "search_summary... " ); outputTable.searchSummaryTable = searchSummHead; 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 sim inspiral table */ if ( vrbflg ) fprintf( stdout, "sim_inspiral... " ); outputTable.simInspiralTable = injectionHead; 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 sngl inspiral table */ if ( coireflg ){ if ( vrbflg ) fprintf( stdout, "sngl_inspiral... " ); outputTable.snglInspiralTable = snglHead; LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sngl_inspiral_table), &status); LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable, sngl_inspiral_table), &status); LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream), &status); } /* close the xml file */ LAL_CALL( LALCloseLIGOLwXMLFile ( &status, &xmlStream), &status); /* Freeing memory */ XLALDestroyREAL4TimeSeries(chan); XLALDestroyCOMPLEX8FrequencySeries(resp); XLALDestroyCOMPLEX8FrequencySeries(detTransDummy); XLALDestroyREAL8FrequencySeries ( specH1 ); XLALDestroyREAL8FrequencySeries ( specH2 ); XLALDestroyREAL8FrequencySeries ( specL1 ); free( specFileH1 ); specFileH1 = NULL; free( specFileH2 ); specFileH2 = NULL; free( specFileL1 ); specFileL1 = NULL; free( injectionFile ); injectionFile = NULL; /* free the process params */ while( procparams.processParamsTable ) { this_proc_param = procparams.processParamsTable; procparams.processParamsTable = this_proc_param->next; free( this_proc_param ); this_proc_param = NULL; } /* free the sim inspiral tables */ while ( injectionHead ) { thisInjection = injectionHead; injectionHead = injectionHead->next; LALFree( thisInjection ); } /*check for memory leaks */ LALCheckMemoryLeaks(); exit( 0 ); }
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 ); }