int main( int argc, char *argv[] )
{
LALStatus status = blank_status;
#if 0
const INT4 S2StartTime = 729273613; /* Feb 14 2003 16:00:00 UTC */
const INT4 S2StopTime = 734367613; /* Apr 14 2003 15:00:00 UTC */
#endif
/* command line options */
LIGOTimeGPS gpsStartTime = {S2StartTime, 0};
LIGOTimeGPS gpsEndTime = {S2StopTime, 0};
REAL8 meanTimeStep = 2630 / LAL_PI;
REAL8 timeInterval = 0;
UINT4 randSeed = 1;
CHAR *userTag = NULL;
REAL4 minMass = 3.0; /* minimum component mass */
REAL4 maxMass = 20.0; /* maximum component mass */
REAL4 sumMaxMass = 0.0; /* maximum total mass sum */
UINT4 sumMaxMassUse=0; /* flag indicating to use the sumMaxMass */
REAL4 dmin = 1.0; /* minimum distance from earth (kpc) */
REAL4 dmax = 20000.0 ; /* maximum distance from earth (kpc) */
REAL4 fLower = 0; /* default value for th lower cut off frequency */
/* REAL4 Rcore = 0.0; */
UINT4 ddistr = 0, mdistr=0;
/* program variables */
RandomParams *randParams = NULL;
REAL4 u, exponent, d2;
REAL4 deltaM, mtotal;
/* waveform */
CHAR waveform[LIGOMETA_WAVEFORM_MAX];
#if 0
int i, stat;
double d, cosphi, sinphi;
#endif
/* GalacticInspiralParamStruc galacticPar; */
/* xml output data */
CHAR fname[256];
MetadataTable proctable;
MetadataTable procparams;
MetadataTable injections;
ProcessParamsTable *this_proc_param;
SimInspiralTable *this_inj = NULL;
LIGOLwXMLStream xmlfp;
UINT4 outCompress = 0;
/* getopt arguments */
struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, &vrbflg, 1 },
{"write-compress", no_argument, &outCompress, 1 },
{"version", no_argument, 0, 'V'},
{"f-lower", required_argument, 0, 'f'},
{"gps-start-time", required_argument, 0, 'a'},
{"gps-end-time", required_argument, 0, 'b'},
{"time-step", required_argument, 0, 't'},
{"time-interval", required_argument, 0, 'i'},
{"seed", required_argument, 0, 's'},
{"min-mass", required_argument, 0, 'A'},
{"max-mass", required_argument, 0, 'B'},
{"max-total-mass", required_argument, 0, 'x'},
{"min-distance", required_argument, 0, 'p'},
{"max-distance", required_argument, 0, 'r'},
{"d-distr", required_argument, 0, 'd'},
{"m-distr", required_argument, 0, 'm'},
{"waveform", required_argument, 0, 'w'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{0, 0, 0, 0}
};
int c;
/* 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));
if (strcmp(CVS_REVISION,"$Revi" "sion$"))
{
XLALPopulateProcessTable(proctable.processTable,
PROGRAM_NAME, CVS_REVISION, CVS_SOURCE, CVS_DATE, 0);
}
else
{
XLALPopulateProcessTable(proctable.processTable,
PROGRAM_NAME, lalappsGitCommitID,
lalappsGitGitStatus,
lalappsGitCommitDate, 0);
}
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
/* clear the waveform field */
memset( waveform, 0, LIGOMETA_WAVEFORM_MAX * sizeof(CHAR) );
/*
*
* parse command line arguments
*
*/
while ( 1 )
{
/* getopt_long stores long option here */
int option_index = 0;
long int gpsinput;
size_t optarg_len;
c = getopt_long_only( argc, argv,
"a:A:b:B:d:f:hi:m:p:q:r:s:t:vZ:w:", 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 'a':
gpsinput = atol( optarg );
if ( gpsinput < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpsinput );
exit( 1 );
}
gpsStartTime.gpsSeconds = gpsinput;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gpsinput );
break;
case 'b':
gpsinput = atol( optarg );
if ( gpsinput < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpsinput );
exit( 1 );
}
gpsEndTime.gpsSeconds = gpsinput;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gpsinput );
break;
case 'f':
fLower = atof( optarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "float",
"%f", fLower );
break;
case 's':
randSeed = atoi( optarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%d", randSeed );
break;
case 't':
meanTimeStep = (REAL8) atof( optarg );
if ( meanTimeStep <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"time step must be > 0: (%e seconds specified)\n",
long_options[option_index].name, meanTimeStep );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "float",
"%e", meanTimeStep );
break;
case 'i':
timeInterval = atof( optarg );
if ( timeInterval < 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"time interval must be >= 0: (%e seconds specified)\n",
long_options[option_index].name, meanTimeStep );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", timeInterval );
break;
case 'A':
/* minimum component mass */
minMass = (REAL4) atof( optarg );
if ( minMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"miniumum component mass must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, minMass );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", minMass );
break;
case 'B':
/* maximum component mass */
maxMass = (REAL4) atof( optarg );
if ( maxMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"maxiumum component mass must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, maxMass );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", maxMass );
break;
case 'x':
/* maximum sum of components */
sumMaxMass = (REAL4) atof( optarg );
if ( sumMaxMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"sum of two component masses must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, sumMaxMass );
exit( 1 );
}
sumMaxMassUse=1;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", sumMaxMass );
break;
case 'p':
/* minimum distance from earth */
dmin = (REAL4) atof( optarg );
if ( dmin <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"minimum distance must be > 0: "
"(%f kpc specified)\n",
long_options[option_index].name, dmin );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", dmin );
break;
case 'r':
/* max distance from earth */
dmax = (REAL4) atof( optarg );
if ( dmax <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"maximum distance must be greater than 0: "
"(%f kpc specified)\n",
long_options[option_index].name, dmax );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", dmax );
break;
case 'd':
ddistr = (UINT4) atoi( optarg );
if ( ddistr != 0 && ddistr != 1 && ddistr != 2)
{
fprintf( stderr, "invalid argument to --%s:\n"
"DDISTR must be either 0 or 1 or 2\n",
long_options[option_index].name);
exit(1);
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"int", "%d", ddistr );
break;
case 'm':
mdistr = (UINT4) atoi( optarg );
if ( mdistr != 0 && mdistr != 1 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"MDISTR must be either 0 or 1\n",
long_options[option_index].name);
exit(1);
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"int", "%d", mdistr );
break;
case 'Z':
/* create storage for the usertag */
optarg_len = strlen( optarg ) + 1;
userTag = (CHAR *) calloc( optarg_len, sizeof(CHAR) );
memcpy( userTag, optarg, optarg_len );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"string", "%s", optarg );
break;
case 'w':
snprintf( waveform, LIGOMETA_WAVEFORM_MAX, "%s", optarg);
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "string",
"%s", optarg);
break;
case 'V':
/* print version information and exit */
fprintf( stdout, "Binary Black Hole INJection generation routine\n"
"Duncan A Brown and Eirini Messaritaki\n"
"CVS Version: " CVS_ID_STRING "\n"
"CVS Tag: " CVS_NAME_STRING "\n" );
fprintf( stdout, lalappsGitID );
exit( 0 );
break;
case 'h':
case '?':
fprintf( stderr, USAGE );
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 );
}
if ( !*waveform )
{
/* use EOBtwoPN as the default waveform */
snprintf( waveform, LIGOMETA_WAVEFORM_MAX, "EOBtwoPN");
}
if ( !fLower )
{
fprintf( stderr, "--f-lower must be specified and non-zero\n" );
exit( 1 );
}
/*
*
* initialization
*
*/
/* initialize the random number generator */
LAL_CALL( LALCreateRandomParams( &status, &randParams, randSeed ), &status );
/* mass range, per component */
deltaM = maxMass - minMass;
/* null out the head of the linked list */
injections.simInspiralTable = NULL;
/* create the output file name */
if ( userTag && outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d_%s-%d-%d.xml.gz",
randSeed, userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( userTag && !outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d_%s-%d-%d.xml",
randSeed, userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( !userTag && outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d-%d-%d.xml.gz",
randSeed, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d-%d-%d.xml",
randSeed, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
/*
*
* loop over duration of desired output times
*
*/
while ( XLALGPSCmp( &gpsStartTime, &gpsEndTime ) < 0 )
{
/* rho, z and lGal are the galactocentric galactic axial coordinates */
/* r and phi are the geocentric galactic spherical coordinates */
#if 0
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
galacticPar.lGal = LAL_TWOPI * u;
galacticPar.z = r * sinphi ;
galacticPar.rho = 0.0 - Rcore * cos(galacticPar.lGal) +
sqrt( r * r - galacticPar.z * galacticPar.z -
Rcore * Rcore * sin(galacticPar.lGal) * sin(galacticPar.lGal) );
#endif
#if 0
if ( vrbflg ) fprintf( stdout, "%e %e %e %e %e\n",
galacticPar.m1, galacticPar.m2,
galacticPar.rho * cos( galacticPar.lGal ),
galacticPar.rho * sin( galacticPar.lGal ),
galacticPar.z );
#endif
/* create the sim_inspiral table */
if ( injections.simInspiralTable )
{
this_inj = this_inj->next = (SimInspiralTable *)
LALCalloc( 1, sizeof(SimInspiralTable) );
}
else
{
injections.simInspiralTable = this_inj = (SimInspiralTable *)
LALCalloc( 1, sizeof(SimInspiralTable) );
}
/* set the geocentric end time of the injection */
/* XXX CHECK XXX */
this_inj->geocent_end_time = gpsStartTime;
if ( timeInterval )
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
XLALGPSAdd( &(this_inj->geocent_end_time), u * timeInterval );
}
/* set gmst */
this_inj->end_time_gmst = fmod(XLALGreenwichMeanSiderealTime(
&this_inj->geocent_end_time), LAL_TWOPI) * 24.0 / LAL_TWOPI; /* hours */
if( XLAL_IS_REAL8_FAIL_NAN(this_inj->end_time_gmst) )
{
fprintf(stderr, "XLALGreenwichMeanSiderealTime() failed\n");
exit(1);
}
/* XXX END CHECK XXX */
/* populate the sim_inspiral table */
if (mdistr == 1)
/* uniformly distributed mass1 and uniformly distributed mass2 */
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass1 = minMass + u * deltaM;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass2 = minMass + u * deltaM;
mtotal = this_inj->mass1 + this_inj->mass2 ;
this_inj->eta = this_inj->mass1 * this_inj->mass2 / ( mtotal * mtotal );
this_inj->mchirp = (this_inj->mass1 + this_inj->mass2) *
pow(this_inj->eta, 0.6);
}
else if (mdistr == 0)
/*uniformly distributed total mass */
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status);
mtotal = 2.0 * minMass + u * 2.0 *deltaM ;
if (sumMaxMassUse==1) {
while (mtotal > sumMaxMass) {
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status);
mtotal = 2.0 * minMass + u * 2.0 *deltaM ;
}
}
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass1 = minMass + u * deltaM;
this_inj->mass2 = mtotal - this_inj->mass1;
while (this_inj->mass1 >= mtotal ||
this_inj->mass2 >= maxMass || this_inj->mass2 <= minMass )
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->mass1 = minMass + u * deltaM;
this_inj->mass2 = mtotal - this_inj->mass1;
}
this_inj->eta = this_inj->mass1 * this_inj->mass2 / ( mtotal * mtotal );
this_inj->mchirp = (this_inj->mass1 + this_inj->mass2) *
pow(this_inj->eta, 0.6);
}
/* spatial distribution */
#if 0
LAL_CALL( LALUniformDeviate( &status, &u, randParams ),
&status );
sinphi = 2.0 * u - 1.0;
cosphi = sqrt( 1.0 - sinphi*sinphi );
#endif
if (ddistr == 0)
/* uniform distribution in distance */
{
REAL4 deltaD = dmax - dmin ;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->distance = dmin + deltaD * u ;
}
else if (ddistr == 1)
/* uniform distribution in log(distance) */
{
REAL4 lmin = log10(dmin);
REAL4 lmax = log10(dmax);
REAL4 deltaL = lmax - lmin;
LAL_CALL( LALUniformDeviate(&status,&u,randParams),&status );
exponent = lmin + deltaL * u;
this_inj->distance = pow(10.0,(REAL4) exponent);
}
else if (ddistr == 2)
/* uniform volume distribution */
{
REAL4 d2min = pow(dmin,3.0) ;
REAL4 d2max = pow(dmax,3.0) ;
REAL4 deltad2 = d2max - d2min ;
LAL_CALL( LALUniformDeviate(&status,&u,randParams),&status );
d2 = d2min + u * deltad2 ;
this_inj->distance = pow(d2,1.0/3.0);
}
this_inj->distance = this_inj->distance / 1000.0; /*convert to Mpc */
/* compute random longitude and latitude */
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->latitude = asin( 2.0 * u - 1.0 ) ;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->longitude = LAL_TWOPI * u ;
#if 0
LAL_CALL( LALGalacticInspiralParamsToSimInspiralTable( &status,
this_inj, &galacticPar, randParams ), &status );
if (vrbflg)
{
fprintf( stdout, "%e\n",
sqrt(galacticPar.z*galacticPar.z+galacticPar.rho*galacticPar.rho
+ Rcore*Rcore + 2.0*Rcore*galacticPar.rho*cos(galacticPar.lGal))-
this_inj->distance*1000.0);
}
#endif
/* set the source and waveform fields */
snprintf( this_inj->source, LIGOMETA_SOURCE_MAX, "???" );
memcpy( this_inj->waveform, waveform, LIGOMETA_WAVEFORM_MAX *
sizeof(CHAR));
/* XXX CHECK XXX */
/* compute random inclination, polarization and coalescence phase */
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->inclination = acos( 2.0 * u - 1.0 );
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->polarization = LAL_TWOPI * u ;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
this_inj->coa_phase = LAL_TWOPI * u ;
/* populate the site specific information */
LAL_CALL(LALPopulateSimInspiralSiteInfo( &status, this_inj ),
&status);
/* increment the injection time */
XLALGPSAdd( &gpsStartTime, meanTimeStep );
/* finally populate the flower */
if (fLower > 0)
{
this_inj->f_lower = fLower;
}
else
{
this_inj->f_lower = 0;
}
/* XXX END CHECK XXX */
} /* end loop over injection times */
/* destroy random parameters */
LAL_CALL( LALDestroyRandomParams( &status, &randParams ), &status );
/*
*
* write output to LIGO_LW XML file
*
*/
/* open the xml file */
memset( &xmlfp, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlfp, fname ), &status );
/* write the process table */
snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "H1H2L1" );
XLALGPSTimeNow(&(proctable.processTable->end_time));
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, process_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, proctable,
process_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
free( proctable.processTable );
/* free the unused process param entry */
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = procparams.processParamsTable->next;
free( this_proc_param );
/* write the process params table */
if ( procparams.processParamsTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, process_params_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, procparams,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
while( procparams.processParamsTable )
{
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
}
/* write the sim_inspiral table */
if ( injections.simInspiralTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, sim_inspiral_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, injections,
sim_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
}
while ( injections.simInspiralTable )
{
this_inj = injections.simInspiralTable;
injections.simInspiralTable = injections.simInspiralTable->next;
LALFree( this_inj );
}
/* close the injection file */
LAL_CALL( LALCloseLIGOLwXMLFile ( &status, &xmlfp ), &status );
/* check for memory leaks and exit */
LALCheckMemoryLeaks();
return 0;
}
int main( int argc, char *argv[] )
{
static LALStatus status;
LALPlaygroundDataMask dataType = unspecified_data_type;
SnglInspiralParameterTest test = unspecified_test;
INT4 startTime = -1;
LIGOTimeGPS startTimeGPS = {0,0};
INT4 endTime = -1;
LIGOTimeGPS endTimeGPS = {0,0};
INT4 startChunkTime = -1;
LIGOTimeGPS startChunkTimeGPS = {0,0};
INT4 endChunkTime = -1;
LIGOTimeGPS endChunkTimeGPS = {0,0};
int coherentRun = 0;
INT4 coherentBuffer = 64;
CHAR inputIFO[LIGOMETA_IFO_MAX];
CHAR outputIFO[LIGOMETA_IFO_MAX];
CHAR comment[LIGOMETA_COMMENT_MAX];
CHAR *userTag = NULL;
CHAR *ifoTag = NULL;
CHAR fileName[FILENAME_MAX];
INT4 numTriggers = 0;
SnglInspiralTable *inspiralEventList=NULL;
SnglInspiralTable *currentTrigger = NULL;
SearchSummvarsTable *inputFiles = NULL;
SearchSummvarsTable *thisInputFile = NULL;
SearchSummaryTable *searchSummList = NULL;
SearchSummaryTable *thisSearchSumm = NULL;
MetadataTable proctable;
MetadataTable processParamsTable;
MetadataTable searchsumm;
MetadataTable searchSummvarsTable;
MetadataTable inspiralTable;
ProcessParamsTable *this_proc_param = NULL;
LIGOLwXMLStream xmlStream;
INT4 outCompress = 0;
INT4 i;
/* LALgetopt arguments */
struct LALoption long_options[] =
{
{"verbose", no_argument, &vrbflg, 1 },
{"check-times", no_argument, &checkTimes, 1 },
{"write-compress", no_argument, &outCompress, 1 },
{"input-ifo", required_argument, 0, 'a'},
{"output-ifo", required_argument, 0, 'b'},
{"parameter-test", required_argument, 0, 'A'},
{"data-type", required_argument, 0, 'D'},
{"gps-start-time", required_argument, 0, 'q'},
{"gps-end-time", required_argument, 0, 'r'},
{"comment", required_argument, 0, 's'},
{"coherent-run", no_argument, &coherentRun, 1 },
{"coherent-buffer", required_argument, &coherentBuffer, 't'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{"ifo-tag", required_argument, 0, 'I'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{0, 0, 0, 0}
};
int c;
/*
*
* initialize things
*
*/
lal_errhandler = LAL_ERR_EXIT;
setvbuf( stdout, NULL, _IONBF, 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 = processParamsTable.processParamsTable =
(ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) );
memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) );
/* create the search summary and zero out the summvars table */
searchsumm.searchSummaryTable = (SearchSummaryTable *)
calloc( 1, sizeof(SearchSummaryTable) );
/* parse the arguments */
while ( 1 )
{
/* LALgetopt_long stores long option here */
int option_index = 0;
long int gpstime;
size_t LALoptarg_len;
c = LALgetopt_long_only( argc, argv,
"a:b:hq:r:s:t:A:I: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 'a':
/* name of input ifo*/
strncpy( inputIFO, LALoptarg, LIGOMETA_IFO_MAX );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'b':
/* name of output ifo */
strncpy( outputIFO, LALoptarg, LIGOMETA_IFO_MAX );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'A':
/* comparison used to test for uniqueness of triggers */
if ( ! strcmp( "m1_and_m2", LALoptarg ) )
{
test = m1_and_m2;
}
else if ( ! strcmp( "psi0_and_psi3", LALoptarg ) )
{
test = psi0_and_psi3;
}
else if ( ! strcmp( "mchirp_and_eta", LALoptarg ) )
{
fprintf( stderr, "invalid argument to --%s:\n"
"mchirp_and_eta test specified, not implemented for trigbank: "
"%s (must be m1_and_m2, psi0_and_psi3, no_test)\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
else if ( ! strcmp( "no_test", LALoptarg ) )
{
test = no_test;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown test specified: "
"%s (must be m1_and_m2, psi0_and_psi3,no_test, or mchirp_and_eta)\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'D':
/* 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 'q':
/* start time */
gpstime = atol( LALoptarg );
if ( gpstime < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpstime );
exit( 1 );
}
startTime = (INT4) gpstime;
startTimeGPS.gpsSeconds = startTime;
ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, startTime );
break;
case 'r':
/* end time */
gpstime = atol( LALoptarg );
if ( gpstime < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpstime );
exit( 1 );
}
endTime = (INT4) gpstime;
endTimeGPS.gpsSeconds = endTime;
ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, endTime );
break;
case 's':
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 't':
coherentBuffer = (INT4) atoi( LALoptarg );
if ( coherentBuffer < 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"coherent-buffer duration (sec) must be positive or zero: "
"(%d specified)\n",
long_options[option_index].name, coherentBuffer );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%d", coherentBuffer );
break;
case 'h':
/* help message */
print_usage(argv[0]);
exit( 1 );
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 'I':
/* create storage for the ifo-tag */
LALoptarg_len = strlen(LALoptarg) + 1;
ifoTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) );
memcpy( ifoTag, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case 'V':
/* print version information and exit */
fprintf( stdout, "Inspiral Triggered Bank Generator\n"
"Patrick Brady, Duncan Brown and Steve Fairhurst\n");
XLALOutputVersionString(stderr, 0);
exit( 0 );
break;
case '?':
print_usage(argv[0]);
exit( 1 );
break;
default:
fprintf( stderr, "Error: Unknown error while parsing options\n" );
print_usage(argv[0]);
exit( 1 );
}
}
/* check the values of the arguments */
if ( startTime < 0 )
{
fprintf( stderr, "Error: --gps-start-time must be specified\n" );
exit( 1 );
}
if ( endTime < 0 )
{
fprintf( stderr, "Error: --gps-end-time must be specified\n" );
exit( 1 );
}
if ( dataType == unspecified_data_type )
{
fprintf( stderr, "Error: --data-type must be specified\n");
exit(1);
}
if ( test == unspecified_test )
{
fprintf( stderr, "Error: --parameter-test must be specified\n");
exit(1);
}
/* fill the comment, if a user has specified one, or leave it blank */
if ( ! *comment )
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX,
" " );
}
else
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX,
"%s", comment );
snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX,
"%s", comment );
}
/* store the check-times in the process_params table */
if ( checkTimes )
{
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, "--check-times");
snprintf( this_proc_param->type, LIGOMETA_TYPE_MAX, "string" );
snprintf( this_proc_param->value, LIGOMETA_TYPE_MAX, " " );
}
/* delete the first, empty process_params entry */
this_proc_param = processParamsTable.processParamsTable;
processParamsTable.processParamsTable =
processParamsTable.processParamsTable->next;
free( this_proc_param );
/*
*
* read in the input data from the rest of the arguments
*
*/
if ( LALoptind < argc )
{
for( i = LALoptind; i < argc; ++i )
{
INT4 numFileTriggers = 0;
numFileTriggers = XLALReadInspiralTriggerFile( &inspiralEventList,
¤tTrigger, &searchSummList, &inputFiles, argv[i] );
if (numFileTriggers < 0)
{
fprintf(stderr, "Error reading triggers from file %s",
argv[i]);
exit( 1 );
}
numTriggers += numFileTriggers;
}
}
else
{
fprintf( stderr, "Error: No trigger files specified.\n" );
exit( 1 );
}
if ( vrbflg ) fprintf( stdout, "Read in a total of %d triggers.\n",
numTriggers );
/* check that we have read in data for all the requested time */
if ( checkTimes )
{
if ( vrbflg ) fprintf( stdout,
"Checking that we have data for all times from %s\n",
inputIFO);
LAL_CALL( LALCheckOutTimeFromSearchSummary ( &status, searchSummList,
inputIFO, &startTimeGPS, &endTimeGPS ), &status);
}
if ( ! inspiralEventList )
{
/* no triggers read in so triggered bank will be empty */
fprintf( stdout, "No triggers read in\n");
/* set numTriggers in case any cuts are made in future */
numTriggers = 0;
goto cleanexit;
}
/* keep only triggers from input ifo */
LAL_CALL( LALIfoCutSingleInspiral( &status, &inspiralEventList, inputIFO ),
&status );
/* time sort the triggers */
if ( vrbflg ) fprintf( stdout, "Sorting triggers\n" );
LAL_CALL( LALSortSnglInspiral( &status, &inspiralEventList,
LALCompareSnglInspiralByTime ), &status );
/* keep only triggers within the requested interval */
if ( vrbflg ) fprintf( stdout,
"Discarding triggers outside requested interval\n" );
if ( coherentRun ) {
startChunkTime = startTimeGPS.gpsSeconds + coherentBuffer;
startChunkTimeGPS.gpsSeconds = startChunkTime;
endChunkTime = endTimeGPS.gpsSeconds - coherentBuffer;
endChunkTimeGPS.gpsSeconds = endChunkTime;
LAL_CALL( LALTimeCutSingleInspiral( &status, &inspiralEventList,
&startChunkTimeGPS, &endChunkTimeGPS), &status );
}
else {
LAL_CALL( LALTimeCutSingleInspiral( &status, &inspiralEventList,
&startTimeGPS, &endTimeGPS), &status );
}
/* keep play/non-play/all triggers */
if ( dataType == playground_only && vrbflg ) fprintf( stdout,
"Keeping only playground triggers\n" );
else if ( dataType == exclude_play && vrbflg ) fprintf( stdout,
"Keeping only non-playground triggers\n" );
else if ( dataType == all_data && vrbflg ) fprintf( stdout,
"Keeping all triggers\n" );
LAL_CALL( LALPlayTestSingleInspiral( &status, &inspiralEventList,
&dataType ), &status );
if( !inspiralEventList )
{
if ( vrbflg ) fprintf( stdout,
"No triggers remain after time and playground cuts.\n" );
/* set numTriggers after cuts were applied */
numTriggers = 0;
goto cleanexit;
}
/* Generate the triggered bank */
if( test != no_test )
{
LAL_CALL( LALCreateTrigBank( &status, &inspiralEventList, &test ),
&status );
}
/* count the number of triggers */
for( currentTrigger = inspiralEventList, numTriggers = 0; currentTrigger;
currentTrigger = currentTrigger->next, ++numTriggers);
if ( vrbflg ) fprintf( stdout, "%d triggers to be written to trigbank.\n",
numTriggers );
/*
*
* write the output xml file
*
*/
cleanexit:
/* search summary entries: */
searchsumm.searchSummaryTable->in_start_time = startTimeGPS;
searchsumm.searchSummaryTable->in_end_time = endTimeGPS;
searchsumm.searchSummaryTable->out_start_time = startTimeGPS;
searchsumm.searchSummaryTable->out_end_time = endTimeGPS;
searchsumm.searchSummaryTable->nevents = numTriggers;
if ( vrbflg ) fprintf( stdout, "writing output file... " );
/* set the file name correctly */
if ( userTag && ifoTag && !outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s_%s-%d-%d.xml",
outputIFO, ifoTag, userTag, startTime, endTime - startTime );
}
else if ( userTag && !ifoTag && !outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml",
outputIFO, userTag, startTime, endTime - startTime );
}
else if ( !userTag && ifoTag && !outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml",
outputIFO, ifoTag, startTime, endTime - startTime );
}
else if ( userTag && ifoTag && outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s_%s-%d-%d.xml.gz",
outputIFO, ifoTag, userTag, startTime, endTime - startTime );
}
else if ( userTag && !ifoTag && outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml.gz",
outputIFO, userTag, startTime, endTime - startTime );
}
else if ( !userTag && ifoTag && outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK_%s-%d-%d.xml.gz",
outputIFO, ifoTag, startTime, endTime - startTime );
}
else if ( !userTag && !ifoTag && outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK-%d-%d.xml.gz",
outputIFO, startTime, endTime - startTime );
}
else
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGBANK-%d-%d.xml",
outputIFO, startTime, endTime - startTime );
}
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status , &xmlStream, fileName ),
&status );
/* write process table */
snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "%s",
inputIFO );
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 );
/* write process_params table */
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
process_params_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, processParamsTable,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* write search_summary table */
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
search_summary_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchsumm,
search_summary_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* write the search_summvars tabls */
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 the sngl_inspiral table */
if ( inspiralEventList )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream,
sngl_inspiral_table), &status );
inspiralTable.snglInspiralTable = inspiralEventList;
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, inspiralTable,
sngl_inspiral_table), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status );
}
LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
/*
*
* clean up the memory that has been allocated
*
*/
if ( vrbflg ) fprintf( stdout, "freeing memory... " );
free( proctable.processTable );
free( searchsumm.searchSummaryTable );
while ( processParamsTable.processParamsTable )
{
this_proc_param = processParamsTable.processParamsTable;
processParamsTable.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
while ( inputFiles )
{
thisInputFile = inputFiles;
inputFiles = thisInputFile->next;
LALFree( thisInputFile );
}
while ( searchSummList )
{
thisSearchSumm = searchSummList;
searchSummList = searchSummList->next;
LALFree( thisSearchSumm );
}
while ( inspiralEventList )
{
currentTrigger = inspiralEventList;
inspiralEventList = inspiralEventList->next;
LAL_CALL( LALFreeSnglInspiral( &status, ¤tTrigger ), &status );
}
if ( userTag ) free( userTag );
if ( ifoTag ) free( ifoTag );
if ( vrbflg ) fprintf( stdout, "done\n" );
LALCheckMemoryLeaks();
exit( 0 );
}
int main ( int argc, char *argv[] )
{
/* xml output data */
CHAR fname[256];
CHAR *userTag = NULL;
LALStatus status = blank_status;
MetadataTable proctable;
MetadataTable procparams;
MetadataTable injections;
SimInspiralTable injParams;
ProcessParamsTable *this_proc_param;
LIGOLwXMLStream xmlfp;
/* default sky position */
SkyPosition binaryPosition;
struct LALoption long_options[] =
{
{"help", no_argument, 0, 'H'},
{"end-time", required_argument, 0, 'a'},
{"end-time-ns", required_argument, 0, 'b'},
{"mass-1", required_argument, 0, 'c'},
{"mass-2", required_argument, 0, 'd'},
{"distance", required_argument, 0, 'e'},
{"longitude", required_argument, 0, 'f'},
{"latitude", required_argument, 0, 'g'},
{"coordinate-system", required_argument, 0, 'h'},
{"inclinaton", required_argument, 0, 'i'},
{"coalescence-phase", required_argument, 0, 'j'},
{"polarization", required_argument, 0, 'k'},
{"waveform," required_argument, 0, 'l'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{0, 0, 0, 0}
};
int c;
/* 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));
if (strcmp(CVS_REVISION,"$Revi" "sion$"))
{
XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME,
CVS_REVISION, CVS_SOURCE, CVS_DATE, 0);
}
else
{
XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME,
lalappsGitCommitID, lalappsGitGitStatus, lalappsGitCommitDate, 0);
}
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
/* clear the waveform field */
memset( &(injParams.waveform), 0, LIGOMETA_WAVEFORM_MAX * sizeof(CHAR) );
/* set the default values */
injParams.mass1 = 1.4;
injParams.mass2 = 1.4;
injParams.eta = 0.25;
injParams.distance = 1.0;
injParams.inclination = 0;
injParams.coa_phase = 0;
injParams.polarization = 0;
/* parse the arguments */
while ( 1 )
{
/* LALgetopt_long stores long option here */
int option_index = 0;
long int gpsinput;
size_t LALoptarg_len;
c = LALgetopt_long_only( argc, argv,
"Ha:b:c:d:e:f:g:h:i:j:k:l:Z:", 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 'a':
{
long int gendsec = atol( LALoptarg );
if ( gendsec < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gendsec );
exit( 1 );
}
injParams.geocent_end_time.gpsSeconds = (INT4) gendsec;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gendsec );
}
break;
case 'b':
{
long int gendnansec = atol( LALoptarg );
if ( gendnansec < 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time nanoseconds is negative\n",
long_options[option_index].name );
exit( 1 );
}
if ( gendnansec > 999999999 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time nanoseconds is greater than unity:\n"
"Must be <= 999999999 (%ld specified)\n",
long_options[option_index].name, gendnansec );
exit( 1 );
}
injParams.geocent_end_time.gpsNanoSeconds = (INT4) gendnansec;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gendnansec );
}
break;
case 'c':
injParams.mass1 = (REAL4) atof( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "real_4",
"%d", rand_seed );
break;
case 'd':
injParams.mass2 = (REAL4) atof( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "real_4",
"%d", rand_seed );
break;
case 'e':
injParams.distance = (REAL4) atof( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "real_4",
"%d", rand_seed );
break;
case 'f':
abort();
break;
case 'g':
abort();
break;
case 'h':
abort();
break;
case 'i':
injParams.inclination = (REAL4) atof( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "real_4",
"%d", rand_seed );
break;
case 'j':
injParams.coa_phase= (REAL4) atof( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "real_4",
"%d", rand_seed );
break;
case 'k':
injParams.polarization = (REAL4) atof( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "real_4",
"%d", rand_seed );
break;
case 'l':
snprintf( &(injParams.waveform),
LIGOMETA_WAVEFORM_MAX, "%s", LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "string",
"%s", LALoptarg );
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 'h':
fprintf( stderr, USAGE );
exit( 0 );
break;
case '?':
fprintf( stderr, USAGE );
exit( 1 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
fprintf( stderr, USAGE );
exit( 1 );
}
}
if ( ! *waveform )
{
/* default to Tev's GeneratePPNInspiral as used in */
snprintf( waveform, LIGOMETA_WAVEFORM_MAX, "GeneratePPNtwoPN" );
}
/* program entry point */
INT4 main(INT4 argc, CHAR *argv[])
{
/* lal initialisation variables */
LALStatus status = blank_status;
/* xml */
CHAR baseName[FILENAME_MAX];
StochasticTable *stochHead = NULL;
StochasticTable *thisStoch = NULL;
/* counter */
INT4 i;
/* data structures */
REAL4TimeSeries *seriesOne;
REAL4TimeSeries *seriesTwo;
REAL4FrequencySeries *overlap;
REAL4FrequencySeries *mask;
REAL4FrequencySeries *omegaGW;
REAL4Window *dataWindow;
LIGOTimeGPS gpsStartTime;
LIGOTimeGPS gpsEndTime;
/* variables */
INT4 numSegments;
INT4 duration, durationEff, extrasec;
INT4 segsInInt;
INT4 segmentLength;
INT4 padData;
REAL8 deltaF;
INT4 filterLength;
INT4 numFMin;
INT4 numFMax;
/* error handler */
status.statusPtr = NULL;
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, prog_name, \
lalAppsVCSIdentInfo.vcsId, lalAppsVCSIdentInfo.vcsStatus, lalAppsVCSIdentInfo.vcsDate, 0);
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *) \
calloc(1, sizeof(ProcessParamsTable));
memset(comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR));
/* parse command line options */
parse_options(argc, argv);
/* get xml file basename */
if (userTag)
{
snprintf(baseName, FILENAME_MAX, "%s%s-STOCHASTIC_%s_%d-%d", \
ifoOne, ifoTwo, userTag, startTime, (endTime - startTime));
}
else
{
snprintf(baseName, FILENAME_MAX, "%s%s-STOCHASTIC-%d-%d", \
ifoOne, ifoTwo, startTime, (endTime - startTime));
}
/* get number of segments */
duration = endTime - startTime;
numSegments = duration / segmentDuration;
segsInInt = intervalDuration / segmentDuration;
/* recentre */
if (recentre_flag)
{
if (vrbflg)
fprintf(stdout, "Recentring within data stream...\n");
durationEff = numSegments * segmentDuration;
extrasec = duration - durationEff;
startTime += extrasec / 2;
endTime = startTime + durationEff;
}
/* add a resample buffer, if required */
if ((resampleRate) || (high_pass_flag))
padData = 1;
else
padData = 0;
/* initialise gps time structures */
gpsStartTime.gpsSeconds = startTime;
gpsStartTime.gpsNanoSeconds = 0;
gpsEndTime.gpsSeconds = endTime;
gpsEndTime.gpsNanoSeconds = 0;
/* read data */
seriesOne = get_time_series(ifoOne, frameCacheOne, channelOne, \
gpsStartTime, gpsEndTime, resampleRate, highPassOrder, highPassFreq, \
highPassAtten, geoHighPassOrder, geoHighPassFreq, geoHighPassAtten, \
padData);
seriesTwo = get_time_series(ifoTwo, frameCacheTwo, channelTwo, \
gpsStartTime, gpsEndTime, resampleRate, highPassOrder, highPassFreq, \
highPassAtten, geoHighPassOrder, geoHighPassFreq, geoHighPassAtten, \
padData);
/* check that the two series have the same sample rate */
if (seriesOne->deltaT != seriesTwo->deltaT)
{
fprintf(stderr, "Series have different sample rates...\n");
exit(1);
}
else
{
/* get resample rate, if required */
if (!resampleRate)
resampleRate = (INT4)(1./seriesOne->deltaT);
}
/* get deltaF for optimal filter */
deltaF = 1./(REAL8)PSD_WINDOW_DURATION;
/* get bins for min and max frequencies */
numFMin = (INT4)(fMin / deltaF);
numFMax = (INT4)(fMax / deltaF);
/* get lengths */
filterLength = numFMax - numFMin + 1;
segmentLength = segmentDuration * resampleRate;
if (vrbflg)
fprintf(stdout, "Generating data segment window...\n");
/* for overlapping hann windows, the hann window length is the segment
* length */
if (overlap_hann_flag)
hannDuration = segmentDuration;
/* create window for data */
dataWindow = data_window(seriesOne->deltaT, segmentLength, hannDuration);
/* generate overlap reduction function */
if (vrbflg)
fprintf(stdout, "Generating the overlap reduction function...\n");
overlap = overlap_reduction_function(&status, filterLength, fMin, deltaF, \
siteOne, siteTwo);
/* generate omegaGW */
if (vrbflg)
fprintf(stdout, "Generating spectrum for optimal filter...\n");
omegaGW = omega_gw(&status, alpha, fRef, omegaRef, filterLength, \
fMin, deltaF);
/* frequency mask */
if (apply_mask_flag)
{
if (vrbflg)
fprintf(stdout, "Applying frequency mask to spectrum..\n");
/* generate frequency mask */
mask = frequency_mask(fMin, deltaF, filterLength, maskBin);
/* apply mask to omegaGW */
for (i = 0; i < filterLength; i++)
omegaGW->data->data[i] *= mask->data->data[i];
/* destroy frequency mask */
XLALDestroyREAL4FrequencySeries(mask);
}
/* perform search */
stochHead = stochastic_search(&status, seriesOne, seriesTwo, overlap, \
omegaGW, dataWindow, numSegments, filterLength, segmentDuration, \
segsInInt, segmentLength, PSD_WINDOW_DURATION, ifoOne, ifoTwo, \
channelOne, channelTwo, calCacheOne, calCacheTwo, calibOffset, \
fMin, fMax, fRef);
/* save out xml table */
save_xml_file(&status, prog_name, outputPath, baseName, \
stochHead, proctable, procparams, this_proc_param, comment);
/* cleanup */
XLALDestroyREAL4FrequencySeries(overlap);
XLALDestroyREAL4FrequencySeries(omegaGW);
XLALDestroyREAL4Window(dataWindow);
XLALDestroyREAL4TimeSeries(seriesOne);
XLALDestroyREAL4TimeSeries(seriesTwo);
/* free memory used in the stochastic xml table */
while(stochHead)
{
thisStoch = stochHead;
stochHead = stochHead->next;
LALFree(thisStoch);
}
/* free calloc'd memory */
if (strcmp(frameCacheOne, frameCacheTwo))
{
free(frameCacheOne);
free(frameCacheTwo);
}
else
{
free(frameCacheOne);
}
free(calCacheOne);
free(calCacheTwo);
free(channelOne);
free(channelTwo);
free(ifoOne);
free(ifoTwo);
free(userTag);
free(outputPath);
/* check for memory leaks and exit */
LALCheckMemoryLeaks();
exit(0);
}
int main ( int argc, char *argv[] )
{
/* lal function variables */
LALStatus status = blank_status;
/* templates */
RandomParams *randParams = NULL;
InspiralTemplate newTmplt;
SnglInspiralTable *thisTmplt = NULL;
/* output data */
MetadataTable templateBank;
MetadataTable proctable;
MetadataTable procparams;
MetadataTable searchsummvars;
SearchSummvarsTable *this_search_summvar = NULL;
ProcessParamsTable *this_proc_param = NULL;
LIGOLwXMLStream results;
/* counters and other variables */
INT4 i;
CHAR fname[256];
/*
*
* 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, lalAppsVCSIdentInfo.vcsId,
lalAppsVCSIdentInfo.vcsStatus, lalAppsVCSIdentInfo.vcsDate, 0);
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
/* call the argument parse and check function */
arg_parse_check( argc, argv, procparams );
/* can use LALMalloc() / LALCalloc() from here */
/*
*
* create the radom number seed
*
*/
/* store the seed in the search summvars table */
this_search_summvar = searchsummvars.searchSummvarsTable =
(SearchSummvarsTable *) LALCalloc( 1, sizeof(SearchSummvarsTable) );
snprintf( this_search_summvar->name,
LIGOMETA_NAME_MAX, "template bank simulation seed" );
if ( randSeedType == urandom )
{
FILE *fpRand = NULL;
INT4 randByte;
if ( vrbflg )
fprintf( stdout, "obtaining random seed from /dev/urandom: " );
randomSeed = 0;
fpRand = fopen( "/dev/urandom", "r" );
if ( fpRand )
{
for ( randByte = 0; randByte < 4 ; ++randByte )
{
INT4 tmpSeed = (INT4) fgetc( fpRand );
randomSeed += tmpSeed << ( randByte * 8 );
}
fclose( fpRand );
}
else
{
perror( "error obtaining random seed from /dev/urandom" );
exit( 1 );
}
}
else if ( randSeedType == user )
{
if ( vrbflg )
fprintf( stdout, "using user specified random seed: " );
}
this_search_summvar->value = randomSeed;
snprintf( this_search_summvar->string, LIGOMETA_STRING_MAX,
"%d", randomSeed );
if ( vrbflg ) fprintf( stdout, "%d\n", randomSeed );
/* create the tmplt bank random parameter structure */
LAL_CALL( LALCreateRandomParams( &status, &randParams, randomSeed ),
&status );
/*
*
* create a random template bank
*
*/
/* make sure the pointer to the first template is null */
templateBank.snglInspiralTable = NULL;
for ( i = 0; i < numTmplts; ++i )
{
memset( &newTmplt, 0, sizeof(InspiralTemplate) );
newTmplt.massChoice = m1Andm2;
newTmplt.order = LAL_PNORDER_TWO;
newTmplt.fLower = fLow;
/* set up the injection masses */
if ( maxMass == minMass )
{
newTmplt.mass1 = (REAL8) maxMass;
newTmplt.mass2 = (REAL8) maxMass;
}
else
{
REAL4 mass;
/* generate random parameters for the injection */
LAL_CALL( LALUniformDeviate( &status, &mass, randParams ), &status );
newTmplt.mass1 = (maxMass - minMass) * mass;
newTmplt.mass1 += minMass;
LAL_CALL( LALUniformDeviate( &status, &mass, randParams ), &status );
newTmplt.mass2 = (maxMass - minMass) * mass;
newTmplt.mass2 += minMass;
}
LAL_CALL( LALInspiralParameterCalc( &status, &newTmplt ), &status );
if ( ! templateBank.snglInspiralTable )
{
thisTmplt = templateBank.snglInspiralTable =
(SnglInspiralTable *) LALCalloc(1, sizeof(SnglInspiralTable));
}
else
{
thisTmplt = thisTmplt->next =
(SnglInspiralTable *) LALCalloc(1, sizeof(SnglInspiralTable));
}
thisTmplt->mass1 = newTmplt.mass1;
thisTmplt->mass2 = newTmplt.mass2;
thisTmplt->mchirp = newTmplt.chirpMass;
thisTmplt->eta = newTmplt.eta;
thisTmplt->tau0 = newTmplt.t0;
thisTmplt->tau2 = newTmplt.t2;
thisTmplt->tau3 = newTmplt.t3;
thisTmplt->tau4 = newTmplt.t4;
thisTmplt->tau5 = newTmplt.t5;
thisTmplt->ttotal = newTmplt.tC;
thisTmplt->psi0 = newTmplt.psi0;
thisTmplt->psi3 = newTmplt.psi3;
thisTmplt->f_final = newTmplt.fFinal;
thisTmplt->eta = newTmplt.eta;
thisTmplt->beta = newTmplt.beta;
snprintf( thisTmplt->ifo, LIGOMETA_IFO_MAX, "P1" );
snprintf( thisTmplt->search, LIGOMETA_SEARCH_MAX, "randombank" );
snprintf( thisTmplt->channel, LIGOMETA_CHANNEL_MAX, "SIM-BANK" );
}
/*
*
* write the output data
*
*/
/* open the output xml file */
memset( &results, 0, sizeof(LIGOLwXMLStream) );
if ( userTag && !outCompress )
{
snprintf( fname, sizeof(fname), "P1-TMPLTBANK_%s-%d-%d.xml",
userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( userTag && outCompress )
{
snprintf( fname, sizeof(fname), "P1-TMPLTBANK_%s-%d-%d.xml.gz",
userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( !userTag && outCompress )
{
snprintf( fname, sizeof(fname), "P1-TMPLTBANK-%d-%d.xml.gz",
gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else
{
snprintf( fname, sizeof(fname), "P1-TMPLTBANK-%d-%d.xml",
gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &results, fname ), &status );
/* write the process table */
snprintf( proctable.processTable->ifos, LIGOMETA_IFO_MAX, "P1" );
XLALGPSTimeNow(&(proctable.processTable->end_time));
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &results, process_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &results, proctable,
process_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &results ), &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 */
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &results, process_params_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &results, procparams,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &results ), &status );
while( procparams.processParamsTable )
{
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
/* write the search summvars table */
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &results,
search_summvars_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &results, searchsummvars,
search_summvars_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &results ), &status );
while( searchsummvars.searchSummvarsTable )
{
this_search_summvar = searchsummvars.searchSummvarsTable;
searchsummvars.searchSummvarsTable = this_search_summvar->next;
LALFree( this_search_summvar );
}
/* write the template bank to the file */
if ( templateBank.snglInspiralTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &results, sngl_inspiral_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &results, templateBank,
sngl_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &results ), &status );
}
while ( templateBank.snglInspiralTable )
{
thisTmplt = templateBank.snglInspiralTable;
templateBank.snglInspiralTable = templateBank.snglInspiralTable->next;
LALFree( thisTmplt );
}
/* close the output xml file */
LAL_CALL( LALCloseLIGOLwXMLFile ( &status, &results ), &status );
/* free the rest of the memory, check for memory leaks and exit */
LAL_CALL( LALDestroyRandomParams( &status, &randParams ), &status );
LALCheckMemoryLeaks();
exit( 0 );
}
int main(int argc, char *argv[])
{
struct options options;
INT8 tinj, jitter;
gsl_rng *rng;
ProcessTable *process_table_head = NULL, *process;
ProcessParamsTable *process_params_table_head = NULL;
SearchSummaryTable *search_summary_table_head = NULL, *search_summary;
TimeSlide *time_slide_table_head = NULL;
SimBurst *sim_burst_table_head = NULL;
SimBurst **sim_burst = &sim_burst_table_head;
/*
* Initialize debug handler
*/
lal_errhandler = LAL_ERR_EXIT;
/*
* Process table
*/
process_table_head = process = XLALCreateProcessTableRow();
if(XLALPopulateProcessTable(process, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0))
exit(1);
XLALGPSTimeNow(&process->start_time);
/*
* Command line and process params table.
*/
options = parse_command_line(&argc, &argv, process, &process_params_table_head);
if(options.user_tag)
snprintf(process->comment, sizeof(process->comment), "%s", options.user_tag);
/*
* Search summary table
*/
search_summary_table_head = search_summary = XLALCreateSearchSummaryTableRow(process);
if(options.user_tag)
snprintf(search_summary->comment, sizeof(search_summary->comment), "%s", options.user_tag);
search_summary->nnodes = 1;
search_summary->out_start_time = *XLALINT8NSToGPS(&search_summary->in_start_time, options.gps_start_time);
search_summary->out_end_time = *XLALINT8NSToGPS(&search_summary->in_end_time, options.gps_end_time);
/*
* Initialize random number generator
*/
rng = gsl_rng_alloc(gsl_rng_mt19937);
if(options.seed)
gsl_rng_set(rng, options.seed);
/*
* Main loop
*/
for(tinj = options.gps_start_time; tinj <= options.gps_end_time; tinj += options.time_step * 1e9) {
/*
* Progress bar.
*/
XLALPrintInfo("%s: ", argv[0]);
XLALPrintProgressBar((tinj - options.gps_start_time) / (double) (options.gps_end_time - options.gps_start_time));
XLALPrintInfo(" complete\n");
/*
* Create an injection
*/
switch(options.population) {
case POPULATION_TARGETED:
*sim_burst = random_directed_btlwnb(options.ra, options.dec, gsl_ran_flat(rng, 0, LAL_TWOPI), options.minf, options.maxf, options.minbandwidth, options.maxbandwidth, options.minduration, options.maxduration, options.minEoverr2, options.maxEoverr2, rng);
break;
case POPULATION_ALL_SKY_SINEGAUSSIAN:
*sim_burst = random_all_sky_sineGaussian(options.minf, options.maxf, options.q, options.minhrss, options.maxhrss, rng);
break;
case POPULATION_ALL_SKY_BTLWNB:
*sim_burst = random_all_sky_btlwnb(options.minf, options.maxf, options.minbandwidth, options.maxbandwidth, options.minduration, options.maxduration, options.minEoverr2, options.maxEoverr2, rng);
break;
case POPULATION_STRING_CUSP:
*sim_burst = random_string_cusp(options.minf, options.maxf, options.minA, options.maxA, rng);
break;
default:
/* shouldn't get here, command line parsing code
* should prevent it */
XLALPrintError("internal error\n");
exit(1);
}
if(!*sim_burst) {
XLALPrintError("can't make injection\n");
exit(1);
}
/*
* Peak time at geocentre in GPS seconds
*/
/* Add "jitter" to the injection if user requests it */
if(options.jitter > 0) {
jitter = gsl_ran_flat(rng, -options.jitter/2, options.jitter/2)*1e9;
} else {
jitter = 0;
}
XLALINT8NSToGPS(&(*sim_burst)->time_geocent_gps, tinj + jitter);
/*
* Peak time at geocentre in GMST radians
*/
(*sim_burst)->time_geocent_gmst = XLALGreenwichMeanSiderealTime(&(*sim_burst)->time_geocent_gps);
/*
* Move to next injection
*/
sim_burst = &(*sim_burst)->next;
}
XLALPrintInfo("%s: ", argv[0]);
XLALPrintProgressBar(1.0);
XLALPrintInfo(" complete\n");
/* load time slide document and merge our table rows with its */
if(load_tisl_file_and_merge(options.time_slide_file, &process_table_head, &process_params_table_head, &time_slide_table_head, &search_summary_table_head, &sim_burst_table_head))
exit(1);
if(set_instruments(process, time_slide_table_head))
exit(1);
snprintf(search_summary->ifos, sizeof(search_summary->ifos), "%s", process->ifos);
/* output */
XLALGPSTimeNow(&process->end_time);
search_summary->nevents = XLALSimBurstAssignIDs(sim_burst_table_head, process->process_id, time_slide_table_head->time_slide_id, 0);
write_xml(options.output, process_table_head, process_params_table_head, search_summary_table_head, time_slide_table_head, sim_burst_table_head);
/* done */
gsl_rng_free(rng);
XLALDestroyProcessTable(process_table_head);
XLALDestroyProcessParamsTable(process_params_table_head);
XLALDestroyTimeSlideTable(time_slide_table_head);
XLALDestroySearchSummaryTable(search_summary_table_head);
XLALDestroySimBurstTable(sim_burst_table_head);
exit(0);
}
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 function variables */
LALStatus status = blank_status;
/* template bank generation parameters */
CHAR *bankFileName = NULL;
INT4 numOutBanks = 0;
REAL4 minMatch = -1;
/* output data */
MetadataTable inputBank;
MetadataTable outputBank;
MetadataTable proctable;
MetadataTable procparams;
ProcessParamsTable *this_proc_param = NULL;
LIGOLwXMLStream xmlStream;
/* counters and other variables */
INT4 i, j;
INT4 numTmplts = 0;
INT4 numTmpltsWritten = 0;
INT4 numPerFile = 0;
CHAR *gpsHyphen;
char outBankFileName[FILENAME_MAX];
CHAR bankFileNameHead[FILENAME_MAX];
CHAR bankFileNameTail[FILENAME_MAX];
CHAR comment[LIGOMETA_COMMENT_MAX];
CHAR *userTag = NULL;
SnglInspiralTable *thisTmplt = NULL;
SnglInspiralTable *tmpTmplt = NULL;
/* LALgetopt arguments */
struct LALoption long_options[] =
{
{"verbose", no_argument, &vrbflg, 1 },
{"version", no_argument, 0, 'V'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{"comment", required_argument, 0, 's'},
{"help", no_argument, 0, 'h'},
{"bank-file", required_argument, 0, 'v'},
{"number-of-banks", required_argument, 0, 'n'},
{"minimal-match", required_argument, 0, 'M'},
{0, 0, 0, 0}
};
int c;
/*
*
* initialize things
*
*/
lal_errhandler = LAL_ERR_EXIT;
setvbuf( stdout, NULL, _IONBF, 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, lalAppsVCSIdentInfo.vcsId,
lalAppsVCSIdentInfo.vcsStatus, lalAppsVCSIdentInfo.vcsDate, 0);
this_proc_param = procparams.processParamsTable =
(ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) );
memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) );
/*
*
* parse command line arguments
*
*/
while ( 1 )
{
/* LALgetopt_long stores long option here */
int option_index = 0;
size_t LALoptarg_len;
c = LALgetopt_long_only( argc, argv,
"i:n:VZ:hs:M:",
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 'v':
LALoptarg_len = strlen( LALoptarg ) + 1;
bankFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( bankFileName, LALoptarg, LALoptarg_len );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--%s", long_options[option_index].name );
snprintf( procparams.processParamsTable->value,
LIGOMETA_VALUE_MAX, "%s", LALoptarg );
break;
case 'n':
numOutBanks = (INT4) atoi( LALoptarg );
if ( numOutBanks < 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"Number of output banks must be greater than zero:"
"(%d specified)\n",
long_options[option_index].name, numOutBanks );
exit( 1 );
}
else if ( numOutBanks > 99 )
{
fprintf( stderr,
"Warning: generating more than 99 banks is not reccomended!\n" );
}
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->type, LIGOMETA_TYPE_MAX, "int" );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX,
"--%s", long_options[option_index].name );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%d",
numOutBanks );
break;
case 's':
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 '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->type, LIGOMETA_TYPE_MAX, "string" );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "-userTag" );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%s",
LALoptarg );
break;
case 'M':
minMatch = (REAL4) atof( LALoptarg );
if ( minMatch <= 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"minimal match of bank must be > 0: "
"(%f specified)\n",
long_options[option_index].name, minMatch );
exit( 1 );
}
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->type, LIGOMETA_TYPE_MAX, "float" );
snprintf( this_proc_param->param, LIGOMETA_PARAM_MAX, "--%s",
long_options[option_index].name );
snprintf( this_proc_param->value, LIGOMETA_VALUE_MAX, "%e",
minMatch );
break;
case 'V':
/* print version information and exit */
fprintf( stdout, "Inspiral Template Bank Splitter\n"
"Duncan Brown <*****@*****.**>\n");
XLALOutputVersionString(stderr, 0);
exit( 0 );
break;
case '?':
fprintf( stderr, USAGE, argv[0] );
exit( 1 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
fprintf( stderr, USAGE, argv[0] );
exit( 1 );
}
}
if ( LALoptind < argc )
{
fprintf( stderr, "extraneous command line arguments:\n" );
while ( LALoptind < argc )
{
fprintf ( stderr, "%s\n", argv[LALoptind++] );
}
exit( 1 );
}
/* check the values of the arguments */
if ( ! bankFileName )
{
fprintf( stderr, "Error: --bank-file must be specified\n" );
exit( 1 );
}
if ( ! numOutBanks )
{
fprintf( stderr, "Error: --number-of-banks must be specified\n" );
exit( 1 );
}
if ( minMatch < 0 )
{
fprintf( stderr, "Error: --minimal-match must be specified\n" );
exit( 1 );
}
/*
*
* read in the template bank from the input file
*
*/
/* read in the template bank from a ligo lw xml file */
inputBank.snglInspiralTable = NULL;
numTmplts = LALSnglInspiralTableFromLIGOLw( &(inputBank.snglInspiralTable),
bankFileName, 0, -1 );
if ( numTmplts < 0 )
{
fprintf( stderr, "error: unable to read templates from %s\n",
bankFileName );
exit( 1 );
}
if ( vrbflg ) fprintf( stdout, "read %d templates from %s\n",
numTmplts, bankFileName );
/* find the hypen just before the GPS start time of the bank */
gpsHyphen = NULL;
gpsHyphen = strstr( bankFileName, "-" );
if ( ! gpsHyphen )
{
fprintf( stderr, "Error: could not find first hypen in file name %s\n",
bankFileName );
exit( 1 );
}
gpsHyphen = strstr( gpsHyphen + 1, "-" );
if ( ! gpsHyphen )
{
fprintf( stderr, "Error: could not find second hypen in file name %s\n",
bankFileName );
exit( 1 );
}
/* store the name of the template bank file */
memcpy( bankFileNameHead, bankFileName,
(size_t) gpsHyphen - (size_t) bankFileName < FILENAME_MAX ?
(gpsHyphen - bankFileName) * sizeof(CHAR) : FILENAME_MAX * sizeof(CHAR) );
strncpy( bankFileNameTail, gpsHyphen + 1, FILENAME_MAX - 1 );
if ( vrbflg )
{
fprintf( stdout, "head of bank file name is %s\n", bankFileNameHead );
fprintf( stdout, "tail of bank file name is %s\n", bankFileNameTail );
}
/*
*
* write out the individual tempate bank files
*
*/
/* compute the number of templates per output file */
numPerFile = floor( ( numTmplts - 0.5 )/ numOutBanks + 1 );
thisTmplt = inputBank.snglInspiralTable;
if ( vrbflg ) fprintf( stdout, "writing around %d templates per file\n",
numPerFile );
for ( i = 0; i < numOutBanks; ++i )
{
/* open the output xml file */
memset( outBankFileName, 0, FILENAME_MAX * sizeof(CHAR) );
if(snprintf( outBankFileName, FILENAME_MAX, "%s_%02d-%s",
bankFileNameHead, i, bankFileNameTail ) >= FILENAME_MAX)
abort();
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status , &xmlStream, outBankFileName),
&status );
if ( vrbflg )
fprintf( stdout, "writing templates to %s... ", outBankFileName );
/* write process table */
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 );
/* write process_params table */
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 templates to the file */
outputBank.snglInspiralTable = thisTmplt;
numTmpltsWritten = 0;
if ( thisTmplt )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream,
sngl_inspiral_table), &status );
for ( j = 0; j < numPerFile - 1 && thisTmplt->next; ++j )
{
thisTmplt = thisTmplt->next;
}
tmpTmplt = thisTmplt->next;
thisTmplt->next = NULL;
thisTmplt = tmpTmplt;
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputBank,
sngl_inspiral_table), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status );
}
while ( outputBank.snglInspiralTable )
{
++numTmpltsWritten;
tmpTmplt = outputBank.snglInspiralTable;
outputBank.snglInspiralTable = outputBank.snglInspiralTable->next;
LALFree( tmpTmplt );
}
LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream), &status );
if ( vrbflg ) fprintf( stdout, "%d templates\n", numTmpltsWritten );
}
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 *ifoName = NULL;
char *inputGlob = NULL;
char *inputFileName = NULL;
char *outputFileName = NULL;
char *tamaFileName = NULL;
char *summFileName = NULL;
REAL4 snrStar = -1;
SnglInspiralClusterChoice clusterchoice = none;
INT8 cluster_dt = -1;
char *injectFileName = NULL;
INT8 inject_dt = -1;
char *missedFileName = NULL;
INT4 hardware = 0;
int enableTrigStartTime = 1;
int j;
FILE *fp = NULL;
glob_t globbedFiles;
int numInFiles = 0;
char **inFileNameList;
char line[MAX_PATH];
int errnum;
UINT8 triggerInputTimeNS = 0;
MetadataTable proctable;
MetadataTable procparams;
ProcessParamsTable *this_proc_param;
UINT4 numSimEvents = 0;
UINT4 numSimInData = 0;
UINT4 numSimFound = 0;
UINT4 numSimMissed = 0;
UINT4 numSimDiscard = 0;
UINT4 numSimProcessed = 0;
SimRingdownTable *simEventHead = NULL;
SimRingdownTable *thisSimEvent = NULL;
SimRingdownTable *missedSimHead = NULL;
SimRingdownTable *thisMissedSim = NULL;
SimRingdownTable *tmpSimEvent = NULL;
SimRingdownTable *prevSimEvent = NULL;
SearchSummaryTable *searchSummaryTable = NULL;
UINT4 numEvents = 0;
UINT4 numEventsKept = 0;
UINT4 numEventsInIFO = 0;
UINT4 numEventsCoinc = 0;
UINT4 numEventsDiscard = 0;
UINT4 numEventsProcessed = 0;
UINT4 numClusteredEvents = 0;
SnglRingdownTable **eventHandle = NULL;
SnglRingdownTable *eventHead = NULL;
SnglRingdownTable *thisEvent = NULL;
SnglRingdownTable *tmpEvent = NULL;
SnglRingdownTable *prevEvent = NULL;
LIGOLwXMLStream xmlStream;
MetadataTable outputTable;
/*
*
* 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) );
/*
*
* 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'},
{"glob", required_argument, 0, 'g'},
{"input", required_argument, 0, 'i'},
{"output", required_argument, 0, 'o'},
{"data-type", required_argument, 0, 'k'},
{"tama-output", required_argument, 0, 'j'},
{"summary-file", required_argument, 0, 'S'},
{"snr-threshold", required_argument, 0, 's'},
{"cluster-algorithm", required_argument, 0, 'C'},
{"cluster-time", required_argument, 0, 't'},
{"ifo-cut", required_argument, 0, 'd'},
{"injection-file", required_argument, 0, 'I'},
{"injection-coincidence", required_argument, 0, 'T'},
{"missed-injections", required_argument, 0, 'm'},
{"hardware-injections", required_argument, 0, 'H'},
{"disable-trig-start-time", no_argument, 0, 'D'},
{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, "hZ:c:d:g:i:o:j:S:s:C:Vt:I:T:m:H:D",
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':
fprintf( stdout, USAGE );
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, "Single Ringdown Reader and Injection Analysis\n"
"Patrick Brady, Duncan Brown and Steve Fairhurst\n");
XLALOutputVersionString(stderr, 0);
exit( 0 );
break;
case 'g':
/* create storage for the input file glob */
LALoptarg_len = strlen( LALoptarg ) + 1;
inputGlob = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( inputGlob, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "'%s'", LALoptarg );
break;
case 'i':
/* create storage for the input file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
inputFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( inputFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
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 'j':
/* create storage of the TAMA file name */
LALoptarg_len = strlen( LALoptarg ) + 1;
tamaFileName = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR));
memcpy( tamaFileName, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
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 '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 '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 'C':
/* choose the clustering algorithm */
{
if ( ! strcmp( "snr_and_chisq", LALoptarg ) )
{
clusterchoice = snr_and_chisq;
}
else if ( ! strcmp( "snrsq_over_chisq", LALoptarg) )
{
clusterchoice = snrsq_over_chisq;
}
else if ( ! strcmp( "snr", LALoptarg) )
{
clusterchoice = snr;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown clustering specified:\n "
"%s (must be one of: snr_and_chisq, \n"
" snrsq_over_chisq or snr)\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"
"custer 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 *= LAL_INT8_C(1000000);
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 'T':
/* injection coincidence time is specified on command line in ms */
inject_dt = (INT8) atoi( LALoptarg );
if ( inject_dt < 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"injection coincidence window must be >= 0: "
"(%" LAL_INT8_FORMAT " specified)\n",
long_options[option_index].name, inject_dt );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT8_FORMAT " ", inject_dt );
/* convert inject time from ms to ns */
inject_dt *= LAL_INT8_C(1000000);
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 'H':
hardware = (INT4) atoi( LALoptarg );
if ( hardware <= 0 )
{
fprintf( stdout, "invalid argument to --%s:\n"
"GPS start time of hardware injections must be > 0: "
"(%d specified)\n",
long_options[option_index].name, hardware );
exit( 1 );
}
ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT " ", hardware );
break;
case 'D':
enableTrigStartTime = 0;
ADD_PROCESS_PARAM( "string", "%s", " " );
break;
case '?':
exit( 1 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
exit( 1 );
}
}
if ( LALoptind < argc )
{
fprintf( stderr, "extraneous command line arguments:\n" );
while ( LALoptind < argc )
{
fprintf ( stderr, "%s\n", argv[LALoptind++] );
}
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 input and output file names have been specified */
if ( (! inputGlob && ! inputFileName) || (inputGlob && inputFileName) )
{
fprintf( stderr, "exactly one of --glob or --input must be specified\n" );
exit( 1 );
}
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 we have all the options to do injections */
if ( injectFileName && inject_dt < 0 )
{
fprintf( stderr, "--injection-coincidence must be specified if "
"--injection-file is given\n" );
exit( 1 );
}
else if ( ! injectFileName && inject_dt >= 0 )
{
fprintf( stderr, "--injection-file must be specified if "
"--injection-coincidence is given\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, " " );
}
switch ( dataType )
{
case playground_only:
if ( vrbflg )
fprintf( stdout, "using data from playground times only\n" );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--playground-only" );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->value,
LIGOMETA_TYPE_MAX, " " );
break;
case exclude_play:
if ( vrbflg )
fprintf( stdout, "excluding all triggers in playground times\n" );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--exclude-play" );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->value,
LIGOMETA_TYPE_MAX, " " );
break;
case all_data:
if ( vrbflg )
fprintf( stdout, "using all input data\n" );
snprintf( procparams.processParamsTable->program,
LIGOMETA_PROGRAM_MAX, "%s", PROGRAM_NAME );
snprintf( procparams.processParamsTable->param,
LIGOMETA_PARAM_MAX, "--all-data" );
snprintf( procparams.processParamsTable->type,
LIGOMETA_TYPE_MAX, "string" );
snprintf( procparams.processParamsTable->value,
LIGOMETA_TYPE_MAX, " " );
break;
default:
fprintf( stderr, "data set not defined\n" );
exit( 1 );
}
/*
*
* read in the injection XML file, if we are doing an injection analysis
*
*/
if ( injectFileName )
{
if ( vrbflg )
fprintf( stdout, "reading injections from %s... ", injectFileName );
simEventHead = XLALSimRingdownTableFromLIGOLw( injectFileName, 0, 0 );
if ( vrbflg ) fprintf( stdout, "got %d injections\n", numSimEvents );
if ( ! simEventHead )
{
fprintf( stderr, "error: unable to read sim_ringdown table from %s\n",
injectFileName );
exit( 1 );
}
/* if we are doing hardware injections, increment all the start times */
if ( hardware )
{
if ( vrbflg ) fprintf( stdout,
"incrementing GPS times of injections by %d seconds\n", hardware );
for ( thisSimEvent = simEventHead;
thisSimEvent; thisSimEvent = thisSimEvent->next )
{
thisSimEvent->geocent_start_time.gpsSeconds += hardware;
thisSimEvent->h_start_time.gpsSeconds += hardware;
thisSimEvent->l_start_time.gpsSeconds += hardware;
}
}
/* discard all injection events that are not in the data we want */
if ( dataType != all_data )
{
numSimDiscard = 0;
thisSimEvent = simEventHead;
simEventHead = NULL;
prevSimEvent = NULL;
if ( vrbflg ) fprintf( stdout, "discarding injections not in data\n" );
while ( thisSimEvent )
{
INT4 isPlayground = XLALINT8NanoSecIsPlayground(XLALGPSToINT8NS(&(thisSimEvent->geocent_start_time)));
if ( (dataType == playground_only && isPlayground) ||
(dataType == exclude_play && ! isPlayground) )
{
/* store the head of the linked list */
if ( ! simEventHead ) simEventHead = thisSimEvent;
/* keep this event */
prevSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
++numSimInData;
if ( vrbflg ) fprintf( stdout, "+" );
}
else
{
/* throw this event away */
tmpSimEvent = thisSimEvent;
if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next;
thisSimEvent = thisSimEvent->next;
LALFree( tmpSimEvent );
++numSimDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
}
if ( vrbflg )
fprintf( stdout, "\nusing %d (discarded %d) of %d injections\n",
numSimInData, numSimDiscard, numSimEvents );
}
else
{
if ( vrbflg )
fprintf( stdout, "using all %d injections\n", numSimInData );
numSimInData = numSimEvents;
}
}
/*
*
* read in the input triggers from the xml files
*
*/
if ( inputGlob )
{
/* use glob() to get a list of the input file names */
if ( glob( inputGlob, GLOB_ERR, NULL, &globbedFiles ) )
{
fprintf( stderr, "error globbing files from %s\n", inputGlob );
perror( "error:" );
exit( 1 );
}
numInFiles = globbedFiles.gl_pathc;
inFileNameList = (char **) LALCalloc( numInFiles, sizeof(char *) );
for ( j = 0; j < numInFiles; ++j )
{
inFileNameList[j] = globbedFiles.gl_pathv[j];
}
}
else if ( inputFileName )
{
/* read the list of input filenames from a file */
fp = fopen( inputFileName, "r" );
if ( ! fp )
{
fprintf( stderr, "could not open file containing list of xml files\n" );
perror( "error:" );
exit( 1 );
}
/* count the number of lines in the file */
while ( get_next_line( line, sizeof(line), fp ) )
{
++numInFiles;
}
rewind( fp );
/* allocate memory to store the input file names */
inFileNameList = (char **) LALCalloc( numInFiles, sizeof(char *) );
/* read in the input file names */
for ( j = 0; j < numInFiles; ++j )
{
inFileNameList[j] = (char *) LALCalloc( MAX_PATH, sizeof(char) );
get_next_line( line, sizeof(line), fp );
strncpy( inFileNameList[j], line, strlen(line) - 1);
}
fclose( fp );
}
else
{
fprintf( stderr, "no input file mechanism specified\n" );
exit( 1 );
}
if ( vrbflg )
{
fprintf( stdout, "reading input triggers from:\n" );
for ( j = 0; j < numInFiles; ++j )
{
fprintf( stdout, "%s\n", inFileNameList[j] );
}
}
/*
*
* read in the triggers from the input xml files
*
*/
if ( injectFileName )
{
thisSimEvent = simEventHead;
simEventHead = NULL;
prevSimEvent = NULL;
numSimDiscard = 0;
numSimInData = 0;
if ( vrbflg )
fprintf( stdout, "discarding injections not in input data\n" );
}
for ( j = 0; j < numInFiles; ++j )
{
LIGOTimeGPS inPlay, outPlay;
UINT8 outPlayNS, outStartNS, outEndNS, triggerTimeNS;
INT4 trigStartTimeArg = 0;
searchSummaryTable = XLALSearchSummaryTableFromLIGOLw( inFileNameList[j] );
if ( ( ! searchSummaryTable ) || searchSummaryTable->next )
{
fprintf( stderr,
"error: zero or multiple search_summary tables in %s\n",
inFileNameList[j] );
exit( 1 );
}
if ( enableTrigStartTime )
{
/* override the value of out_start_time if there is a non-zero */
/* --trig-start-time option in the process_params table */
/* this is necessary to get round a bug in early versions of */
/* the ringdown code */
int mioStatus;
int pParParam;
int pParValue;
struct MetaioParseEnvironment parseEnv;
const MetaioParseEnv env = &parseEnv;
/* open the procress_params table from the input file */
mioStatus = MetaioOpenTable( env, inFileNameList[j], "process_params" );
if ( mioStatus )
{
fprintf( stderr, "error opening process_params table from file %s\n",
inFileNameList[j] );
exit( 1 );
}
/* figure out where the param and value columns are */
if ( (pParParam = MetaioFindColumn( env, "param" )) < 0 )
{
fprintf( stderr, "unable to find column param in process_params\n" );
MetaioClose(env);
exit( 1 );
}
if ( (pParValue = MetaioFindColumn( env, "value" )) < 0 )
{
fprintf( stderr, "unable to find column value in process_params\n" );
MetaioClose(env);
exit( 1 );
}
/* get the trigger start time from the process params */
while ( (mioStatus = MetaioGetRow(env)) == 1 )
{
if ( ! strcmp( env->ligo_lw.table.elt[pParParam].data.lstring.data,
"--trig-start-time" ) )
{
trigStartTimeArg = (INT4)
atoi( env->ligo_lw.table.elt[pParValue].data.lstring.data );
}
}
MetaioClose( env );
if ( trigStartTimeArg )
{
searchSummaryTable->out_start_time.gpsSeconds = trigStartTimeArg;
searchSummaryTable->out_start_time.gpsNanoSeconds = 0;
if ( vrbflg ) fprintf( stdout, "file %s has --trig-start-time %d\n",
inFileNameList[j], trigStartTimeArg );
}
}
/* compute the out time from the search summary table */
outStartNS = XLALGPSToINT8NS ( &(searchSummaryTable->out_start_time) );
outEndNS = XLALGPSToINT8NS ( &(searchSummaryTable->out_end_time) );
triggerTimeNS = outEndNS - outStartNS;
/* check for events and playground */
if ( dataType != all_data )
{
LAL_CALL( LALPlaygroundInSearchSummary( &status, searchSummaryTable,
&inPlay, &outPlay ), &status );
outPlayNS = XLALGPSToINT8NS ( &outPlay );
if ( dataType == playground_only )
{
if ( outPlayNS )
{
/* increment the total trigger time by the amount of playground */
triggerInputTimeNS += outPlayNS;
}
else
{
/* skip this file as it does not contain any playground data */
if ( vrbflg )
{
fprintf( stdout, "file %s not in playground, continuing\n",
inFileNameList[j] );
}
LALFree( searchSummaryTable );
searchSummaryTable = NULL;
continue;
}
}
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;
}
if ( injectFileName )
{
if ( vrbflg ) fprintf( stdout, "discarding injections not in file: " );
/* throw away injections that are outside analyzed times */
while ( thisSimEvent && thisSimEvent->geocent_start_time.gpsSeconds <
searchSummaryTable->out_end_time.gpsSeconds )
{
/* check if injection is before file start time */
if ( thisSimEvent->geocent_start_time.gpsSeconds <
searchSummaryTable->out_start_time.gpsSeconds )
{
/* discard the current injection */
if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next;
tmpSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
LALFree( tmpSimEvent );
++numSimDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
else
{
/* store the head of the linked list */
if ( ! simEventHead ) simEventHead = thisSimEvent;
/* keep this injection */
prevSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
++numSimInData;
if ( vrbflg ) fprintf( stdout, "+" );
}
}
if ( vrbflg ) fprintf( stdout, "\n" );
}
/*
*
* if there are any events in the file, read them in
*
*/
if ( searchSummaryTable->nevents )
{
INT4 isPlay;
if ( vrbflg ) fprintf( stdout, "file %s contains %d events, processing\n",
inFileNameList[j], searchSummaryTable->nevents );
if ( ! prevEvent )
{
eventHandle = &thisEvent;
}
else
{
eventHandle = &(prevEvent->next);
}
/* read the events from the file into a temporary list */
XLAL_TRY( *eventHandle = XLALSnglRingdownTableFromLIGOLw( inFileNameList[j] ), errnum);
if ( ! *eventHandle )
switch ( errnum )
{
case XLAL_EDATA:
XLALPrintError("Unable to read sngl_ringdown table from %s\n", inFileNameList[j] );
/*LALFree(thisInputFile);*/
XLALClearErrno();
break;
default:
XLALSetErrno( errnum );
XLAL_ERROR(XLAL_EFUNC );
}
/* only keep triggers from the data that we want to analyze */
thisEvent = *eventHandle;
while ( thisEvent )
{
numEvents++;
isPlay = XLALINT8NanoSecIsPlayground( XLALGPSToINT8NS( &(thisEvent->start_time) ) );
if ( (dataType == all_data ||
(dataType == playground_only && isPlay) ||
(dataType == exclude_play && ! isPlay))
&& ( snrStar < 0 || thisEvent->snr > snrStar) )
{
/* keep the trigger and increment the count of triggers */
if ( ! eventHead ) eventHead = thisEvent;
prevEvent = thisEvent;
thisEvent = thisEvent->next;
++numEventsKept;
}
else
{
/* discard the trigger and move to the next one */
if ( prevEvent ) prevEvent->next = thisEvent->next;
tmpEvent = thisEvent;
thisEvent = thisEvent->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &tmpEvent ), &status);
}
}
/* make sure that the linked list is properly terminated */
if ( prevEvent && prevEvent->next ) prevEvent->next->next = NULL;
}
else
{
if ( vrbflg ) fprintf( stdout, "file %s contains no events, skipping\n",
inFileNameList[j] );
}
LALFree( searchSummaryTable );
searchSummaryTable = NULL;
}
/* discard the remaining injections which occured after the last file */
if ( injectFileName )
{
if ( vrbflg ) fprintf( stdout, "kept %d injections, discarded %d\n",
numSimInData, numSimDiscard );
if ( prevSimEvent ) prevSimEvent->next = NULL;
numSimDiscard = 0;
while ( thisSimEvent )
{
tmpSimEvent = thisSimEvent;
thisSimEvent = thisSimEvent->next;
LALFree( tmpSimEvent );
++numSimDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
if ( vrbflg ) fprintf( stdout, "\ndiscarded %d injections at end of list\n",
numSimDiscard );
}
/*
*
* sort the ringdown events by time
*
*/
if ( injectFileName || sortTriggers )
{
if ( vrbflg ) fprintf( stdout, "sorting ringdown trigger list..." );
LAL_CALL( LALSortSnglRingdown( &status, &eventHead,
*LALCompareSnglRingdownByTime ), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
}
/*
*
* keep only event from requested ifo
*
*/
if ( ifoName )
{
if ( vrbflg ) fprintf( stdout,
"keeping only triggers from %s, discarding others...", ifoName );
LAL_CALL( LALIfoCutSingleRingdown( &status, &eventHead, ifoName ), &status );
LALIfoCountSingleRingdown( &status, &numEventsInIFO, eventHead,
XLALIFONumber(ifoName) );
if ( vrbflg ) fprintf( stdout, "done\n" );
}
/*
*
* check for events that are coincident with injections
*
*/
if ( injectFileName )
{
int coincidence = 0;
UINT8 simTime, ringdownTime;
if ( vrbflg ) fprintf( stdout,
"checking for events that are coincident with injections\n" );
/* Note: we are assuming that both the ringdown and */
/* injection events are time sorted */
thisSimEvent = simEventHead;
thisEvent = eventHead;
simEventHead = NULL;
eventHead = NULL;
prevSimEvent = NULL;
prevEvent = NULL;
numSimFound = 0;
numSimDiscard = 0;
numEventsDiscard = 0;
numEventsCoinc = 0;
if ( ! thisEvent )
{
/* no triggers in the input data, so all injections are missed */
if ( vrbflg ) fprintf( stdout, "no triggers in input data\n" );
thisMissedSim = missedSimHead = thisSimEvent;
while ( thisMissedSim )
{
/* count the number of injections just stuck in the missed list */
if ( vrbflg ) fprintf( stdout, "M" );
++numSimMissed;
++numSimProcessed;
thisMissedSim = thisMissedSim->next;
}
}
else
{
/* begin loop over the sim_ringdown events */
while ( thisSimEvent )
{
/* compute the end time in nanosec for the injection */
/* at the relevant detector */
if ( ! strcmp( "L1", thisEvent->ifo ) )
{
simTime = XLALGPSToINT8NS ( &(thisSimEvent->l_start_time) );
}
else if ( ! strcmp( "H1", thisEvent->ifo ) ||
! strcmp( "H2", thisEvent->ifo ) )
{
simTime = XLALGPSToINT8NS ( &(thisSimEvent->h_start_time) );
}
else
{
fprintf( stderr, "unknown detector found in event list: %s\n",
thisEvent->ifo );
fprintf( stderr, "Detector must be one of (G1|H1|H2|L1|T1|V1)\n");
exit( 1 );
}
/* find the first ringdown event after the current sim event */
while ( thisEvent )
{
coincidence = 0;
/* compute the time in nanosec for the ringdown */
ringdownTime = XLALGPSToINT8NS ( &(thisEvent->start_time) );
if ( ringdownTime < (simTime - inject_dt) )
{
/* discard this event and move on to the next one */
if ( prevEvent ) prevEvent->next = thisEvent->next;
tmpEvent = thisEvent;
thisEvent = thisEvent->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &tmpEvent ), &status);
++numEventsProcessed;
++numEventsDiscard;
if ( vrbflg ) fprintf( stdout, "-" );
}
else
{
/* we have reached the negative coincincidence window */
break;
}
}
while ( thisEvent )
{
/* compute the time in nanosec for the ringdown */
ringdownTime = XLALGPSToINT8NS ( &(thisEvent->start_time) );
if ( ringdownTime < (simTime + inject_dt) )
{
/* this event is within the coincidence window */
/* store this event and move on to the next one */
if ( ! eventHead ) eventHead = thisEvent;
prevEvent = thisEvent;
thisEvent = thisEvent->next;
coincidence = 1;
++numEventsProcessed;
++numEventsCoinc;
if ( vrbflg ) fprintf( stdout, "+" );
}
else
{
/* we have reached the end of the positive coincincidence window */
break;
}
}
if ( coincidence )
{
/* keep this event in the list and move to the next sim event */
if ( ! simEventHead ) simEventHead = thisSimEvent;
prevSimEvent = thisSimEvent;
++numSimFound;
++numSimProcessed;
thisSimEvent = thisSimEvent->next;
if ( vrbflg ) fprintf( stdout, "F" );
}
else
{
/* save this sim event in the list of missed events... */
if ( ! missedSimHead )
{
missedSimHead = thisMissedSim = thisSimEvent;
}
else
{
thisMissedSim = thisMissedSim->next = thisSimEvent;
}
/* ...and remove it from the list of found events */
if ( prevSimEvent ) prevSimEvent->next = thisSimEvent->next;
++numSimMissed;
if ( vrbflg ) fprintf( stdout, "M" );
/* move to the next sim in the list */
++numSimProcessed;
thisSimEvent = thisSimEvent->next;
/* make sure the missed sim list is terminated */
thisMissedSim->next = NULL;
}
if ( ! thisEvent )
{
/* these are no more events to process so all the rest of the */
/* injections must be put in the missed injections list */
if ( ! missedSimHead )
{
/* this and any subsequent events are in the missed sim list */
if ( thisSimEvent ) thisMissedSim = missedSimHead = thisSimEvent;
}
else
{
if ( thisSimEvent )
{
/* append the rest of the list to the list of missed injections */
thisMissedSim = thisMissedSim->next = thisSimEvent;
}
else
{
/* there are no injections after this one */
thisMissedSim = thisMissedSim->next = NULL;
}
}
/* terminate the list of found injections correctly */
if ( prevSimEvent ) prevSimEvent->next = NULL;
while ( thisMissedSim )
{
/* count the number of injections just stuck in the missed list */
if ( vrbflg ) fprintf( stdout, "M" );
++numSimMissed;
++numSimProcessed;
thisMissedSim = thisMissedSim->next;
}
thisSimEvent = NULL;
break;
}
}
if ( thisEvent )
{
/* discard any remaining ringdown triggers -- including thisEvent */
/* as we have run out of injections */
tmpEvent = thisEvent;
if ( prevEvent ) prevEvent->next = NULL;
while ( tmpEvent )
{
thisEvent = tmpEvent;
tmpEvent = tmpEvent->next;
LAL_CALL ( LALFreeSnglRingdown ( &status, &thisEvent ), &status);
++numEventsDiscard;
++numEventsProcessed;
if ( vrbflg ) fprintf( stdout, "-" );
}
}
}
if ( vrbflg )
{
fprintf( stdout, "\nfound %d injections, missed %d injections "
"(%d injections processed)\n",
numSimFound, numSimMissed, numSimProcessed );
fprintf( stdout, "found %d coincident events, %d events discarded "
"(%d events processed)\n",
numEventsCoinc, numEventsDiscard, numEventsProcessed );
}
} /* end if ( injectFileName ) */
/*
*
* cluster the remaining events
*
*/
if ( eventHead && clusterchoice )
{
if ( vrbflg ) fprintf( stdout, "clustering remaining triggers... " );
LAL_CALL( LALClusterSnglRingdownTable( &status, eventHead,
cluster_dt, clusterchoice ), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
/* count the number of triggers surviving the clustering */
thisEvent = eventHead;
numClusteredEvents = 0;
while ( thisEvent )
{
++numClusteredEvents;
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->start_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 );
/* 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 found injections to the sim table */
if ( simEventHead )
{
if ( vrbflg ) fprintf( stdout, "sim_ringdown... " );
outputTable.simRingdownTable = simEventHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
sim_ringdown_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sim_ringdown_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status );
}
/* Write the results to the ringdown table */
if ( eventHead )
{
if ( vrbflg ) fprintf( stdout, "sngl_ringdown... " );
outputTable.snglRingdownTable = eventHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
sngl_ringdown_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sngl_ringdown_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream ), &status);
}
/* close the output file */
LAL_CALL( LALCloseLIGOLwXMLFile(&status, &xmlStream), &status);
if ( vrbflg ) fprintf( stdout, "done\n" );
/* write out the TAMA file if it is requested */
if ( tamaFileName )
{
/* FIXME */
REAL8 UNUSED trigtime;
fp = fopen( tamaFileName, "w" );
if ( ! fp )
{
perror( "TAMA file" );
exit( 1 );
}
fprintf( fp, "IFO trigger time snr chisq "
" total mass eta eff dist (kpc)\n" );
for ( thisEvent = eventHead; thisEvent; thisEvent = thisEvent->next )
{
trigtime = XLALGPSGetREAL8(&(thisEvent->start_time));
}
fclose( fp );
}
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.simRingdownTable = missedSimHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream, sim_ringdown_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, outputTable,
sim_ringdown_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 );
if ( snrStar >= 0 )
{
fprintf( fp, "number of triggers in input data with snr above %f: %d \n",
snrStar, numEventsKept );
}
else
{
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 );
}
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 %" LAL_INT8_FORMAT "msec of injection: %d\n",
(inject_dt / LAL_INT8_C(1000000) ), numEventsCoinc );
fprintf( fp, "efficiency: %f \n",
(REAL4) numSimFound / (REAL4) numSimInData );
}
if ( clusterchoice )
{
fprintf( fp, "number of event clusters with %" LAL_INT8_FORMAT " msec window: %d\n",
cluster_dt/ LAL_INT8_C(1000000), numClusteredEvents );
}
fclose( fp );
}
/*
*
* free memory and exit
*
*/
/* free the ringdown events we saved */
while ( eventHead )
{
thisEvent = eventHead;
eventHead = eventHead->next;
LAL_CALL ( LALFreeSnglRingdown ( &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 the input file name data */
if ( inputGlob )
{
LALFree( inFileNameList );
globfree( &globbedFiles );
}
else
{
for ( j = 0; j < numInFiles; ++j )
{
LALFree( inFileNameList[j] );
}
LALFree( inFileNameList );
}
if ( vrbflg ) fprintf( stdout, "checking memory leaks and exiting\n" );
LALCheckMemoryLeaks();
exit( 0 );
}
int main( int argc, char *argv[] )
{
static LALStatus status;
INT4 startTime = -1;
LIGOTimeGPS startTimeGPS = {0,0};
INT4 endTime = -1;
LIGOTimeGPS endTimeGPS = {0,0};
CHAR inputIFO[LIGOMETA_IFO_MAX];
CHAR outputIFO[LIGOMETA_IFO_MAX];
CHAR comment[LIGOMETA_COMMENT_MAX];
CHAR *userTag = NULL;
CHAR *ifoTag = NULL;
CHAR fileName[FILENAME_MAX];
INT4 numTriggers = 0;
SnglInspiralTable *inspiralEventList=NULL;
SnglInspiralTable *currentTrigger = NULL;
SearchSummvarsTable *inputFiles = NULL;
SearchSummvarsTable *thisInputFile = NULL;
SearchSummaryTable *searchSummList = NULL;
SearchSummaryTable *thisSearchSumm = NULL;
MetadataTable proctable;
MetadataTable processParamsTable;
MetadataTable searchsumm;
MetadataTable searchSummvarsTable;
MetadataTable inspiralTable;
ProcessParamsTable *this_proc_param = NULL;
LIGOLwXMLStream xmlStream;
INT4 outCompress = 0;
long int gpstime;
trigScanType trigScanMethod = trigScanNone;
/* Switch for clustering */
/* triggers in template */
/* parameters and end time */
REAL8 trigScanMetricScalingFac = -1.0;
/* Use this scaling factor for the volume spanned by a trigger in the */
/* parameter space. When set to x, the volume is taken to be that of the*/
/* ambiguity ellipsoid at a 'minimal match' of (1.0-x). */
/* original bank entered at the */
/* command line */
INT2 trigScanAppendStragglers = -1; /* Switch to append cluster */
/* out-liers (stragglers) */
INT4 i;
/* LALgetopt arguments */
struct LALoption long_options[] =
{
{"verbose", no_argument, &vrbflg, 1 },
{"write-compress", no_argument, &outCompress, 1 },
{"gps-start-time", required_argument, 0, 'q'},
{"gps-end-time", required_argument, 0, 'r'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"user-tag", required_argument, 0, 'Z'},
{"ifo", required_argument, 0, 'I'},
{"ts-cluster", required_argument, 0, '*'},
{"ts-metric-scaling", required_argument, 0, '>'},
{0, 0, 0, 0}
};
int c;
/*
*
* initialize things
*
*/
lal_errhandler = LAL_ERR_EXIT;
setvbuf( stdout, NULL, _IONBF, 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 = processParamsTable.processParamsTable =
(ProcessParamsTable *) calloc( 1, sizeof(ProcessParamsTable) );
memset( comment, 0, LIGOMETA_COMMENT_MAX * sizeof(CHAR) );
/* create the search summary and zero out the summvars table */
searchsumm.searchSummaryTable = (SearchSummaryTable *)
calloc( 1, sizeof(SearchSummaryTable) );
/* parse the arguments */
while ( 1 )
{
/* LALgetopt_long stores long option here */
int option_index = 0;
size_t LALoptarg_len;
c = LALgetopt_long_only( argc, argv,
"a:b:hq:r:s:A:I: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 's':
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 'h':
/* help message */
print_usage(argv[0]);
exit( 1 );
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 'I':
/* create storage for the ifo-tag */
LALoptarg_len = strlen(LALoptarg) + 1;
ifoTag = (CHAR *) calloc( LALoptarg_len, sizeof(CHAR) );
memcpy( ifoTag, LALoptarg, LALoptarg_len );
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
snprintf(inputIFO, LIGOMETA_IFO_MAX, "%s", LALoptarg);
snprintf(outputIFO, LIGOMETA_IFO_MAX, "%s", LALoptarg);
break;
case 'V':
/* print version information and exit */
fprintf( stdout, "TrigScan Cluster \n"
"Larne Pekowsky\n"
"Based on trigbank and inspiral by Patrick Brady, Duncan Brown and Steve Fairhurst\n");
XLALOutputVersionString(stderr, 0);
exit( 0 );
break;
case '?':
print_usage(argv[0]);
exit( 1 );
break;
case 'q':
/* start time */
gpstime = atol( LALoptarg );
if ( gpstime < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpstime );
exit( 1 );
}
startTime = (INT4) gpstime;
startTimeGPS.gpsSeconds = startTime;
ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, startTime );
break;
case 'r':
/* end time */
gpstime = atol( LALoptarg );
if ( gpstime < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpstime );
exit( 1 );
}
endTime = (INT4) gpstime;
endTimeGPS.gpsSeconds = endTime;
ADD_PROCESS_PARAM( "int", "%" LAL_INT4_FORMAT, endTime );
break;
case '*':
/* store trigSanClustering method */
if ( ! strcmp( "T0T3Tc", LALoptarg ) )
{
trigScanMethod = T0T3Tc;
trigScanAppendStragglers = 0;
}
else if ( ! strcmp( "T0T3TcAS", LALoptarg ) )
{
trigScanMethod = T0T3Tc;
trigScanAppendStragglers = 1;
}
else if ( ! strcmp( "Psi0Psi3Tc", LALoptarg ) )
{
trigScanMethod = Psi0Psi3Tc;
trigScanAppendStragglers = 0;
}
else if ( ! strcmp( "Psi0Psi3TcAS", LALoptarg ) )
{
trigScanMethod = Psi0Psi3Tc;
trigScanAppendStragglers = 1;
}
else
{
fprintf( stderr, "invalid argument to --%s:\n"
"unknown scan method specified: %s\n"
"(Must be one of T0T3Tc, T0T3TcAS, Psi0Psi3Tc, Psi0Psi3TcAS)\n",
long_options[option_index].name, LALoptarg );
exit( 1 );
}
ADD_PROCESS_PARAM( "string", "%s", LALoptarg );
break;
case '>':
/* TrigScan Template Metric Scaling Factor */
trigScanMetricScalingFac = atof( LALoptarg );
if ( trigScanMetricScalingFac <= 0.0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"ts-volume-safety must be > 0.0 : "
"(%f specified)\n",
long_options[option_index].name, trigScanMetricScalingFac );
exit( 1 );
}
ADD_PROCESS_PARAM( "float", "%s", LALoptarg );
break;
default:
fprintf( stderr, "Error: Unknown error while parsing options\n" );
print_usage(argv[0]);
exit( 1 );
}
}
/* check the values of the arguments */
if ( startTime < 0 )
{
fprintf( stderr, "Error: --gps-start-time must be specified\n" );
exit( 1 );
}
if ( endTime < 0 )
{
fprintf( stderr, "Error: --gps-end-time must be specified\n" );
exit( 1 );
}
/* Check the trigScan input parameters */
if ( ! trigScanMethod )
{
fprintf ( stderr, "You must specify --ts-method\n" );
exit(1);
}
if ( trigScanMetricScalingFac <= 0.0 )
{
fprintf ( stderr, "You must specify --ts-metric-scaling\n" );
exit(1);
}
/* fill the comment, if a user has specified one, or leave it blank */
if ( ! *comment )
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX,
" " );
}
else
{
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX,
"%s", comment );
snprintf( searchsumm.searchSummaryTable->comment, LIGOMETA_COMMENT_MAX,
"%s", comment );
}
/* delete the first, empty process_params entry */
this_proc_param = processParamsTable.processParamsTable;
processParamsTable.processParamsTable =
processParamsTable.processParamsTable->next;
free( this_proc_param );
/*
*
* read in the input data from the rest of the arguments
*
*/
if ( LALoptind < argc )
{
for( i = LALoptind; i < argc; ++i )
{
INT4 numFileTriggers = 0;
numFileTriggers = XLALReadInspiralTriggerFile( &inspiralEventList,
¤tTrigger, &searchSummList, &inputFiles, argv[i] );
if (numFileTriggers < 0)
{
fprintf(stderr, "Error reading triggers from file %s",
argv[i]);
exit( 1 );
}
numTriggers += numFileTriggers;
}
}
else
{
fprintf( stderr, "Error: No trigger files specified.\n" );
exit( 1 );
}
if ( vrbflg ) fprintf( stdout, "Read in a total of %d triggers.\n",
numTriggers );
if ( ! inspiralEventList )
{
/* no triggers read in so triggered bank will be empty */
fprintf( stdout, "No triggers read in\n");
exit( 0 );
}
/* trigScanClustering */
/* Call the clustering routine */
if (XLALTrigScanClusterTriggers( &(inspiralEventList),
trigScanMethod,
trigScanMetricScalingFac,
trigScanAppendStragglers ) == XLAL_FAILURE )
{
fprintf( stderr, "New trig scan has failed!!\n" );
exit(1);
}
/* time sort the triggers */
if ( vrbflg ) fprintf( stdout, "Sorting triggers\n" );
LAL_CALL( LALSortSnglInspiral( &status, &inspiralEventList,
LALCompareSnglInspiralByTime ), &status );
if( !inspiralEventList )
{
if ( vrbflg ) fprintf( stdout,
"No triggers remain after time and playground cuts.\n" );
/* set numTriggers after cuts were applied */
numTriggers = 0;
}
/*
*
* write the output xml file
*
*/
/* search summary entries: */
searchsumm.searchSummaryTable->in_start_time = startTimeGPS;
searchsumm.searchSummaryTable->in_end_time = endTimeGPS;
searchsumm.searchSummaryTable->out_start_time = startTimeGPS;
searchsumm.searchSummaryTable->out_end_time = endTimeGPS;
searchsumm.searchSummaryTable->nevents = numTriggers;
if ( vrbflg ) fprintf( stdout, "writing output file... " );
/* set the file name correctly */
if ( userTag && !outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%s-%d-%d.xml",
outputIFO, userTag, startTime, endTime - startTime );
}
else if ( !userTag && !outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%d-%d.xml",
outputIFO, startTime, endTime - startTime );
}
else if ( userTag && outCompress )
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%s-%d-%d.xml.gz",
outputIFO, userTag, startTime, endTime - startTime );
}
else
{
snprintf( fileName, FILENAME_MAX, "%s-TRIGSCAN_%d-%d.xml.gz",
outputIFO, startTime, endTime - startTime );
}
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status , &xmlStream, fileName ),
&status );
/* write process table */
snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "%s",
inputIFO );
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 );
/* write process_params table */
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
process_params_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, processParamsTable,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* write search_summary table */
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlStream,
search_summary_table ), &status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, searchsumm,
search_summary_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlStream ), &status );
/* write the search_summvars tabls */
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 the sngl_inspiral table */
if ( inspiralEventList )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status ,&xmlStream,
sngl_inspiral_table), &status );
inspiralTable.snglInspiralTable = inspiralEventList;
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlStream, inspiralTable,
sngl_inspiral_table), &status );
LAL_CALL( LALEndLIGOLwXMLTable( &status, &xmlStream), &status );
}
LAL_CALL( LALCloseLIGOLwXMLFile( &status, &xmlStream), &status );
if ( vrbflg ) fprintf( stdout, "done\n" );
/*
*
* clean up the memory that has been allocated
*
*/
if ( vrbflg ) fprintf( stdout, "freeing memory... " );
free( proctable.processTable );
free( searchsumm.searchSummaryTable );
while ( processParamsTable.processParamsTable )
{
this_proc_param = processParamsTable.processParamsTable;
processParamsTable.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
while ( inputFiles )
{
thisInputFile = inputFiles;
inputFiles = thisInputFile->next;
LALFree( thisInputFile );
}
while ( searchSummList )
{
thisSearchSumm = searchSummList;
searchSummList = searchSummList->next;
LALFree( thisSearchSumm );
}
while ( inspiralEventList )
{
currentTrigger = inspiralEventList;
inspiralEventList = inspiralEventList->next;
LAL_CALL( LALFreeSnglInspiral( &status, ¤tTrigger ), &status );
}
if ( userTag ) free( userTag );
if ( ifoTag ) free( ifoTag );
if ( vrbflg ) fprintf( stdout, "done\n" );
LALCheckMemoryLeaks();
exit( 0 );
}
int main( int argc, char *argv[] )
{
LALStatus status = blank_status;
const INT4 S2StartTime = 729273613; /* Feb 14 2003 16:00:00 UTC */
const INT4 S2StopTime = 734367613; /* Apr 14 2003 15:00:00 UTC */
/* command line options */
LIGOTimeGPS gpsStartTime = {S2StartTime, 0};
LIGOTimeGPS gpsEndTime = {S2StopTime, 0};
REAL8 meanTimeStep = 2630 / LAL_PI;
REAL8 timeInterval = 0;
UINT4 randSeed = 1;
CHAR *userTag = NULL;
REAL4 minMass = 0.1;
REAL4 maxMass = 1.0;
REAL4 r_core = 5.0; /* kpc core radius */
REAL4 r_max = 50.0; /* kpc halo radius */
REAL4 q = 1.0; /* flatten halo */
/* program variables */
RandomParams *randParams = NULL;
REAL4 u;
REAL4 deltaM;
int i, stat;
const int maxIter = 1000;
const double tol = 1e-6;
const gsl_root_fsolver_type *solver_type;
gsl_root_fsolver *solver;
gsl_function pdf;
struct halo_pdf_params pdf_params;
double r_lo, r_hi, r;
double cosphi, sinphi;
double pdf_norm;
GalacticInspiralParamStruc galacticPar;
/* xml output data */
CHAR fname[256];
MetadataTable proctable;
MetadataTable procparams;
MetadataTable injections;
ProcessParamsTable *this_proc_param;
SimInspiralTable *this_inj = NULL;
LIGOLwXMLStream xmlfp;
UINT4 outCompress = 0;
/* LALgetopt arguments */
struct LALoption long_options[] =
{
{"help", no_argument, 0, 'h'},
{"verbose", no_argument, &vrbflg, 1 },
{"write-compress", no_argument, &outCompress, 1 },
{"gps-start-time", required_argument, 0, 'a'},
{"gps-end-time", required_argument, 0, 'b'},
{"time-step", required_argument, 0, 't'},
{"time-interval", required_argument, 0, 'i'},
{"seed", required_argument, 0, 's'},
{"minimum-mass", required_argument, 0, 'A'},
{"maximum-mass", required_argument, 0, 'B'},
{"core-radius", required_argument, 0, 'p'},
{"flatten-halo", required_argument, 0, 'q'},
{"halo-radius", required_argument, 0, 'r'},
{"user-tag", required_argument, 0, 'Z'},
{"userTag", required_argument, 0, 'Z'},
{0, 0, 0, 0}
};
int c;
/* 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));
if (strcmp(CVS_REVISION,"$Revi" "sion$"))
{
XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME,
CVS_REVISION, CVS_SOURCE, CVS_DATE, 0);
}
else
{
XLALPopulateProcessTable(proctable.processTable, PROGRAM_NAME,
lalappsGitCommitID, lalappsGitGitStatus, lalappsGitCommitDate, 0);
}
snprintf( proctable.processTable->comment, LIGOMETA_COMMENT_MAX, " " );
this_proc_param = procparams.processParamsTable = (ProcessParamsTable *)
calloc( 1, sizeof(ProcessParamsTable) );
/*
*
* parse command line arguments
*
*/
while ( 1 )
{
/* LALgetopt_long stores long option here */
int option_index = 0;
long int gpsinput;
size_t LALoptarg_len;
c = LALgetopt_long_only( argc, argv,
"a:A:b:B:hi:p:q:r:s:t: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 'a':
gpsinput = atol( LALoptarg );
if ( gpsinput < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpsinput );
exit( 1 );
}
gpsStartTime.gpsSeconds = gpsinput;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gpsinput );
break;
case 'b':
gpsinput = atol( LALoptarg );
if ( gpsinput < 441417609 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"GPS start time is prior to "
"Jan 01, 1994 00:00:00 UTC:\n"
"(%ld specified)\n",
long_options[option_index].name, gpsinput );
exit( 1 );
}
gpsEndTime.gpsSeconds = gpsinput;
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%ld", gpsinput );
break;
case 's':
randSeed = atoi( LALoptarg );
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "int",
"%d", randSeed );
break;
case 't':
meanTimeStep = (REAL8) atof( LALoptarg );
if ( meanTimeStep <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"time step must be > 0: (%le seconds specified)\n",
long_options[option_index].name, meanTimeStep );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name, "float",
"%le", meanTimeStep );
break;
case 'i':
timeInterval = atof( LALoptarg );
if ( timeInterval < 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"time interval must be >= 0: (%le seconds specified)\n",
long_options[option_index].name, meanTimeStep );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%le", timeInterval );
break;
case 'A':
minMass = (REAL4) atof( LALoptarg );
if ( minMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"miniumum component mass must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, minMass );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", minMass );
break;
case 'B':
maxMass = (REAL4) atof( LALoptarg );
if ( maxMass <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"maxiumum component mass must be > 0: "
"(%f solar masses specified)\n",
long_options[option_index].name, maxMass );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", maxMass );
break;
case 'p':
/* core-radius */
r_core = (REAL4) atof( LALoptarg );
if ( r_core <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"galactic core radius must be > 0: "
"(%f kpc specified)\n",
long_options[option_index].name, r_core );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", r_core );
break;
case 'q':
/* flatten-halo */
q = (REAL4) atof( LALoptarg );
if ( q <= 0 || q > 1 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"halo flattening parameter must be in range (0,1]: "
"(%f specified)\n",
long_options[option_index].name, q );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", q );
break;
case 'r':
/* max halo radius */
r_max = (REAL4) atof( LALoptarg );
if ( r_max <= 0 )
{
fprintf( stderr, "invalid argument to --%s:\n"
"halo radius must be greater than 0: "
"(%f kpc specified)\n",
long_options[option_index].name, r_max );
exit( 1 );
}
this_proc_param = this_proc_param->next =
next_process_param( long_options[option_index].name,
"float", "%e", r_max );
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 =
next_process_param( long_options[option_index].name,
"string", "%s", LALoptarg );
break;
case 'v':
vrbflg = 1;
break;
case 'h':
fprintf( stderr, USAGE );
exit( 0 );
break;
case '?':
fprintf( stderr, USAGE );
exit( 1 );
break;
default:
fprintf( stderr, "unknown error while parsing options\n" );
fprintf( stderr, USAGE );
exit( 1 );
}
}
if ( LALoptind < argc )
{
fprintf( stderr, "extraneous command line arguments:\n" );
while ( LALoptind < argc )
{
fprintf ( stderr, "%s\n", argv[LALoptind++] );
}
exit( 1 );
}
/*
*
* initialization
*
*/
/* initialize the random number generator */
LAL_CALL( LALCreateRandomParams( &status, &randParams, randSeed ), &status );
/* initialize the gsl solver with the spatial pdf */
pdf.function = &halo_pdf;
pdf.params = &pdf_params;
solver_type = gsl_root_fsolver_bisection;
solver = gsl_root_fsolver_alloc( solver_type );
pdf_params.a = r_core;
/* normalization for the spatial pdf */
pdf_norm = r_max - r_core * atan2( r_max, r_core );
/* mass range */
deltaM = maxMass - minMass;
/* null out the head of the linked list */
injections.simInspiralTable = NULL;
/* create the output file name */
if ( userTag && outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d_%s-%d-%d.xml.gz",
randSeed, userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( userTag && !outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d_%s-%d-%d.xml",
randSeed, userTag, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else if ( !userTag && outCompress )
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d-%d-%d.xml.gz",
randSeed, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
else
{
snprintf( fname, sizeof(fname), "HL-INJECTIONS_%d-%d-%d.xml",
randSeed, gpsStartTime.gpsSeconds,
gpsEndTime.gpsSeconds - gpsStartTime.gpsSeconds );
}
/*
*
* loop over duration of desired output times
*
*/
while ( XLALGPSCmp( &gpsStartTime, &gpsEndTime ) < 0 )
{
/* uniformly distributed masses */
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
galacticPar.m1 = minMass + u * deltaM;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
galacticPar.m2 = minMass + u * deltaM;
/* spatial distribution */
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
pdf_params.u = u * pdf_norm;
r_lo = 0.0;
r_hi = r_max;
gsl_root_fsolver_set( solver, &pdf, r_lo, r_hi );
for ( i = 0; i < maxIter; ++i )
{
gsl_root_fsolver_iterate( solver );
r = gsl_root_fsolver_root( solver );
r_lo = gsl_root_fsolver_x_lower( solver );
r_hi = gsl_root_fsolver_x_upper( solver );
stat = gsl_root_test_interval( r_lo, r_hi, 0, tol );
if ( stat == GSL_SUCCESS )
break;
}
if ( stat != GSL_SUCCESS )
{
fprintf( stderr, "could not find root after %d iterations\n", maxIter );
exit( 1 );
}
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
sinphi = 2.0 * u - 1.0;
cosphi = sqrt( 1.0 - sinphi*sinphi );
galacticPar.rho = r * cosphi;
galacticPar.z = q * r * sinphi;
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
galacticPar.lGal = LAL_TWOPI * u;
if ( vrbflg ) fprintf( stdout, "%e %e %e %e %e\n",
galacticPar.m1, galacticPar.m2,
galacticPar.rho * cos( galacticPar.lGal ),
galacticPar.rho * sin( galacticPar.lGal ),
galacticPar.z );
/* create the sim_inspiral table */
if ( injections.simInspiralTable )
{
this_inj = this_inj->next = (SimInspiralTable *)
LALCalloc( 1, sizeof(SimInspiralTable) );
}
else
{
injections.simInspiralTable = this_inj = (SimInspiralTable *)
LALCalloc( 1, sizeof(SimInspiralTable) );
}
/* set the geocentric end time of the injection */
galacticPar.geocentEndTime = gpsStartTime;
if ( timeInterval )
{
LAL_CALL( LALUniformDeviate( &status, &u, randParams ), &status );
XLALGPSAdd( &(galacticPar.geocentEndTime), u * timeInterval );
}
/* populate the sim_inspiral table */
LAL_CALL( LALGalacticInspiralParamsToSimInspiralTable( &status,
this_inj, &galacticPar, randParams ), &status );
/* set the source and waveform fields */
snprintf( this_inj->source, LIGOMETA_SOURCE_MAX, "MW" );
snprintf( this_inj->waveform, LIGOMETA_WAVEFORM_MAX,
"GeneratePPNtwoPN" );
/* increment the injection time */
XLALGPSAdd( &gpsStartTime, meanTimeStep );
} /* end loop over injection times */
/* destroy random parameters */
LAL_CALL( LALDestroyRandomParams( &status, &randParams ), &status );
/*
*
* write output to LIGO_LW XML file
*
*/
/* open the xml file */
memset( &xmlfp, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &status, &xmlfp, fname ), &status );
/* write the process table */
snprintf( proctable.processTable->ifos, LIGOMETA_IFOS_MAX, "H1H2L1" );
XLALGPSTimeNow(&(proctable.processTable->end_time));
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, process_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, proctable,
process_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
free( proctable.processTable );
/* free the unused process param entry */
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = procparams.processParamsTable->next;
free( this_proc_param );
/* write the process params table */
if ( procparams.processParamsTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, process_params_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, procparams,
process_params_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
while( procparams.processParamsTable )
{
this_proc_param = procparams.processParamsTable;
procparams.processParamsTable = this_proc_param->next;
free( this_proc_param );
}
}
/* write the sim_inspiral table */
if ( injections.simInspiralTable )
{
LAL_CALL( LALBeginLIGOLwXMLTable( &status, &xmlfp, sim_inspiral_table ),
&status );
LAL_CALL( LALWriteLIGOLwXMLTable( &status, &xmlfp, injections,
sim_inspiral_table ), &status );
LAL_CALL( LALEndLIGOLwXMLTable ( &status, &xmlfp ), &status );
}
while ( injections.simInspiralTable )
{
this_inj = injections.simInspiralTable;
injections.simInspiralTable = injections.simInspiralTable->next;
LALFree( this_inj );
}
/* close the injection file */
LAL_CALL( LALCloseLIGOLwXMLFile ( &status, &xmlfp ), &status );
/* check for memory leaks and exit */
LALCheckMemoryLeaks();
return 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 );
}
