int main( int argc, char *argv[] )
{
static LALStatus status;
UINT4 loop = 0; /* loop counter */
Math3DPointList *list = NULL; /* structure for mathematica plot */
Math3DPointList *first = NULL;
SnglInspiralTable *bankHead = NULL;
SnglInspiralTable *tmplt = NULL;
InspiralCoarseBankIn coarseIn;
INT4 ntiles = 0; /* number of tiles */
INT2 Math3DPlot = 0; /* option flag for Mathematica plot */
INT4 opt = 0; /* returning value of LALgetopt() */
INT4 optflag = -1; /* Command Line option */
REAL8Vector *psd = NULL;
REAL8 df = 1.0;
InspiralTemplate inspiralTemplate;
REAL4 noiseMin = 1;
BOOLEAN haveXML = 0;
if( (list = (Math3DPointList *) LALCalloc( 1, sizeof( Math3DPointList )))
== NULL )
{
LALError( &status, INSPIRALSPINBANKTESTC_MSGEMEM );
printf( INSPIRALSPINBANKTESTC_MSGEMEM );
return INSPIRALSPINBANKTESTC_EMEM;
}
first = list;
/* Stuff for calculating the PSD and Noise Moments */
coarseIn.fLower = inspiralTemplate.fLower = 30;
coarseIn.fUpper = inspiralTemplate.fCutoff = 2000;
coarseIn.iflso = 0;
/* Parse options. */
do
{
optflag++;
switch (opt)
{
case 'b':
#if LAL_METAIO_ENABLED
if( (ntiles = LALSnglInspiralTableFromLIGOLw( &bankHead, LALoptarg, 1,
20000)) < 1 )
{
fprintf( stderr, INSPIRALSPINBANKTESTC_MSGEFILE );
return INSPIRALSPINBANKTESTC_EFILE;
}
haveXML = 1;
#endif
break;
case 'm':
coarseIn.mmCoarse = atof( LALoptarg );
break;
case 'n':
coarseIn.mMin = atof( LALoptarg );
break;
case 'p':
Math3DPlot = 1;
break;
case 's':
break;
case 'x':
coarseIn.MMax = atof( LALoptarg );
break;
default:
coarseIn.mmCoarse = 0.1;
coarseIn.mMin = 1.0;
coarseIn.MMax = 2*3.0;
Math3DPlot = 0;
break;
}
}
while( (opt = LALgetopt( argc, argv, "b:n:m:x:ps" )) != -1 );
/* Generate template bank from model noise if not given an XML file. */
if( !haveXML )
{
coarseIn.shf.data = NULL;
memset( &(coarseIn.shf), 0, sizeof( REAL8FrequencySeries ) );
coarseIn.shf.f0 = 0;
LALDCreateVector( &status, &psd, coarseIn.fUpper );
df = 1.0;
LALNoiseSpectralDensity( &status, psd, &LALLIGOIPsd, df );
coarseIn.shf.data = psd;
coarseIn.shf.deltaF = df;
for( loop = 0; loop < psd->length; loop++ )
{
if( psd->data[loop] > 0 && psd->data[loop] < noiseMin )
{
noiseMin = psd->data[loop];
}
}
LALInspiralSpinBank( &status, &bankHead, &ntiles, &coarseIn );
if( status.statusCode )
{
LALError( &status, INSPIRALSPINBANKTESTC_MSGESUB );
printf( INSPIRALSPINBANKTESTC_MSGESUB );
return INSPIRALSPINBANKTESTC_ESUB;
}
}
/* Convert template bank structure to plot input structure. */
if( Math3DPlot )
{
for( tmplt = bankHead; tmplt != NULL; tmplt = tmplt->next )
{
list->x = tmplt->psi0;
list->y = tmplt->psi3;
list->z = tmplt->beta;
list->grayLevel = 1.0*loop/ntiles;
if( (list = list->next = (Math3DPointList *) LALCalloc( 1, sizeof(
Math3DPointList ))) == NULL ) {
LALError( &status, INSPIRALSPINBANKTESTC_MSGEMEM );
printf( INSPIRALSPINBANKTESTC_MSGEMEM );
return INSPIRALSPINBANKTESTC_EMEM;
}
}
list->next = NULL;
LALMath3DPlot( &status, first, &ntiles, NULL );
if( status.statusCode )
{
LALError( &status, INSPIRALSPINBANKTESTC_MSGESUB );
printf( INSPIRALSPINBANKTESTC_MSGESUB );
return INSPIRALSPINBANKTESTC_ESUB;
}
/* Clean Up the memory from the MathPlot3D structure */
list = first;
while( list->next )
{
first = list->next;
LALFree( list );
list = first;
}
}
/* free the last (first?) memory allocated for Math3DPlot. */
LALFree( list );
if (status.statusCode)
return INSPIRALSPINBANKTESTC_ESUB;
else
return INSPIRALSPINBANKTESTC_ENORM;
}
int main( int argc, char *argv[] )
{
/* lal initialization variables */
LALStatus stat = blank_status;
/* Argument pointers */
CHAR *inFile = NULL;
CHAR *vetoFile = NULL;
CHAR *outFile = NULL;
/* Program operation variables */
LALSegList vetoSegs;
SnglInspiralTable *events = NULL;
INT4 numEvents = 0;
INT4 numEventsKept = 0;
SnglInspiralTable *eventHead = NULL;
SnglInspiralTable *thisEvent = NULL;
SnglInspiralTable *tmpEvent = NULL;
SnglInspiralTable *prevEvent = NULL;
LIGOLwXMLStream xmlStream;
MetadataTable outputTable;
/*------ Beginning of code ------*/
/*-- Check command-line arguments --*/
if ( argc != 4 ) {
printf( USAGE );
exit( 0 );
}
inFile = argv[1];
vetoFile = argv[2];
outFile = argv[3];
/* set up inital debugging values */
lal_errhandler = LAL_ERR_EXIT;
/*-- Initialize the veto segment list, and read the veto file --*/
XLALSegListInit( &vetoSegs );
LAL_CALL( LALSegListRead( &stat, &vetoSegs, vetoFile, "" ), &stat );
/*-- Make sure the list of veto segments is coalesced for fast searching --*/
XLALSegListCoalesce( &vetoSegs );
/*-- Read the inspiral events from the file --*/
numEvents = LALSnglInspiralTableFromLIGOLw( &events, inFile, 0, -1 );
if ( numEvents < 0 ) {
fprintf( stderr, "error: unable to read sngl_inspiral table from %s\n",
inFile );
exit( 1 );
}
/*-- Report the number of events read in --*/
printf( "Read %d events from input file\n", numEvents );
/*-- Loop over inspiral triggers --*/
thisEvent = events;
while ( thisEvent ) {
/*-- Check the time of this event against the veto segment list --*/
if ( XLALSegListSearch( &vetoSegs, &(thisEvent->end_time) ) == NULL ) {
/* This inspiral trigger does not fall within any veto segment */
/* keep the trigger and increment the count of triggers */
if ( ! eventHead ) eventHead = thisEvent;
prevEvent = thisEvent;
thisEvent = thisEvent->next;
++numEventsKept;
} else {
/*-- This event's end_time falls within one of the veto segments --*/
/* discard the trigger and move to the next one */
if ( prevEvent ) prevEvent->next = thisEvent->next;
tmpEvent = thisEvent;
thisEvent = thisEvent->next;
LAL_CALL ( LALFreeSnglInspiral ( &stat, &tmpEvent ), &stat);
}
}
/* make sure that the linked list is properly terminated */
if ( prevEvent && prevEvent->next ) prevEvent->next->next = NULL;
/*-- Report the number of events kept --*/
printf( "Kept %d events\n", numEventsKept );
/*-- Write out the surviving triggers --*/
memset( &xmlStream, 0, sizeof(LIGOLwXMLStream) );
LAL_CALL( LALOpenLIGOLwXMLFile( &stat, &xmlStream, outFile ), &stat );
if ( eventHead )
{
outputTable.snglInspiralTable = eventHead;
LAL_CALL( LALBeginLIGOLwXMLTable( &stat, &xmlStream,
sngl_inspiral_table ), &stat );
LAL_CALL( LALWriteLIGOLwXMLTable( &stat, &xmlStream, outputTable,
sngl_inspiral_table ), &stat );
LAL_CALL( LALEndLIGOLwXMLTable( &stat, &xmlStream ), &stat);
}
/* close the output file */
LAL_CALL( LALCloseLIGOLwXMLFile(&stat, &xmlStream), &stat);
/*-- Free memory and exit --*/
while ( eventHead )
{
thisEvent = eventHead;
eventHead = eventHead->next;
LAL_CALL ( LALFreeSnglInspiral ( &stat, &thisEvent ), &stat);
}
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[] )
{
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 )
{
UINT4 line=0, i;
UINT8 id=0;
UINT4 start = 0;
ResultIn trigger;
REAL4 tau0, tau3, tau0I, tau3I, psi0, psi3, phaseI, coaTime;
FILE *input1, *input2, *bank;
FILE *output;
SnglInspiralTable *inputData = NULL;
INT4 numFileTriggers = 0;
MetadataTable templateBank;
char sbuf[512];
if (argc>1) {
if (strcmp(argv[1], "--help")==0) {
BEAscii2XmlHelp();
}
if (strcmp(argv[1], "-h")==0) {
BEAscii2XmlHelp();
}
}
/* Main program starts here */
/* First we open the file containing the ascii results */
fprintf(stderr,"opening the xml output data file -- %s", BEASCII2XML_OUTPUT);
output = fopen(BEASCII2XML_OUTPUT,"w");
fprintf(stderr,"done\n");
fprintf(stderr,"opening the xml input data file -- %s", BEASCII2XML_INPUT1);
if ( (input1 = fopen(BEASCII2XML_INPUT1,"r"))==NULL) {
fprintf(stderr,"error while opening input file %s\n",BEASCII2XML_INPUT1);
exit(0);
}
fprintf(stderr,"done\n");
fprintf(stderr,"opening the xml prototype (argument of BankEfficiency code) -- ");
if ( (input2 = fopen(BEASCII2XML_INPUT2,"r"))==NULL)
{
fprintf(stderr,"error while opening input file %s\n",BEASCII2XML_INPUT2);
fprintf(stderr,"the xml file will not contains parameters information\n");
PRINT_LIGOLW_XML_HEADER(output);
fprintf(stderr,"creating the header file -- done\n");
}
else
{
/* read prototype and save in outputfile */
fprintf(stderr,"parsing the prototype -- ");
while(fgets(sbuf,1024,input2) !=NULL)
fputs(sbuf, output);
fprintf(stderr," done\n");
}
/* insert the template bank here */
if ( (bank = fopen(BEASCII2XML_BANK,"r"))==NULL)
{
fprintf(stderr,"error while opening input file %s\n",BEASCII2XML_BANK);
fprintf(stderr,"the xml file will not contains the bank table\n");
}
else
{
/* read prototype and save in outputfile */
fprintf(stderr,"parsing the bank -- ");
fprintf( stdout, "reading triggers from file: %s\n", BEASCII2XML_BANK );
numFileTriggers =
LALSnglInspiralTableFromLIGOLw( &inputData,BEASCII2XML_BANK , 0, -1 );
fprintf(stderr," done %d\n", numFileTriggers);
myfprintf(output, LIGOLW_XML_SNGL_INSPIRAL );
while(inputData)
{
/* id = inputData->event_id->id;*/
fprintf(output, SNGL_INSPIRAL_ROW,
inputData->ifo,
inputData->search,
inputData->channel,
inputData->end_time.gpsSeconds,
inputData->end_time.gpsNanoSeconds,
inputData->end_time_gmst,
inputData->impulse_time.gpsSeconds,
inputData->impulse_time.gpsNanoSeconds,
inputData->template_duration,
inputData->event_duration,
inputData->amplitude,
inputData->eff_distance,
inputData->coa_phase,
inputData->mass1,
inputData->mass2,
inputData->mchirp,
inputData->mtotal,
inputData->eta,
inputData->tau0,
inputData->tau2,
inputData->tau3,
inputData->tau4,
inputData->tau5,
inputData->ttotal,
inputData->psi0,
inputData->psi3,
inputData->alpha,
inputData->alpha1,
inputData->alpha2,
inputData->alpha3,
inputData->alpha4,
inputData->alpha5,
inputData->alpha6,
inputData->beta,
inputData->f_final,
inputData->snr,
inputData->chisq,
inputData->chisq_dof,
inputData->sigmasq,
id);
inputData = inputData->next;
fprintf(output, "\n");
}
myfprintf(output, LIGOLW_XML_TABLE_FOOTER );
}
PRINT_LIGOLW_XML_BANKEFFICIENCY(output);
fprintf(stderr,"done\n");
/* read ascii input and save in xml format */
fprintf(stderr,"reading the ascii file -- and saving xml file");
do
{
fscanf(input1,BANKEFFICIENCY_PARAMS_ROW_SPACE,
&trigger.psi0_triggerU,
&trigger.psi3_triggerU,
&trigger.psi0_trigger,
&trigger.psi3_trigger,
&psi0,
&psi3,
&tau0,
&tau3,
&tau0I,
&tau3I,
&trigger.fend_triggerU,
&trigger.fend_trigger,
&trigger.fend_inject,
&trigger.mass1_inject,
&trigger.mass2_inject,
&trigger.rho_finalU,
&trigger.phaseU,
&phaseI,
&trigger.alphaFU,
&trigger.layerU,
&trigger.binU,
&trigger.rho_final,
&trigger.snrAtCoaTime,
&phaseI,
&trigger.phase,
&trigger.alphaF,
&trigger.layer,
&trigger.bin,
&coaTime);
if (start==0){
start+=1;
}
else
{
fprintf(output,",\n");
}
fprintf(output, BANKEFFICIENCY_PARAMS_ROW,
trigger.psi0_triggerU,
trigger.psi3_triggerU,
trigger.psi0_trigger,
trigger.psi3_trigger,
psi0,
psi3,
tau0,
tau3,
tau0I,
tau3I,
trigger.fend_triggerU,
trigger.fend_trigger,
trigger.fend_inject,
trigger.mass1_inject,
trigger.mass2_inject,
trigger.rho_finalU,
phaseI,
trigger.phaseU,
trigger.alphaFU,
trigger.layerU,
trigger.binU,
trigger.rho_final,
trigger.snrAtCoaTime,
phaseI,
trigger.phase,
trigger.alphaF,
trigger.layer,
trigger.bin,
coaTime);
line++;
}
while(!feof(input1));
fprintf(stderr,"read %d lines...done\n", line);
PRINT_LIGOLW_XML_TABLE_FOOTER(output);
PRINT_LIGOLW_XML_FOOTER(output);
fclose(output);
fprintf(stderr,"closing xml file\n");
return 0;
}
