/*---------- function definitions ---------- */
int main(int argc,char *argv[])
{
LALStatus status = blank_status; /* initialize status */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT; /* exit with returned status-code on error */
/* register all user-variables */
LAL_CALL (InitUserVars(&status, &CommandLineArgs), &status);
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
LAL_CALL (LALUserVarReadAllInput(&status, &should_exit, argc, argv), &status);
if (should_exit)
return EXIT_FAILURE;
LAL_CALL ( CheckUserInput (&status, &CommandLineArgs), &status);
LAL_CALL ( Initialize (&status, &CommandLineArgs), &status);
/*---------- central function: compute F-statistic ---------- */
LAL_CALL ( ComputeF(&status, CommandLineArgs), &status);
/* Free remaining memory */
LAL_CALL ( LALSDestroyVector(&status, &(amc.a) ), &status);
LAL_CALL ( LALSDestroyVector(&status, &(amc.b) ), &status);
LAL_CALL ( LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
return 0;
} /* main() */
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[] )
{
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[] )
{
/* 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[])
{
LALStatus status = blank_status;
ConfigVariables XLAL_INIT_DECL(config);
UserVariables_t XLAL_INIT_DECL(uvar);
/* register user-variables */
XLAL_CHECK ( XLALInitUserVars ( &uvar ) == XLAL_SUCCESS, XLAL_EFUNC );
/* read cmdline & cfgfile */
BOOLEAN should_exit = 0;
XLAL_CHECK( XLALUserVarReadAllInput( &should_exit, argc, argv ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( should_exit ) {
exit(1);
}
if ( uvar.version )
{
XLALOutputVersionString ( stdout, lalDebugLevel );
exit(0);
}
/* basic setup and initializations */
XLAL_CHECK ( XLALInitCode( &config, &uvar, argv[0] ) == XLAL_SUCCESS, XLAL_EFUNC );
/* ----- allocate memory for AM-coeffs ----- */
AMCoeffs AMold, AMnew1, AMnew2; /**< containers holding AM-coefs computed by 3 different AM functions */
AMold.a = XLALCreateREAL4Vector ( 1 );
AMold.b = XLALCreateREAL4Vector ( 1 );
AMnew1.a = XLALCreateREAL4Vector ( 1 );
AMnew1.b = XLALCreateREAL4Vector ( 1 );
AMnew2.a = XLALCreateREAL4Vector ( 1 );
AMnew2.b = XLALCreateREAL4Vector ( 1 );
XLAL_CHECK ( AMold.a && AMold.b && AMnew1.a && AMnew1.b && AMnew2.a && AMnew2.a, XLAL_ENOMEM, "Failed to XLALCreateREAL4Vector ( 1 )\n" );
/* ----- get detector-state series ----- */
DetectorStateSeries *detStates = NULL;
XLAL_CHECK ( (detStates = XLALGetDetectorStates ( config.timestamps, config.det, config.edat, 0 )) != NULL, XLAL_EFUNC );
/* ----- compute associated SSB timing info ----- */
SSBtimes *tSSB = XLALGetSSBtimes ( detStates, config.skypos, config.timeGPS, SSBPREC_RELATIVISTIC );
XLAL_CHECK ( tSSB != NULL, XLAL_EFUNC, "XLALGetSSBtimes() failed with xlalErrno = %d\n", xlalErrno );
/* ===== 1) compute AM-coeffs the 'old way': [used in CFSv1] ===== */
BarycenterInput XLAL_INIT_DECL(baryinput);
AMCoeffsParams XLAL_INIT_DECL(amParams);
EarthState earth;
baryinput.site.location[0] = config.det->location[0]/LAL_C_SI;
baryinput.site.location[1] = config.det->location[1]/LAL_C_SI;
baryinput.site.location[2] = config.det->location[2]/LAL_C_SI;
baryinput.alpha = config.skypos.longitude;
baryinput.delta = config.skypos.latitude;
baryinput.dInv = 0.e0;
/* amParams structure to compute a(t) and b(t) */
amParams.das = XLALMalloc(sizeof(*amParams.das));
amParams.das->pSource = XLALMalloc(sizeof(*amParams.das->pSource));
amParams.baryinput = &baryinput;
amParams.earth = &earth;
amParams.edat = config.edat;
amParams.das->pDetector = config.det;
amParams.das->pSource->equatorialCoords.longitude = config.skypos.longitude;
amParams.das->pSource->equatorialCoords.latitude = config.skypos.latitude;
amParams.das->pSource->orientation = 0.0;
amParams.das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams.polAngle = 0;
LAL_CALL ( LALComputeAM ( &status, &AMold, config.timestamps->data, &amParams), &status);
XLALFree ( amParams.das->pSource );
XLALFree ( amParams.das );
/* ===== 2) compute AM-coeffs the 'new way' using LALNewGetAMCoeffs() */
LALGetAMCoeffs ( &status, &AMnew1, detStates, config.skypos );
if ( status.statusCode ) {
XLALPrintError ("%s: call to LALGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode );
XLAL_ERROR ( status.statusCode & XLAL_EFUNC );
}
/* ===== 3) compute AM-coeffs the 'newer way' using LALNewGetAMCoeffs() [used in CFSv2] */
LALNewGetAMCoeffs ( &status, &AMnew2, detStates, config.skypos );
if ( status.statusCode ) {
XLALPrintError ("%s: call to LALNewGetAMCoeffs() failed, status = %d\n\n", __func__, status.statusCode );
XLAL_ERROR ( status.statusCode & XLAL_EFUNC );
}
/* ===== 4) use standalone version of the above [used in FstatMetric_v2] */
REAL8 a0,b0;
if ( XLALComputeAntennaPatternCoeffs ( &a0, &b0, &config.skypos, &config.timeGPS, config.det, config.edat ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALComputeAntennaPatternCoeffs() failed.\n", __func__ );
XLAL_ERROR ( XLAL_EFUNC );
}
/* ==================== output the results ==================== */
printf ("\n");
printf ("----- Input parameters:\n");
printf ("tGPS = { %d, %d }\n", config.timeGPS.gpsSeconds, config.timeGPS.gpsNanoSeconds );
printf ("Detector = %s\n", config.det->frDetector.name );
printf ("Sky position: longitude = %g rad, latitude = %g rad [equatorial coordinates]\n", config.skypos.longitude, config.skypos.latitude );
printf ("\n");
printf ("----- Antenna pattern functions (a,b):\n");
printf ("LALComputeAM: ( %-12.8g, %-12.8g) [REAL4]\n", AMold.a->data[0], AMold.b->data[0] );
printf ("LALGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew1.a->data[0], AMnew1.b->data[0] );
printf ("LALNewGetAMCoeffs: ( %-12.8g, %-12.8g) [REAL4]\n", AMnew2.a->data[0]/config.sinzeta, AMnew2.b->data[0]/config.sinzeta );
printf ("XLALComputeAntennaPatternCoeffs: ( %-12.8g, %-12.8g) [REAL8]\n", a0/config.sinzeta, b0/config.sinzeta );
printf ("\n");
printf ("----- Detector & Earth state:\n");
REAL8 *pos = detStates->data[0].rDetector;
printf ("Detector position [ICRS J2000. Units=sec]: rDet = {%g, %g, %g}\n", pos[0], pos[1], pos[2] );
REAL8 *vel = detStates->data[0].vDetector;
printf ("Detector velocity [ICRS J2000. Units=c]: vDet = {%g, %g, %g}\n", vel[0], vel[1], vel[2] );
printf ("Local mean sideral time: LMST = %g rad\n", detStates->data[0].LMST);
printf ("\n");
printf ("----- SSB timing data:\n");
printf ("TOA difference tSSB - tDet = %g s\n", tSSB->DeltaT->data[0] );
printf ("TOA rate of change dtSSB/dtDet - 1 = %g\n", tSSB->Tdot->data[0] - 1.0 );
printf ("\n\n");
/* ----- done: free all memory */
XLAL_CHECK ( XLALDestroyConfig( &config ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyDetectorStateSeries ( detStates );
XLALDestroyREAL4Vector ( AMold.a );
XLALDestroyREAL4Vector ( AMold.b );
XLALDestroyREAL4Vector ( AMnew1.a );
XLALDestroyREAL4Vector ( AMnew1.b );
XLALDestroyREAL4Vector ( AMnew2.a );
XLALDestroyREAL4Vector ( AMnew2.b );
XLALDestroyREAL8Vector ( tSSB->DeltaT );
XLALDestroyREAL8Vector ( tSSB->Tdot );
XLALFree (tSSB);
LALCheckMemoryLeaks();
return 0;
} /* main */
int main(int argc, char **argv)
{
FILE *fp = NULL;
FILE *fp2 = NULL;
FILE *fp3 = NULL;
FILE *fp4 = NULL;
LALStatus status = blank_status;
SFTCatalog *catalog = NULL;
SFTVector *sft_vect = NULL;
INT4 i,j,k,l;
INT4 numBins, nSFT;
SFTConstraints constraints=empty_SFTConstraints;
LIGOTimeGPS startTime, endTime;
REAL8 avg =0;
REAL4 *timeavg =NULL;
REAL4 PWR,SNR;
REAL8 f =0;
CHAR outbase[256],outfile[256],outfile2[256],outfile3[256], outfile4[256]; /*, outfile6[256]; */
REAL8 NumBinsAvg =0;
REAL8 timebaseline =0;
BOOLEAN help = 0;
CHAR *SFTpatt = NULL;
CHAR *IFO = NULL;
INT4 startGPS = 0;
INT4 endGPS = 0;
REAL8 f_min = 0.0;
REAL8 f_max = 0.0;
REAL8 freqres =0.0;
INT4 blocksRngMed = 101;
CHAR *outputBname = NULL;
INT4 cur_epoch = 0, next_epoch = 0;
/* these varibales are for converting GPS seconds into UTC time and date*/
struct tm date;
CHARVector *timestamp = NULL;
CHARVector *year_date = NULL;
REAL8Vector *timestamps=NULL;
CHAR *psrInput = NULL;
CHAR *psrEphemeris = NULL;
CHAR *earthFile = NULL;
CHAR *sunFile = NULL;
/*========================================================================================================================*/
LAL_CALL(LALRegisterBOOLUserVar (&status, "help", 'h', UVAR_HELP, "Print this help message", &help ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "SFTs", 'p', UVAR_REQUIRED, "SFT location/pattern", &SFTpatt ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "IFO", 'I', UVAR_REQUIRED, "Detector", &IFO ), &status);
LAL_CALL(LALRegisterINTUserVar (&status, "startGPS", 's', UVAR_REQUIRED, "Starting GPS time", &startGPS ), &status);
LAL_CALL(LALRegisterINTUserVar (&status, "endGPS", 'e', UVAR_REQUIRED, "Ending GPS time", &endGPS ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "fMin", 'f', UVAR_REQUIRED, "Minimum frequency", &f_min ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "fMax", 'F', UVAR_REQUIRED, "Maximum frequency", &f_max ), &status);
LAL_CALL(LALRegisterINTUserVar (&status, "blocksRngMed", 'w', UVAR_OPTIONAL, "Running Median window size", &blocksRngMed), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "outputBname", 'o', UVAR_OPTIONAL, "Base name of output files", &outputBname ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "freqRes", 'r', UVAR_REQUIRED, "Spectrogram freq resolution", &freqres ), &status);
LAL_CALL(LALRegisterREALUserVar (&status, "timeBaseline", 't', UVAR_REQUIRED, "The time baseline of sfts", &timebaseline), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "psrInput", 'P', UVAR_OPTIONAL, "name of tempo pulsar file", &psrInput ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "psrEphemeris", 'S', UVAR_OPTIONAL, "pulsar ephemeris file", &psrEphemeris ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "earthFile", 'y', UVAR_OPTIONAL, "earth .dat file", &earthFile ), &status);
LAL_CALL(LALRegisterSTRINGUserVar(&status, "sunFile", 'z', UVAR_OPTIONAL, "sun .dat file", &sunFile ), &status);
LAL_CALL(LALUserVarReadAllInput(&status, argc, argv), &status);
if (help)
return(0);
startTime.gpsSeconds = startGPS;/*cg; startTime is a structure, and gpsSeconds is a member of that structure*/
startTime.gpsNanoSeconds = 0;/*cg; gps NanoSeconds is also a member of the startTime structure */
constraints.minStartTime = &startTime; /*cg; & operator gets the address of variable, &a is a pointer to a. This line puts the startTime structure into the structure constraints*/
endTime.gpsSeconds = endGPS;
endTime.gpsNanoSeconds = 0;
constraints.maxEndTime = &endTime;/*cg; This line puts the end time into the structure constraints*/
constraints.detector = IFO;/*cg; this adds the interferometer into the contraints structure*/
LALSFTdataFind ( &status, &catalog, SFTpatt, &constraints );/*cg; creates SFT catalog, uses the constraints structure*/
if (catalog == NULL)/*need to check for a NULL pointer, and print info about circumstances if it is null*/
{
fprintf(stderr, "SFT catalog pointer is NULL! There has been an error with LALSFTdataFind\n");
fprintf(stderr, "LALStatus info.... status code: %d, message: %s, offending function: %s\n", status.statusCode, status.statusDescription, status.function);
exit(0);
}
if (catalog->length == 0)
{
fprintf(stderr, "No SFTs found, please exmanine start time, end time, frequency range etc\n");
exit(0);
}
LALLoadSFTs ( &status, &sft_vect, catalog, f_min,f_max);/*cg;reads the SFT data into the structure sft_vect*/
if (sft_vect == NULL)
{
fprintf(stderr, "SFT vector pointer is NULL! There has been an error with LALLoadSFTs\n");
fprintf(stderr, "LALStatus info.... status code: %d, message: %s, offending function: %s\n", status.statusCode, status.statusDescription, status.function);
exit(0);
}
LALDestroySFTCatalog( &status, &catalog);/*cg; desctroys the SFT catalogue*/
numBins = sft_vect->data->data->length;/*the number of bins in the freq_range*/
nSFT = sft_vect->length;/* the number of sfts.*/
fprintf(stderr, "nSFT = %d\tnumBins = %d\tf0 = %f\n", nSFT, numBins,sft_vect->data->f0);/*print->logs/spectrumAverage_testcg_0.err */
if (LALUserVarWasSet(&outputBname))
strcpy(outbase, outputBname);
else
sprintf(outbase, "spec_%.2f_%.2f_%s_%d_%d", f_min,f_max,constraints.detector,startTime.gpsSeconds,endTime.gpsSeconds);/*cg; this is the default name for producing the output files, the different suffixes are just added to this*/
sprintf(outfile, "%s", outbase);/*cg; name of first file to be output*/
sprintf(outfile2, "%s_timestamps", outbase);/*cg: name of second file to be output*/
sprintf(outfile3, "%s.txt", outbase);/*cg; name of third file to be output*/
sprintf(outfile4, "%s_date", outbase);/*cg;file for outputting the date, which is used in matlab plotting.*/
fp = fopen(outfile, "w");/*cg; open all three files for writing, if they don't exist create them, if they do exist overwrite them*/
fp2 = fopen(outfile2, "w");
fp3 = fopen(outfile3, "w");
fp4 = fopen(outfile4, "w");
/*----------------------------------------------------------------------------------------------------------------*/
/*cg; Create the first file called spec_blah_blah. This file outputs the power in each spectrogram bin. The number of bins depends on the frequency range, freq resolution, and number of SFTs.*/
/*cg; Create the second file, called blah_b;ah_blah_timestamps. This will simply contain the time in GPS seconds of each SFT.*/
NumBinsAvg = freqres*numBins/(f_max-f_min);/*this calcs the number of bins over which to average the sft data, this is worked out so it produces the same freq resolution as specified in the arguments passed to fscanDriver.py. numBins is the total number of bins in the raw sft data*/
l=0;/*l is used as a counter to count how many SFTs and fake zero SFTs (used for gaps) are output for specgram.*/
timestamps = XLALCreateREAL8Vector(l);/*test for getting rid of second loop*/
LALCHARCreateVector(&status, &year_date, (UINT4)128);
/*create output files and check for missing sfts*/
for (j=0;j<nSFT;j++)/*cg;nSFT is the numnber of SFT files used for the time specified. So process is repeated for each SFT*/
{
cur_epoch = sft_vect->data[j].epoch.gpsSeconds;/*finds the gps time of the current sft in the sequence with index j*/
fprintf(fp2, "%d.\t%d\n", l, cur_epoch);/*cg; this bit writes the second file, i.e. the timestamps*/
XLALResizeREAL8Vector(timestamps, l+1);/*resizes the vector timestamps, so cur_epoch can be added*/
timestamps->data[l]= cur_epoch;/*number of gaps is not know in advance, hence need for te resizing*/
XLALGPSToUTC(&date, cur_epoch);/*cg; gets the UTC date in struct tm format from the GPS seconds.*/
fprintf(fp4, "%d\t %i\t %i\t %i\t %i\t %i\t %i\n", l, (date.tm_year+1900), date.tm_mon+1, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
for ( i=0; i < (numBins-2); i+=NumBinsAvg)/*cg; this loop works out the powers and writes the first file.*/
{/*cg; each SFT is split up into a number of bins, the number of bins is read in from the SFT file*/
avg = 0.0;/*cg; the vairable avg is reset each time.*/
if (i+NumBinsAvg>numBins) {printf("Error\n");return(2);}/*cg; error is detected, to prevent referencing data past the end of sft_vect.*/
for (k=0;k<NumBinsAvg;k++)/*cg; for each bin, k goes trhough each entry from 0 to 180.*/
avg += sqrt(2*(crealf(sft_vect->data[j].data->data[i+k])*crealf(sft_vect->data[j].data->data[i+k]) +
cimagf(sft_vect->data[j].data->data[i+k])*cimagf(sft_vect->data[j].data->data[i+k]))/timebaseline);/*cg; re amd im are real and imaginary parts of SFT, duh!*/
fprintf(fp,"%e\t",avg/NumBinsAvg);
}
fprintf(fp,"\n");
/*------------------------------*/
/*Bit to check if there is a gap in the sfts*/
if ( j < (nSFT-1) )/*in all cases except when we are examining the last sft, check that there is no gap to the next sft*/
{
next_epoch = sft_vect->data[j+1].epoch.gpsSeconds;
/*test to see if SFT gap is longer than 3/2*timebaseline, if so create another entry in the matrix*/
while ((cur_epoch+((3/2)*timebaseline)) < next_epoch)
{
for ( i=0; i < (numBins-2); i+=NumBinsAvg)
{
avg = 0.0;
if (i+NumBinsAvg>numBins) {printf("Error\n");return(2);}
fprintf(fp,"%e\t",avg);
}
fprintf(fp,"\n");
l=l+1;
cur_epoch=cur_epoch+timebaseline;
fprintf(fp2, "%d.\t%d\n", l, cur_epoch );
XLALResizeREAL8Vector(timestamps, l+1);
timestamps->data[l]= cur_epoch;
XLALGPSToUTC(&date, cur_epoch);/*cg; gets the UTC date in struct tm format from the GPS seconds.*/
fprintf(fp4, "%d\t %i\t %i\t %i\t %i\t %i\t %i\n", l, (date.tm_year+1900), date.tm_mon+1, date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
}
}
l=l+1;
}
fprintf(stderr,"finished checking for missing sfts, l=%d\n", l);
/*----------------------------------------------------------------------------------------------------------------*/
/*cg; Create the third and final file, called blah_blah_blah.txt. This file will contain the data used in the matlab plot script to plot the normalised average power vs the frequency.*/
/* Find time average of normalized SFTs */
LALNormalizeSFTVect(&status, sft_vect, blocksRngMed);
LALNormalizeSFTVect(&status, sft_vect, blocksRngMed);
timeavg = XLALMalloc(numBins*sizeof(REAL4));
if (timeavg == NULL) fprintf(stderr,"Timeavg memory not allocated\n");
for (j=0;j<nSFT;j++)
{
for ( i=0; i < numBins; i++)
{
if (j == 0)
{
timeavg[i] = crealf(sft_vect->data[j].data->data[i])*crealf(sft_vect->data[j].data->data[i]) +
cimagf(sft_vect->data[j].data->data[i])*cimagf(sft_vect->data[j].data->data[i]);
}
else
{
timeavg[i] += crealf(sft_vect->data[j].data->data[i])*crealf(sft_vect->data[j].data->data[i]) +
cimagf(sft_vect->data[j].data->data[i])*cimagf(sft_vect->data[j].data->data[i]);
}
}
}
/*timeavg records the power of each bin*/
for ( i=0; i < numBins; i++)
{
f = sft_vect->data->f0 + ((REAL4)i)*sft_vect->data->deltaF;
PWR=timeavg[i]/((REAL4)nSFT);
SNR=(PWR-1)*(sqrt(((REAL4)nSFT)));
fprintf(fp3,"%16.8f %g %g\n",f, PWR, SNR);
}
/*------------------------------------------------------------------------------------------------------------------------*/
/*End of normal spec_avg code, the remaining code is for crab freq calc.*/
/*================================================================================================================*/
/*================================================================================================================*/
/*This next block of code is for the crab specific changes to fscan*/
#define CRAB 0
/*change this to CRAB 0 to prevent this section of code from compiling, change to 1 to compile it.*/
#if CRAB
/*--------------------------------------------------------------------------------------------------------------*/
/*some header files for the crab*/
/*#include "../TDS_isolated/HeterodyneCrabPulsar.h"*/
/*#include "../TDS_isolated/heterodyne_pulsar.h"*/
#include<../TDS_isolated/HeterodyneCrabPulsar.h>
if (psrInput != NULL){
fprintf(stderr,"--------------------\n\n");
fprintf(stderr,"start of crab stuff\n");
LIGOTimeGPS dataEpoch;
/*below 4 structures are from HeterodyneCrabPulsar.h*/
GetCrabEphemerisInput input; /*this is needed to get the crab ephemeris*/
CrabSpindownParamsInput crabEphemerisData;
CrabSpindownParamsOutput crabOutput;
ParamsForHeterodyne hetParams;
/*CG; these lines allocate memory for the crab ephemeris and crab output variables...*/
crabEphemerisData.f1 = NULL;
LALDCreateVector( &status, &crabEphemerisData.f1, NUM);
crabEphemerisData.f0 = NULL;
LALDCreateVector( &status, &crabEphemerisData.f0, NUM);
crabEphemerisData.tArr = NULL;
LALDCreateVector( &status, &crabEphemerisData.tArr, NUM);
crabOutput.tArr = NULL;
LALDCreateVector( &status, &crabOutput.tArr, NUM);
crabOutput.f0 = NULL;
LALDCreateVector( &status, &crabOutput.f0, NUM);
crabOutput.f1 = NULL;
LALDCreateVector( &status, &crabOutput.f1, NUM);
crabOutput.f2 = NULL;
LALDCreateVector( &status, &crabOutput.f2, NUM);
crabOutput.f3 = NULL;
LALDCreateVector( &status, &crabOutput.f3, NUM);
crabOutput.f4 = NULL;
LALDCreateVector( &status, &crabOutput.f4, NUM);
/*This next set of variables are to do with the doppler shifts that are then applied to to the crab feq.*/
REAL8 t2=0., tdt=0.;
EphemerisData *edat=NULL;
BarycenterInput baryinput, baryinput2;
EarthState earth, earth2;
EmissionTime emit, emit2;
REAL8 df=0., freq, finalFreq, max_df, minf, maxf;
REAL8 dtpos=0.; /* time between position epoch and data timestamp */
BinaryPulsarParams pulsarParams; /*general pulsar params strcut, despite binary name*/
/*CHAR *psrInput = NULL;*/ /* pulsar input file containing params f0, f1 etc. */
LALDetector det;
CHAR detName[256];
REAL8 ecliptic_lat, e_tilt=0.409092627;/*the ecliptic latitude of the source, and hte earth's tilt in radians (23.439281 degrees)*/
char outfile5[256];
FILE *fp5 = NULL;
sprintf(outfile5, "%s_crab", outbase);
fp5 = fopen(outfile5, "w");
/*----------------------------------------------------------------------------------------------------------------*/
/*cg; calculating the crab freq, done in three steps. This is done for each sft*/
/*----------------------------------------------------------------------------------------------------------------*/
/* ---1--- */
/*Find rough guess of crabs freq from ephemeris*/
/*----------------------------------------------------------------------------------------------------------------*/
/*Get detector position, this is needed for barycentre calcs*/
det = *XLALGetSiteInfo( IFO );
/* read in tempo par file for pulsar, This is one of the optional command line arguments*/
/*fprintf(stderr,"%s\n",psrInput);*/
fprintf(stderr,"%s\n",psrInput);
XLALReadTEMPOParFile(&pulsarParams, psrInput);
/*Make sure that posepoch and pepoch are set*/
if(pulsarParams.pepoch == 0. && pulsarParams.posepoch != 0.)
pulsarParams.pepoch = pulsarParams.posepoch;
else if(pulsarParams.posepoch == 0. && pulsarParams.pepoch != 0.)
pulsarParams.posepoch = pulsarParams.pepoch;
fprintf(stderr,"Check on read tempo file, pepoch: %f\n", pulsarParams.pepoch);
/*input.filename=psrEphemeris;*/ /*/archive/home/colingill/lalsuite/lalapps/src/pulsar/fscan/ /archive/home/colingill/public_html/crab_ephemeris.txt*/
input.filename = XLALMalloc(sizeof(CHAR)*256);
if(input.filename == NULL) fprintf(stderr,"input.filename pointer memory not allocated\t");
strcpy(input.filename,psrEphemeris);
/*fprintf(stderr,"psrEphemeris:%s\n", input.filename);*/
/*The first stage is to read in f and fdot from the ephemeris, the crab_ephemeris.txt file is part of lalapps and is maintained by matt*/
LALGetCrabEphemeris( &status, &crabEphemerisData, &input );
/*check on the outputs, crabEphemerisData is a struct of type CrabSpindownParamsInput, and has members tArr, f0, f1*/
fprintf(stderr,"input crab ephemeris present, number of entries: %i\n", crabEphemerisData.numOfData);
fprintf(stderr,"crabEphemerisData: \ttarr= %f\tf0= %f\tf_dot= %e\n", crabEphemerisData.tArr->data[0], crabEphemerisData.f0->data[0], crabEphemerisData.f1->data[0]);
/*Now I have f and fdot, use function below to compute the higher order derrivatives of the crabs frequency*/
LALComputeFreqDerivatives( &status, &crabOutput, &crabEphemerisData );
/*check on this function, crabOutput is datatype CrabSpindownParamsOutput*/
fprintf(stderr,"crabOutput:\tf0= %f\tf1= %e\tf2= %e\n", crabOutput.f0->data[0], crabOutput.f1->data[0], crabOutput.f2->data[0]);/*need to change the type of printf for F1 and f2 to exponentials.*/
fprintf(stderr,"--------------------\n");
/*Allocate memory for edat, no need to do in the loop*/
edat = XLALMalloc(sizeof(*edat));
(*edat).ephiles.earthEphemeris = earthFile; /*"/archive/home/colingill/lalsuite/lal/packages/pulsar/test/earth05-09.dat";*/
(*edat).ephiles.sunEphemeris = sunFile;/*"/archive/home/colingill/lalsuite/lal/packages/pulsar/test/sun05-09.dat";*/
/*work out the eclitptic lattitude of the source, used in max freq calc.*/
ecliptic_lat=asin(cos(e_tilt)*sin(pulsarParams.dec)-sin(pulsarParams.ra)*cos(pulsarParams.dec)*sin(e_tilt));
fprintf(stderr,"eqcliptic_lat: %e\t", ecliptic_lat);
for (i=0;i<l;i++)
{
if (i == (l-1))/*catches the last iteration where there is no i+1 entry in timestamps*/
{
cur_epoch = timestamps->data[i]+(timebaseline/2);
}
else
{
cur_epoch = timestamps->data[i]+((timestamps->data[i+1] - timestamps->data[i])/2);
}
fprintf(stderr,"cur_epoch: %d\t", cur_epoch);
/*The time has to be set so that the nearest entry to that time in the ephemeris can be used*/
dataEpoch.gpsSeconds = cur_epoch; /*INT8)floor(time->data[j]);*/
dataEpoch.gpsNanoSeconds = 0;
/*prepare hetParams, which is then used to get the freq derrivatives out and also in the next sub-section for Bary functions*/
LALSetSpindownParams( &status, &hetParams, &crabOutput, dataEpoch );
fprintf(stderr,"hetparams epoch: %f\t f0= %f\tf1= %e\n", hetParams.epoch, hetParams.f0, hetParams.f1);
/*----------------------------------------------------------------------------------------------------------------*/
/* ---2--- */
/*Add corrections for timing noise to get a better guess at the freq*/
/*----------------------------------------------------------------------------------------------------------------*/
/*now I want to use these params to calc the freq at any point in time. Using the higher order derrivatives is how we adjust for timing noise.*/
/*Get the time difference between the current epoch and the epoch of the ephemeris entry*/
tdt= cur_epoch - hetParams.epoch;
fprintf(stderr,"dt: %f,\tf1= %e,\tf2= %e,\tf3= %e,\tf4=%e\n", tdt, hetParams.f1, hetParams.f2, hetParams.f3, hetParams.f4);
freq = 2.0*( hetParams.f0 + ((hetParams.f1)*tdt) + (((hetParams.f2)*tdt*tdt)/2) + (((hetParams.f3)*tdt*tdt*tdt)/6) + (((hetParams.f4)*tdt*tdt*tdt*tdt)/24) );
fprintf(stderr,"crab fcoarse: %f\t", freq);
/*freq = 2.0*(params->f0 + params->f1*t1 + (params->f2)*t1*t1+ (params->f3)*t1*t1*t1 + (params->f4)*t1*t1*t1*t1);*/ /*cg;line 486 from hetcrabpulsar, works out freq, this is with one order of t removed for each of the derrivatives of f, and also each term is divided by a factorial, 1!, 2!, 3!, but this starts one term along from the oroginal code as we have integrated the orginal code to get freq not phase*/
/*----------------------------------------------------------------------------------------------------------------*/
/* ---3--- */
/*Add doppler shifts for earth's motion back onto the freq to get actual observed freq at detectors.*/
/*----------------------------------------------------------------------------------------------------------------*/
/*now I have the freq, I need to add the doppler shift for the earths motion around the sun */
baryinput.dInv = 0.;/*I can always set this to zero, as Matt said so, I must ask him why*/
LAL_CALL( LALInitBarycenter(&status, edat), &status );/* */
/*this lines take position of detector which are in xyz coords in meters from earths centre and converts them into seconds (time)*/
baryinput.site.location[0] = det.location[0]/LAL_C_SI;
baryinput.site.location[1] = det.location[1]/LAL_C_SI;
baryinput.site.location[2] = det.location[2]/LAL_C_SI;
/*dtpos should be the time between the entry in the ephemeris and the point in time for which doppler shifts are being calc.ed*/
dtpos = cur_epoch - pulsarParams.posepoch;
/* set up RA, DEC, and distance variables for LALBarycenter*/
baryinput.delta = pulsarParams.dec + dtpos*pulsarParams.pmdec;
baryinput.alpha = pulsarParams.ra + dtpos*pulsarParams.pmra/cos(baryinput.delta);
t2=cur_epoch+1;
baryinput2 = baryinput;
baryinput.tgps.gpsSeconds = (INT4)floor(cur_epoch);
baryinput.tgps.gpsNanoSeconds = (INT4)floor((fmod(cur_epoch,1.0)*1.e9));
baryinput2.tgps.gpsSeconds = (INT4)floor(t2);
baryinput2.tgps.gpsNanoSeconds = (INT4)floor((fmod(t2,1.0)*1.e9));
/*the barycentre functions are needed to calc the inputs for the correction to fcoarse, namely emit, earth and baryinput*/
LAL_CALL( LALBarycenterEarth(&status, &earth, &baryinput.tgps, edat), &status );
LAL_CALL( LALBarycenter(&status, &emit, &baryinput, &earth), &status );
LAL_CALL( LALBarycenterEarth(&status, &earth2, &baryinput2.tgps, edat), &status );
LAL_CALL( LALBarycenter(&status, &emit2, &baryinput2, &earth2), &status );
/* I need to calc the correction to the freq for the doppler shifts, the correction is df, from line 1074 heterdyne_pulsar. deltaT is T_emission in TDB - T_arrrival in GPS + light travel time to SSB. we are working out delta(delatT) over 1 second, so do not bother with the divide by one bit.*/
df = freq*(emit2.deltaT - emit.deltaT);
fprintf(stderr,"df: %f,\t", df);
/*Calc maximum possible df and then subtract applied df from it, use the remaining df to plot range over which f will wander.*/
max_df=freq*(( (29.783e3*cos(ecliptic_lat))+(465*cos(pulsarParams.dec)) )/3.0e8);/*max doppler shift, from speed of earth in plane of direction to source over c.*/
fprintf(stderr,"max df: %f\tbeta: %e\n", max_df, ecliptic_lat);
maxf=freq+max_df;
minf=freq-max_df;
finalFreq=freq+df;
/*df = fcoarse*(emit2.deltaT - emit.deltaT + binOutput2.deltaT - binOutput.deltaT);*//*use when have binary calcs in here also.*/
fprintf(fp5,"%f\t%f\t%f\t%f\t%f\n", freq, df, minf, finalFreq, maxf);
fprintf(stderr,"crab freq calc, i:%d, minf:%f, f:%f, maxf:%f\n", i, minf, finalFreq, maxf);
/*----------------------------------------------------------------------------------------------------------------*/
}
fclose(fp5);
fprintf(stderr,"end of crab stuff\n");
/*Free up any memory allocated in crab section*/
XLALFree(edat);
}
#endif
/*fprintf(stderr,"end of spec_avg 1\n");*/
/*=======================================================================================================================*/
/*=======================================================================================================================*/
/*release a;; the allocaeted memory*/
LALCHARDestroyVector(&status, ×tamp);
LALCHARDestroyVector(&status, &year_date);
LALDestroySFTVector (&status, &sft_vect );
/*fprintf(stderr,"end of spec_avg 2\n");*/
if (timeavg != NULL) XLALFree(timeavg);
/*fprintf(stderr,"end of spec_avg 3\n");*/
LAL_CALL(LALDestroyUserVars(&status), &status);
/*fprintf(stderr,"end of spec_avg 4\n");*/
/*close all the files, spec_avg.c is done, all info written to the files.*/
fclose(fp);
fclose(fp2);
fclose(fp3);
fclose(fp4);
fprintf(stderr,"end of spec_avg\n");
return(0);
}
int main(int argc, char *argv[]){
static LALStatus status;
static LALDetector *detector;
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
static REAL8 foft;
static HoughPulsarTemplate pulsarTemplate;
EphemerisData *edat = NULL;
CHAR *uvar_earthEphemeris = NULL;
CHAR *uvar_sunEphemeris = NULL;
SFTVector *inputSFTs = NULL;
REAL8 *alphaVec=NULL;
REAL8 *deltaVec=NULL;
REAL8 *freqVec=NULL;
REAL8 *spndnVec=NULL;
/* pgV is vector of peakgrams and pg1 is onepeakgram */
static UCHARPeakGram *pg1, **pgV;
UINT4 msp; /*number of spin-down parameters */
CHAR *uvar_ifo = NULL;
CHAR *uvar_sftDir = NULL; /* the directory where the SFT could be */
CHAR *uvar_fnameOut = NULL; /* The output prefix filename */
CHAR *uvar_fnameIn = NULL;
INT4 numberCount, ind;
UINT8 nTemplates;
UINT4 mObsCoh;
REAL8 uvar_peakThreshold;
REAL8 f_min, f_max, fWings, timeBase;
INT4 uvar_blocksRngMed;
UINT4 sftlength;
INT4 sftFminBin;
UINT4 loopId, tempLoopId;
FILE *fpOut = NULL;
CHAR *fnameLog=NULL;
FILE *fpLog = NULL;
CHAR *logstr=NULL;
/*REAL8 asq, bsq;*/ /* square of amplitude modulation functions a and b */
/******************************************************************/
/* Set up the default parameters. */
/* ****************************************************************/
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
msp = 1; /*only one spin-down */
/* memory allocation for spindown */
pulsarTemplate.spindown.length = msp;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(msp*sizeof(REAL8));
uvar_peakThreshold = THRESHOLD;
uvar_earthEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
uvar_fnameOut = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameOut,VALIDATEOUT);
uvar_fnameIn = (CHAR *)LALMalloc(1024*sizeof(CHAR));
strcpy(uvar_fnameIn,VALIDATEIN);
uvar_blocksRngMed = BLOCKSRNGMED;
/* register user input variables */
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_ifo, "ifo", STRING, 'i', OPTIONAL, "Detector GEO(1) LLO(2) LHO(3)" ) == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_earthEphemeris, "earthEphemeris", STRING, 'E', OPTIONAL, "Earth Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sunEphemeris, "sunEphemeris", STRING, 'S', OPTIONAL, "Sun Ephemeris file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_sftDir, "sftDir", STRING, 'D', OPTIONAL, "SFT Directory") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameIn, "fnameIn", STRING, 'T', OPTIONAL, "Input template file") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_fnameOut, "fnameOut", STRING, 'o', OPTIONAL, "Output filename") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_blocksRngMed, "blocksRngMed", INT4, 'w', OPTIONAL, "RngMed block size") == XLAL_SUCCESS, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALRegisterNamedUvar( &uvar_peakThreshold, "peakThreshold", REAL8, 't', OPTIONAL, "Peak selection threshold") == XLAL_SUCCESS, XLAL_EFUNC);
/* read all command line variables */
BOOLEAN should_exit = 0;
XLAL_CHECK_MAIN( XLALUserVarReadAllInput(&should_exit, argc, argv, lalAppsVCSInfoList) == XLAL_SUCCESS, XLAL_EFUNC);
if (should_exit)
exit(1);
/* open log file for writing */
fnameLog = LALCalloc( (strlen(uvar_fnameOut) + strlen(".log") + 10),1);
strcpy(fnameLog,uvar_fnameOut);
strcat(fnameLog,".log");
if ((fpLog = fopen(fnameLog, "w")) == NULL) {
fprintf(stderr, "Unable to open file %s for writing\n", fnameLog);
LALFree(fnameLog);
exit(1);
}
/* get the log string */
XLAL_CHECK_MAIN( ( logstr = XLALUserVarGetLog(UVAR_LOGFMT_CFGFILE) ) != NULL, XLAL_EFUNC);
fprintf( fpLog, "## Log file for HoughValidate\n\n");
fprintf( fpLog, "# User Input:\n");
fprintf( fpLog, "#-------------------------------------------\n");
fprintf( fpLog, "%s", logstr);
LALFree(logstr);
/* append an ident-string defining the exact CVS-version of the code used */
{
CHAR command[1024] = "";
fprintf (fpLog, "\n\n# CVS-versions of executable:\n");
fprintf (fpLog, "# -----------------------------------------\n");
fclose (fpLog);
sprintf (command, "ident %s | sort -u >> %s", argv[0], fnameLog);
/* we don't check this. If it fails, we assume that */
/* one of the system-commands was not available, and */
/* therefore the CVS-versions will not be logged */
if ( system(command) ) fprintf (stderr, "\nsystem('%s') returned non-zero status!\n\n", command );
LALFree(fnameLog);
}
/* open output file for writing */
fpOut= fopen(uvar_fnameOut, "w");
/*setlinebuf(fpOut);*/ /* line buffered on */
setvbuf(fpOut, (char *)NULL, _IOLBF, 0);
/*****************************************************************/
/* read template file */
/*****************************************************************/
{
FILE *fpIn = NULL;
INT4 r;
REAL8 temp1, temp2, temp3, temp4, temp5;
UINT8 templateCounter;
fpIn = fopen(uvar_fnameIn, "r");
if ( !fpIn )
{
fprintf(stderr, "Unable to fine file %s\n", uvar_fnameIn);
return DRIVEHOUGHCOLOR_EFILE;
}
nTemplates = 0;
do
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, &temp2, &temp3, &temp4, &temp5);
/* make sure the line has the right number of entries or is EOF */
if (r==5) nTemplates++;
} while ( r != EOF);
rewind(fpIn);
alphaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
deltaVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
freqVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
spndnVec = (REAL8 *)LALMalloc(nTemplates*sizeof(REAL8));
for (templateCounter = 0; templateCounter < nTemplates; templateCounter++)
{
r=fscanf(fpIn,"%lf%lf%lf%lf%lf\n", &temp1, alphaVec + templateCounter, deltaVec + templateCounter,
freqVec + templateCounter, spndnVec + templateCounter);
}
fclose(fpIn);
}
/**************************************************/
/* read sfts */
/*************************************************/
f_min = freqVec[0]; /* initial frequency to be analyzed */
/* assume that the last frequency in the templates file is also the highest frequency */
f_max = freqVec[nTemplates-1] ;
/* we need to add wings to fmin and fmax to account for
the Doppler shift, the size of the rngmed block size
and also nfsizecylinder. The block size and nfsizecylinder are
specified in terms of frequency bins...this goes as one of the arguments of
LALReadSFTfiles */
/* first correct for Doppler shift */
fWings = f_max * VTOT;
f_min -= fWings;
f_max += fWings;
/* create pattern to look for in SFT directory */
{
CHAR *tempDir = NULL;
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
/* set detector constraint */
constraints.detector = NULL;
if ( XLALUserVarWasSet( &uvar_ifo ) )
constraints.detector = XLALGetChannelPrefix ( uvar_ifo );
/* get sft catalog */
tempDir = (CHAR *)LALCalloc(512, sizeof(CHAR));
strcpy(tempDir, uvar_sftDir);
strcat(tempDir, "/*SFT*.*");
XLAL_CHECK_MAIN( ( catalog = XLALSFTdataFind( tempDir, &constraints) ) != NULL, XLAL_EFUNC);
detector = XLALGetSiteInfo( catalog->data[0].header.name);
mObsCoh = catalog->length;
timeBase = 1.0 / catalog->data->header.deltaF;
XLAL_CHECK_MAIN( ( inputSFTs = XLALLoadSFTs ( catalog, f_min, f_max) ) != NULL, XLAL_EFUNC);
XLAL_CHECK_MAIN( XLALNormalizeSFTVect( inputSFTs, uvar_blocksRngMed, 0.0 ) == XLAL_SUCCESS, XLAL_EFUNC);
if ( XLALUserVarWasSet( &uvar_ifo ) )
LALFree( constraints.detector );
LALFree( tempDir);
XLALDestroySFTCatalog(catalog );
}
sftlength = inputSFTs->data->data->length;
{
INT4 tempFbin;
sftFminBin = floor( (REAL4)(timeBase * inputSFTs->data->f0) + (REAL4)(0.5));
tempFbin = floor( timeBase * inputSFTs->data->f0 + 0.5);
if (tempFbin - sftFminBin)
{
fprintf(stderr, "Rounding error in calculating fminbin....be careful! \n");
}
}
/* loop over sfts and select peaks */
/* first the memory allocation for the peakgramvector */
pgV = NULL;
pgV = (UCHARPeakGram **)LALMalloc(mObsCoh*sizeof(UCHARPeakGram *));
/* memory for peakgrams */
for (tempLoopId=0; tempLoopId < mObsCoh; tempLoopId++)
{
pgV[tempLoopId] = (UCHARPeakGram *)LALMalloc(sizeof(UCHARPeakGram));
pgV[tempLoopId]->length = sftlength;
pgV[tempLoopId]->data = NULL;
pgV[tempLoopId]->data = (UCHAR *)LALMalloc(sftlength* sizeof(UCHAR));
LAL_CALL (SFTtoUCHARPeakGram( &status, pgV[tempLoopId], inputSFTs->data + tempLoopId, uvar_peakThreshold), &status);
}
/* having calculated the peakgrams we don't need the sfts anymore */
XLALDestroySFTVector( inputSFTs);
/* ****************************************************************/
/* setting timestamps vector */
/* ****************************************************************/
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALMalloc(mObsCoh*sizeof(LIGOTimeGPS));
{
UINT4 j;
for (j=0; j < mObsCoh; j++){
timeV.data[j].gpsSeconds = pgV[j]->epoch.gpsSeconds;
timeV.data[j].gpsNanoSeconds = pgV[j]->epoch.gpsNanoSeconds;
}
}
/******************************************************************/
/* compute the time difference relative to startTime for all SFTs */
/******************************************************************/
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
{
REAL8 t0, ts, tn, midTimeBase;
UINT4 j;
midTimeBase=0.5*timeBase;
ts = timeV.data[0].gpsSeconds;
tn = timeV.data[0].gpsNanoSeconds * 1.00E-9;
t0=ts+tn;
timeDiffV.data[0] = midTimeBase;
for (j=1; j< mObsCoh; ++j){
ts = timeV.data[j].gpsSeconds;
tn = timeV.data[j].gpsNanoSeconds * 1.00E-9;
timeDiffV.data[j] = ts + tn -t0 + midTimeBase;
}
}
/******************************************************************/
/* compute detector velocity for those time stamps */
/******************************************************************/
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALMalloc(mObsCoh*sizeof(REAL8Cart3Coor));
{
VelocityPar velPar;
REAL8 vel[3];
UINT4 j;
velPar.detector = *detector;
velPar.tBase = timeBase;
velPar.vTol = ACCURACY;
velPar.edat = NULL;
/* read in ephemeris data */
XLAL_CHECK_MAIN( ( edat = XLALInitBarycenter( uvar_earthEphemeris, uvar_sunEphemeris ) ) != NULL, XLAL_EFUNC);
velPar.edat = edat;
/* now calculate average velocity */
for(j=0; j< velV.length; ++j){
velPar.startTime.gpsSeconds = timeV.data[j].gpsSeconds;
velPar.startTime.gpsNanoSeconds = timeV.data[j].gpsNanoSeconds;
LAL_CALL( LALAvgDetectorVel ( &status, vel, &velPar), &status );
velV.data[j].x= vel[0];
velV.data[j].y= vel[1];
velV.data[j].z= vel[2];
}
}
/* amplitude modulation stuff */
{
AMCoeffs XLAL_INIT_DECL(amc);
AMCoeffsParams *amParams;
EarthState earth;
BarycenterInput baryinput; /* Stores detector location and other barycentering data */
/* detector location */
baryinput.site.location[0] = detector->location[0]/LAL_C_SI;
baryinput.site.location[1] = detector->location[1]/LAL_C_SI;
baryinput.site.location[2] = detector->location[2]/LAL_C_SI;
baryinput.dInv = 0.e0;
/* alpha and delta must come from the skypatch */
/* for now set it to something arbitrary */
baryinput.alpha = 0.0;
baryinput.delta = 0.0;
/* Allocate space for amParams stucture */
/* Here, amParams->das is the Detector and Source info */
amParams = (AMCoeffsParams *)LALMalloc(sizeof(AMCoeffsParams));
amParams->das = (LALDetAndSource *)LALMalloc(sizeof(LALDetAndSource));
amParams->das->pSource = (LALSource *)LALMalloc(sizeof(LALSource));
/* Fill up AMCoeffsParams structure */
amParams->baryinput = &baryinput;
amParams->earth = &earth;
amParams->edat = edat;
amParams->das->pDetector = detector;
/* make sure alpha and delta are correct */
amParams->das->pSource->equatorialCoords.latitude = baryinput.delta;
amParams->das->pSource->equatorialCoords.longitude = baryinput.alpha;
amParams->das->pSource->orientation = 0.0;
amParams->das->pSource->equatorialCoords.system = COORDINATESYSTEM_EQUATORIAL;
amParams->polAngle = amParams->das->pSource->orientation ; /* These two have to be the same!!*/
/* timeV is start time ---> change to mid time */
LAL_CALL (LALComputeAM(&status, &amc, timeV.data, amParams), &status);
/* calculate a^2 and b^2 */
/* for (ii=0, asq=0.0, bsq=0.0; ii<mObsCoh; ii++) */
/* { */
/* REAL8 *a, *b; */
/* a = amc.a + ii; */
/* b = amc.b + ii; */
/* asq += (*a) * (*a); */
/* bsq += (*b) * (*b); */
/* } */
/* free amParams */
LALFree(amParams->das->pSource);
LALFree(amParams->das);
LALFree(amParams);
}
/* loop over templates */
for(loopId=0; loopId < nTemplates; ++loopId){
/* set template parameters */
pulsarTemplate.f0 = freqVec[loopId];
pulsarTemplate.longitude = alphaVec[loopId];
pulsarTemplate.latitude = deltaVec[loopId];
pulsarTemplate.spindown.data[0] = spndnVec[loopId];
{
REAL8 f0new, vcProdn, timeDiffN;
REAL8 sourceDelta, sourceAlpha, cosDelta, factorialN;
UINT4 j, i, f0newBin;
REAL8Cart3Coor sourceLocation;
sourceDelta = pulsarTemplate.latitude;
sourceAlpha = pulsarTemplate.longitude;
cosDelta = cos(sourceDelta);
sourceLocation.x = cosDelta* cos(sourceAlpha);
sourceLocation.y = cosDelta* sin(sourceAlpha);
sourceLocation.z = sin(sourceDelta);
/* loop for all different time stamps,calculate frequency and produce number count*/
/* first initialize number count */
numberCount=0;
for (j=0; j<mObsCoh; ++j)
{
/* calculate v/c.n */
vcProdn = velV.data[j].x * sourceLocation.x
+ velV.data[j].y * sourceLocation.y
+ velV.data[j].z * sourceLocation.z;
/* loop over spindown values to find f_0 */
f0new = pulsarTemplate.f0;
factorialN = 1.0;
timeDiffN = timeDiffV.data[j];
for (i=0; i<msp;++i)
{
factorialN *=(i+1.0);
f0new += pulsarTemplate.spindown.data[i]*timeDiffN / factorialN;
timeDiffN *= timeDiffN;
}
f0newBin = floor(f0new*timeBase + 0.5);
foft = f0newBin * (1.0 +vcProdn) / timeBase;
/* get the right peakgram */
pg1 = pgV[j];
/* calculate frequency bin for template */
ind = floor( foft * timeBase + 0.5 ) - sftFminBin;
/* update the number count */
numberCount+=pg1->data[ind];
}
} /* end of block calculating frequency path and number count */
/******************************************************************/
/* printing result in the output file */
/******************************************************************/
fprintf(fpOut,"%d %f %f %f %g \n",
numberCount, pulsarTemplate.longitude, pulsarTemplate.latitude, pulsarTemplate.f0,
pulsarTemplate.spindown.data[0] );
} /* end of loop over templates */
/******************************************************************/
/* Closing files */
/******************************************************************/
fclose(fpOut);
/******************************************************************/
/* Free memory and exit */
/******************************************************************/
LALFree(alphaVec);
LALFree(deltaVec);
LALFree(freqVec);
LALFree(spndnVec);
for (tempLoopId = 0; tempLoopId < mObsCoh; tempLoopId++){
pg1 = pgV[tempLoopId];
LALFree(pg1->data);
LALFree(pg1);
}
LALFree(pgV);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(velV.data);
LALFree(pulsarTemplate.spindown.data);
XLALDestroyEphemerisData(edat);
XLALDestroyUserVars();
LALCheckMemoryLeaks();
return DRIVEHOUGHCOLOR_ENORM;
}
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[] )
{
/* 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; /* LALStatus pointer */
static MultiSFTVector *inputSFTs = NULL;
static SFTCatalog *catalog = NULL;
static SFTCatalog thisCatalog;
static SFTConstraints constraints;
/* 09/09/05 gam; randPar now a parameter for LALCleanCOMPLEX8SFT */
FILE *fp=NULL;
INT4 seed, ranCount;
RandomParams *randPar=NULL;
UINT4 k, j;
/* user input variables */
BOOLEAN uvar_help;
LALStringVector *uvar_linefiles=NULL; /* files with harmonics info */
CHAR *uvar_sftDir; /* directory for unclean sfts */
CHAR *uvar_outDir; /* directory for cleaned sfts */
REAL8 uvar_fMin, uvar_fMax;
INT4 uvar_window, uvar_maxBins;
/* set defaults */
uvar_help = FALSE;
uvar_sftDir = (CHAR *)LALMalloc(256 * sizeof(CHAR));
strcpy(uvar_sftDir, INPUTSFTDIR);
uvar_outDir = (CHAR *)LALMalloc(256 * sizeof(CHAR));
strcpy(uvar_outDir, OUTPUTSFTDIR);
uvar_fMin = STARTFREQ;
uvar_fMax = ENDFREQ;
uvar_window = WINDOWSIZE;
uvar_maxBins = MAXBINS;
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h',UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'i',UVAR_OPTIONAL, "Input SFT file pattern", &uvar_sftDir), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "outDir", 'o',UVAR_OPTIONAL, "Output SFT Directory", &uvar_outDir), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fMin", 0, UVAR_OPTIONAL, "start Frequency", &uvar_fMin), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fMax", 0, UVAR_OPTIONAL, "Max Frequency Band", &uvar_fMax), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "window", 'w',UVAR_OPTIONAL, "Window size", &uvar_window), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "maxBins", 'm',UVAR_OPTIONAL, "Max. bins to clean", &uvar_maxBins),&status);
LAL_CALL( LALRegisterLISTUserVar( &status, "linefiles", 0, UVAR_OPTIONAL, "List of linefiles (filenames must contain IFO name)", &uvar_linefiles), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* set detector constraint */
constraints.detector = NULL;
/* get sft catalog */
LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status);
if ( (catalog == NULL) || (catalog->length == 0) ) {
fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir );
exit(1);
}
thisCatalog.length = 1;
fprintf(stdout, "%d\n",catalog->length);
/* get a new seed value, and use it to create a new random parameter structure */
fp=fopen("/dev/urandom", "r");
if (!fp)
{
fprintf(stderr,"Error in opening /dev/urandom \n");
exit(1);
}
ranCount = fread(&seed, sizeof(seed), 1, fp);
fclose(fp);
if (!(ranCount==1))
{
fprintf(stderr,"Error in reading random seed \n");
exit(1);
}
LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status );
/* loop over sfts and clean them -- load one sft at a time */
for (j=0; j<catalog->length; j++) {
thisCatalog.data = catalog->data + j;
/* read the sfts */
LAL_CALL( LALLoadMultiSFTs ( &status, &inputSFTs, &thisCatalog, uvar_fMin, uvar_fMax), &status);
/* clean lines */
if ( LALUserVarWasSet( &uvar_linefiles ) ) {
LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar_maxBins,
uvar_window, uvar_linefiles, randPar), &status);
}
/* write output */
for (k = 0; k < inputSFTs->length; k++) {
LAL_CALL( LALWriteSFTVector2Dir ( &status, inputSFTs->data[k], uvar_outDir, "cleaned", "cleaned"), &status);
}
LAL_CALL( LALDestroyMultiSFTVector(&status, &inputSFTs), &status );
} /* end loop over sfts */
/* Free memory */
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
LAL_CALL( LALDestroyUserVars(&status), &status);
LAL_CALL( LALDestroyRandomParams (&status, &randPar), &status);
LALCheckMemoryLeaks();
return 0;
}
/*
* main program entry point
*/
INT4 main(INT4 argc, CHAR **argv)
{
/* status */
LALStatus status = blank_status;
/* counters */
int c;
UINT4 i;
/* mode counters */
UINT4 l, m;
/* metadata file/directory */
CHAR *nrMetaFile = NULL;
CHAR *nrDataDir = NULL;
CHAR file_path[FILENAME_MAX];
/* metadata format */
CHAR *metadata_format = NULL;
/* metadata parsing variables */
LALParsedDataFile *meta_file = NULL;
BOOLEAN wasRead = 0;
CHAR field[HISTORY_COMMENT];
CHAR *wf_name[MAX_L+1][(2*MAX_L) + 1];
/* common metadata */
CHAR *md_mass_ratio = NULL;
CHAR *md_spin1x = NULL;
CHAR *md_spin1y = NULL;
CHAR *md_spin1z = NULL;
CHAR *md_spin2x = NULL;
CHAR *md_spin2y = NULL;
CHAR *md_spin2z = NULL;
CHAR *md_freq_start_22 = NULL;
/* NINJA1 metadata */
CHAR *md_simulation_details = NULL;
CHAR *md_nr_group = NULL;
CHAR *md_email = NULL;
/* NINJA2 metadata */
CHAR *md_waveform_name = NULL;
CHAR *md_initial_separation = NULL;
CHAR *md_eccentricity = NULL;
CHAR *md_number_of_cycles_22 = NULL;
CHAR *md_code = NULL;
CHAR *md_submitter_email = NULL;
CHAR *md_authors_emails = NULL;
/* common metadata strings */
CHAR str_mass_ratio[HISTORY_COMMENT];
CHAR str_spin1x[HISTORY_COMMENT];
CHAR str_spin1y[HISTORY_COMMENT];
CHAR str_spin1z[HISTORY_COMMENT];
CHAR str_spin2x[HISTORY_COMMENT];
CHAR str_spin2y[HISTORY_COMMENT];
CHAR str_spin2z[HISTORY_COMMENT];
CHAR str_freq_start_22[HISTORY_COMMENT];
CHAR str_creator[HISTORY_COMMENT];
/* NINJA1 metadata strings */
CHAR str_simulation_details[HISTORY_COMMENT];
CHAR str_nr_group[HISTORY_COMMENT];
CHAR str_email[HISTORY_COMMENT];
/* NINJA2 metadata strings */
CHAR str_waveform_name[HISTORY_COMMENT];
CHAR str_initial_separation[HISTORY_COMMENT];
CHAR str_eccentricity[HISTORY_COMMENT];
CHAR str_number_of_cycles_22[HISTORY_COMMENT];
CHAR str_code[HISTORY_COMMENT];
CHAR str_submitter_email[HISTORY_COMMENT];
CHAR str_authors_emails[HISTORY_COMMENT];
/* channel names */
CHAR *plus_channel[MAX_L+1][(2*MAX_L) + 1];
CHAR *cross_channel[MAX_L+1][(2*MAX_L) + 1];
/* waveforms */
UINT4 wf_length;
REAL4TimeVectorSeries *waveforms[MAX_L][(2*MAX_L) + 1];
REAL4TimeSeries *hplus[MAX_L+1][(2*MAX_L) + 1];
REAL4TimeSeries *hcross[MAX_L+1][(2*MAX_L) + 1];
REAL8TimeVectorSeries *waveformsREAL8[MAX_L][(2*MAX_L) + 1];
REAL8TimeSeries *hplusREAL8[MAX_L+1][(2*MAX_L) + 1];
REAL8TimeSeries *hcrossREAL8[MAX_L+1][(2*MAX_L) + 1];
/* frame variables */
LALFrameH *frame;
CHAR *frame_name = NULL;
LIGOTimeGPS epoch;
INT4 duration;
INT4 detector_flags;
INT4 generatingREAL8 = 0;
/* LALgetopt arguments */
struct LALoption long_options[] =
{
/* options that set a flag */
{"verbose", no_argument, &vrbflg, 1},
/* options that don't set a flag */
{"format", required_argument, 0, 'f'},
{"nr-meta-file", required_argument, 0, 'm'},
{"nr-data-dir", required_argument, 0, 'd'},
{"output", required_argument, 0, 'o'},
{"double-precision", no_argument, 0, 'p'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{0, 0, 0, 0}
};
/* default debug level */
lal_errhandler = LAL_ERR_EXIT;
/* 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, "f:m:d:o:phV", long_options, &option_index);
/* detect the end of the options */
if (c == -1)
break;
switch(c)
{
case 0:
/* if this option sets a flag, do nothing else for 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':
/* help message */
print_usage(stdout, argv[0]);
exit(0);
break;
case 'V':
/* print version information and exit */
fprintf(stdout, "Numerical Relativity Frame Generation\n");
XLALOutputVersionString(stderr, 0);
exit(0);
break;
case 'f':
/* create storage for the metadata format */
LALoptarg_len = strlen(LALoptarg) + 1;
metadata_format = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(metadata_format, LALoptarg, LALoptarg_len);
break;
case 'm':
/* create storage for the meta file name */
LALoptarg_len = strlen(LALoptarg) + 1;
nrMetaFile = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(nrMetaFile, LALoptarg, LALoptarg_len);
break;
case 'd':
/* create storage for the meta data directory name */
LALoptarg_len = strlen(LALoptarg) + 1;
nrDataDir = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(nrDataDir, LALoptarg, LALoptarg_len);
break;
case 'o':
/* create storage for the output frame file name */
LALoptarg_len = strlen(LALoptarg) + 1;
frame_name = (CHAR *)calloc(LALoptarg_len, sizeof(CHAR));
memcpy(frame_name, LALoptarg, LALoptarg_len);
break;
case 'p':
/* We're generating a double-precision frame */
generatingREAL8 = 1;
break;
case '?':
print_usage(stderr, argv[0]);
exit(1);
break;
default:
fprintf(stderr, "Unknown error while parsing arguments\n");
print_usage(stderr, argv[0]);
exit(1);
break;
}
}
/* check for extraneous command line arguments */
if (LALoptind < argc)
{
fprintf(stderr, "Extraneous command line arguments:\n");
while(LALoptind < argc)
fprintf(stderr, "%s\n", argv[LALoptind++]);
exit(1);
}
/*
* check validity of arguments
*/
/* metadata format specified */
if (metadata_format == NULL)
{
fprintf(stderr, "warning: --format not specified, assuming NINJA1\n");
metadata_format = (CHAR *)calloc(7, sizeof(CHAR));
memcpy(metadata_format, "NINJA1", 7);
}
/* check for supported metadata format */
if (strcmp(metadata_format, "NINJA1") == 0);
else if (strcmp(metadata_format, "NINJA2") == 0);
else
{
fprintf(stderr, "Supported metadata formats are NINJA1 and NINJA2 (%s specified)\n", metadata_format);
exit(1);
}
/* meta file specified */
if (nrMetaFile == NULL)
{
fprintf(stderr, "--nr-meta-file must be specified\n");
exit(1);
}
/* data directory specified */
if (nrDataDir == NULL)
{
fprintf(stderr, "--nr-data-dir must be specified\n");
exit(1);
}
/* output frame filename specified */
if (frame_name == NULL)
{
fprintf(stderr, "--output must be specified\n");
exit(1);
}
/*
* main code
*/
/* frame metadata */
/* TODO: set these to something sensible */
duration = 0;
epoch.gpsSeconds = 0;
epoch.gpsNanoSeconds = 0;
detector_flags = 0;
if (vrbflg)
fprintf(stdout, "reading metadata: %s\n", nrMetaFile);
/* open metadata file */
XLAL_CHECK ( XLALParseDataFile(&meta_file, nrMetaFile) == XLAL_SUCCESS, XLAL_EFUNC );
/*
* get metadata
*/
/* common metadata */
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_mass_ratio, meta_file, NULL, "mass-ratio", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1x, meta_file, NULL, "spin1x", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1y, meta_file, NULL, "spin1y", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin1z, meta_file, NULL, "spin1z", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2x, meta_file, NULL, "spin2x", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2y, meta_file, NULL, "spin2y", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_spin2z, meta_file, NULL, "spin2z", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
/* format specific metadata */
if (strcmp(metadata_format, "NINJA1") == 0)
{
/* NINJA1 */
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_simulation_details, meta_file, NULL, "simulation-details", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_nr_group, meta_file, NULL, "nr-group", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_email, meta_file, NULL, "email", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_freq_start_22, meta_file, NULL, "freqStart22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
}
else if (strcmp(metadata_format, "NINJA2") == 0)
{
/* NINJA2 */
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_waveform_name, meta_file, NULL, "waveform-name", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_initial_separation, meta_file, NULL, "initial-separation", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_eccentricity, meta_file, NULL, "eccentricity", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_number_of_cycles_22, meta_file, NULL, "number-of-cycles-22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_code, meta_file, NULL, "code", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_submitter_email, meta_file, NULL, "submitter-email", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_authors_emails, meta_file, NULL, "authors-emails", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &md_freq_start_22, meta_file, NULL, "freq-start-22", &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
}
else
{
/* unknown metadata format - should not be executed */
fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format);
exit(1);
}
/*
* set metadata strings
*/
/* common waveform */
snprintf(str_mass_ratio, HISTORY_COMMENT, "mass-ratio:%s", md_mass_ratio);
snprintf(str_spin1x, HISTORY_COMMENT, "spin1x:%s", md_spin1x);
snprintf(str_spin1y, HISTORY_COMMENT, "spin1y:%s", md_spin1y);
snprintf(str_spin1z, HISTORY_COMMENT, "spin1z:%s", md_spin1z);
snprintf(str_spin2x, HISTORY_COMMENT, "spin2x:%s", md_spin2x);
snprintf(str_spin2y, HISTORY_COMMENT, "spin2y:%s", md_spin2y);
snprintf(str_spin2z, HISTORY_COMMENT, "spin2z:%s", md_spin2z);
snprintf(str_creator, HISTORY_COMMENT, "creator:%s(git:%s)", PROGRAM_NAME, lalAppsVCSId);
/* format specific metadata */
if (strcmp(metadata_format, "NINJA1") == 0)
{
/* NINJA1 */
snprintf(str_freq_start_22, HISTORY_COMMENT, "freqStart22:%s", md_freq_start_22);
snprintf(str_simulation_details, HISTORY_COMMENT, "simulation-details:%s", md_simulation_details);
snprintf(str_nr_group, HISTORY_COMMENT, "nr-group:%s", md_nr_group);
snprintf(str_email, HISTORY_COMMENT, "email:%s", md_email);
}
else if (strcmp(metadata_format, "NINJA2") == 0)
{
/* NINJA2 */
snprintf(str_waveform_name, HISTORY_COMMENT, "waveform-name:%s", md_waveform_name);
snprintf(str_initial_separation, HISTORY_COMMENT, "inital-separation:%s", md_initial_separation);
snprintf(str_eccentricity, HISTORY_COMMENT, "eccentricity:%s", md_eccentricity);
snprintf(str_freq_start_22, HISTORY_COMMENT, "freq_start_22:%s", md_freq_start_22);
snprintf(str_number_of_cycles_22, HISTORY_COMMENT, "number-of-cycles-22:%s", md_number_of_cycles_22);
snprintf(str_code, HISTORY_COMMENT, "code:%s", md_code);
snprintf(str_submitter_email, HISTORY_COMMENT, "submitter-email:%s", md_submitter_email);
snprintf(str_authors_emails, HISTORY_COMMENT, "authors-emails:%s", md_authors_emails);
}
else
{
/* unknown metadata format - should not be executed */
fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format);
exit(1);
}
/* define frame */
frame = XLALFrameNew(&epoch, duration, "NR", 0, 1, detector_flags);
/*
* add metadata as FrHistory structures
*/
/* common metadata */
XLALFrameAddFrHistory(frame, "creator", str_creator);
XLALFrameAddFrHistory(frame, "mass-ratio", str_mass_ratio);
XLALFrameAddFrHistory(frame, "spin1x", str_spin1x);
XLALFrameAddFrHistory(frame, "spin1y", str_spin1y);
XLALFrameAddFrHistory(frame, "spin1z", str_spin1z);
XLALFrameAddFrHistory(frame, "spin2x", str_spin2x);
XLALFrameAddFrHistory(frame, "spin2y", str_spin2y);
XLALFrameAddFrHistory(frame, "spin2z", str_spin2z);
/* format specific metadata */
if (strcmp(metadata_format, "NINJA1") == 0)
{
/* NINJA1 */
XLALFrameAddFrHistory(frame, "simulation-details", str_simulation_details);
XLALFrameAddFrHistory(frame, "nr-group", str_nr_group);
XLALFrameAddFrHistory(frame, "email", str_email);
XLALFrameAddFrHistory(frame, "freqStart22", str_freq_start_22);
}
else if (strcmp(metadata_format, "NINJA2") == 0)
{
/* NINJA2 */
XLALFrameAddFrHistory(frame, "waveform-name", str_waveform_name);
XLALFrameAddFrHistory(frame, "initial-separation", str_initial_separation);
XLALFrameAddFrHistory(frame, "eccentricity", str_eccentricity);
XLALFrameAddFrHistory(frame, "freq_start_22", str_freq_start_22);
XLALFrameAddFrHistory(frame, "number-of-cycles-22", str_number_of_cycles_22);
XLALFrameAddFrHistory(frame, "code", str_code);
XLALFrameAddFrHistory(frame, "submitter-email", str_code);
XLALFrameAddFrHistory(frame, "authors-emails", str_authors_emails);
}
else
{
/* unknown metadata format - should not be executed */
fprintf(stderr, "error: unsupported metadata format: %s\n", metadata_format);
exit(1);
}
/* loop over l & m values */
for (l = MIN_L; l <= MAX_L; l++)
{
for (m = (MAX_L - l); m <= MAX_L + l; m++)
{
/* ensure pointers are NULL */
wf_name[l][m] = NULL;
plus_channel[l][m] = NULL;
cross_channel[l][m] = NULL;
/* generate channel names */
plus_channel[l][m] = XLALGetNinjaChannelName("plus", l, m - MAX_L);
cross_channel[l][m] = XLALGetNinjaChannelName("cross", l, m - MAX_L);
if (generatingREAL8)
{
hplusREAL8[l][m] = NULL;
hcrossREAL8[l][m] = NULL;
waveformsREAL8[l][m] = NULL;
/* initilise waveform time series */
hplusREAL8[l][m] = XLALCreateREAL8TimeSeries(plus_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
hcrossREAL8[l][m] = XLALCreateREAL8TimeSeries(cross_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
}
else
{
hplus[l][m] = NULL;
hcross[l][m] = NULL;
waveforms[l][m] = NULL;
/* initilise waveform time series */
hplus[l][m] = XLALCreateREAL4TimeSeries(plus_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
hcross[l][m] = XLALCreateREAL4TimeSeries(cross_channel[l][m], &epoch, 0, 0, &lalDimensionlessUnit, 0);
}
/* read ht-data section of metadata file */
snprintf(field, HISTORY_COMMENT, "%d,%d", l, m - MAX_L);
XLAL_CHECK ( XLALReadConfigSTRINGVariable( &wf_name[l][m], meta_file, NULL, field, &wasRead) == XLAL_SUCCESS, XLAL_EFUNC );
/* read waveform */
if (wf_name[l][m] != NULL)
{
/* get full path to waveform data file */
snprintf(file_path, FILENAME_MAX, "%s/%s", nrDataDir, wf_name[l][m]);
if (vrbflg)
fprintf(stdout, "reading waveform: %s\n", file_path);
/* read waveforms */
if (generatingREAL8)
{
LAL_CALL(LALReadNRWave_raw_real8(&status, &waveformsREAL8[l][m], file_path), &status);
}
else
{
LAL_CALL(LALReadNRWave_raw(&status, &waveforms[l][m], file_path), &status);
}
}
/* generate waveform time series from vector series */
/* TODO: should use pointer arithmetic here and update the data
* pointer in the REAL4TimeSeries to point to the appropriate
* location within the REAL4TimeVector Series */
if (generatingREAL8) {
if (waveformsREAL8[l][m])
{
/* get length of waveform */
wf_length = waveformsREAL8[l][m]->data->vectorLength;
/* allocate memory for waveform */
XLALResizeREAL8TimeSeries(hplusREAL8[l][m], 0, wf_length);
XLALResizeREAL8TimeSeries(hcrossREAL8[l][m], 0, wf_length);
/* set time spacing */
hplusREAL8[l][m]->deltaT = waveformsREAL8[l][m]->deltaT;
hcrossREAL8[l][m]->deltaT = waveformsREAL8[l][m]->deltaT;
/* copy waveforms into appropriate series */
for (i = 0; i < wf_length; i ++) {
hplusREAL8[l][m]->data->data[i] = waveformsREAL8[l][m]->data->data[i];
hcrossREAL8[l][m]->data->data[i] = waveformsREAL8[l][m]->data->data[wf_length + i];
}
/* Done with waveformsREAL8, clean up here to limit memory usage */
LALFree(waveformsREAL8[l][m]->data->data);
LALFree(waveformsREAL8[l][m]->data);
LALFree(waveformsREAL8[l][m]);
}
}
else /* REAL4 */
{
if (waveforms[l][m])
{
/* get length of waveform */
wf_length = waveforms[l][m]->data->vectorLength;
/* allocate memory for waveform */
XLALResizeREAL4TimeSeries(hplus[l][m], 0, wf_length);
XLALResizeREAL4TimeSeries(hcross[l][m], 0, wf_length);
/* set time spacing */
hplus[l][m]->deltaT = waveforms[l][m]->deltaT;
hcross[l][m]->deltaT = waveforms[l][m]->deltaT;
/* copy waveforms into appropriate series */
for (i = 0; i < wf_length; i ++) {
hplus[l][m]->data->data[i] = waveforms[l][m]->data->data[i];
hcross[l][m]->data->data[i] = waveforms[l][m]->data->data[wf_length + i];
}
}
}
/* add channels to frame */
if (generatingREAL8)
{
if ((hplusREAL8[l][m]->data->length) && (hcrossREAL8[l][m]->data->length))
{
XLALFrameAddREAL8TimeSeriesSimData(frame, hplusREAL8[l][m]);
XLALFrameAddREAL8TimeSeriesSimData(frame, hcrossREAL8[l][m]);
}
}
else
{
if ((hplus[l][m]->data->length) && (hcross[l][m]->data->length))
{
XLALFrameAddREAL4TimeSeriesSimData(frame, hplus[l][m]);
XLALFrameAddREAL4TimeSeriesSimData(frame, hcross[l][m]);
}
}
}
}
if (vrbflg)
fprintf(stdout, "writing frame: %s\n", frame_name);
/* write frame */
if (XLALFrameWrite(frame, frame_name) != 0 )
{
fprintf(stderr, "Error: Cannot save frame file '%s'\n", frame_name);
exit(1);
}
/*
* clear memory
*/
/* strings */
if(nrMetaFile) free(nrMetaFile);
if(nrDataDir) free(nrDataDir);
if(frame_name) free(frame_name);
if(metadata_format) free(metadata_format);
/* common metadata */
if(md_mass_ratio) LALFree(md_mass_ratio);
if(md_spin1x) LALFree(md_spin1x);
if(md_spin1y) LALFree(md_spin1y);
if(md_spin1z) LALFree(md_spin1z);
if(md_spin2x) LALFree(md_spin2x);
if(md_spin2y) LALFree(md_spin2y);
if(md_spin2z) LALFree(md_spin2z);
if(md_freq_start_22) LALFree(md_freq_start_22);
/* NINJA1 metadata */
if(md_simulation_details) LALFree(md_simulation_details);
if(md_nr_group) LALFree(md_nr_group);
if(md_email) LALFree(md_email);
/* NINJA2 metadata */
if(md_waveform_name) LALFree(md_waveform_name);
if(md_initial_separation) LALFree(md_initial_separation);
if(md_eccentricity) LALFree(md_eccentricity);
if(md_number_of_cycles_22) LALFree(md_number_of_cycles_22);
if(md_code) LALFree(md_code);
if(md_submitter_email) LALFree(md_submitter_email);
if(md_authors_emails) LALFree(md_authors_emails);
/* config file */
if(meta_file->lines->list->data) LALFree(meta_file->lines->list->data);
if(meta_file->lines->list) LALFree(meta_file->lines->list);
if(meta_file->lines->tokens) LALFree(meta_file->lines->tokens);
if(meta_file->lines) LALFree(meta_file->lines);
if(meta_file->wasRead) LALFree(meta_file->wasRead);
if(meta_file) LALFree(meta_file);
/* waveforms */
if (generatingREAL8)
{
for (l = MIN_L; l <= MAX_L; l++)
{
for (m = (MAX_L - l); m <= MAX_L + l; m++)
{
/* channel names */
if (plus_channel[l][m])
LALFree(plus_channel[l][m]);
if (cross_channel[l][m])
LALFree(cross_channel[l][m]);
if (wf_name[l][m])
LALFree(wf_name[l][m]);
/* hplus */
if (hplusREAL8[l][m])
XLALDestroyREAL8TimeSeries(hplusREAL8[l][m]);
/* hcross */
if (hcrossREAL8[l][m])
XLALDestroyREAL8TimeSeries(hcrossREAL8[l][m]);
}
}
}
else
{
for (l = MIN_L; l <= MAX_L; l++)
{
for (m = (MAX_L - l); m <= MAX_L + l; m++)
{
/* channel names */
if (plus_channel[l][m])
LALFree(plus_channel[l][m]);
if (cross_channel[l][m])
LALFree(cross_channel[l][m]);
if (wf_name[l][m])
LALFree(wf_name[l][m]);
/* raw waveforms */
if (waveforms[l][m]) {
LALFree(waveforms[l][m]->data->data);
LALFree(waveforms[l][m]->data);
LALFree(waveforms[l][m]);
}
/* hplus */
if (hplus[l][m])
XLALDestroyREAL4TimeSeries(hplus[l][m]);
/* hcross */
if (hcross[l][m])
XLALDestroyREAL4TimeSeries(hcross[l][m]);
}
}
}
/* clear frame */
XLALFrameFree(frame);
/* check for memory leaks */
LALCheckMemoryLeaks();
exit(0);
}
int main(int argc, char *argv[]){
/* LALStatus pointer */
static LALStatus status;
/* time and velocity */
static LIGOTimeGPSVector timeV;
REAL8 timeBase;
LALDetector *det;
DetectorStateSeries *detStates=NULL;
/* ephemeris */
EphemerisData *edat=NULL;
/* user input variables */
BOOLEAN uvar_help;
CHAR *uvar_earthEphemeris=NULL;
CHAR *uvar_sunEphemeris=NULL;
CHAR *uvar_sftDir=NULL;
/* Set up the default parameters */
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
uvar_help = FALSE;
uvar_earthEphemeris = (CHAR *)LALCalloc( 512 , sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALCalloc( 512 , sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_REQUIRED, "Earth Ephemeris file", &uvar_earthEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_REQUIRED, "Sun Ephemeris file", &uvar_sunEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* get ephemeris */
edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = uvar_earthEphemeris;
(*edat).ephiles.sunEphemeris = uvar_sunEphemeris;
LAL_CALL( LALInitBarycenter( &status, edat), &status);
/* read sft Files and set up weights and nstar vector */
{
/* new SFT I/O data types */
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
UINT4 k;
/* set detector constraint */
constraints.detector = NULL;
/* get sft catalog */
LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status);
if ( (catalog == NULL) || (catalog->length == 0) ) {
fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir );
exit(1);
}
for (k = 0; k < catalog->length; k++) {
det = XLALGetSiteInfo ( catalog->data[k].header.name);
timeBase = 1./catalog->data[k].header.deltaF;
timeV.length = 1;
timeV.deltaT = timeBase;
timeV.data = &(catalog->data[k].header.epoch);
LAL_CALL( LALGetDetectorStates ( &status, &detStates, &timeV, det, edat, 0.5*timeBase), &status);
fprintf(stdout, "%g %g %g\n", detStates->data[0].vDetector[0], detStates->data[0].vDetector[1],
detStates->data[0].vDetector[2]);
LALDestroyDetectorStateSeries (&status, &detStates );
LALFree (det);
} /* end loop over sfts */
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
} /* end of sft reading block */
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LAL_CALL (LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
if ( lalDebugLevel )
REPORTSTATUS ( &status);
return status.statusCode;
}
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;
}
/**
* MAIN function of PredictFStat code.
* Calculates the F-statistic for a given position in the sky and detector
* semi-analytically and outputs the final 2F value.
*/
int main(int argc,char *argv[])
{
LALStatus status = blank_status; /* initialize status */
REAL8 rho2; /* SNR^2 */
UserInput_t uvar = empty_UserInput;
CHAR *VCSInfoString; /**< LAL + LALapps Git version string */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
/* register all user-variable */
LAL_CALL (initUserVars(&status, &uvar), &status);
/* do ALL cmdline and cfgfile handling */
LAL_CALL (LALUserVarReadAllInput(&status, argc, argv), &status);
if (uvar.help) /* if help was requested, we're done here */
exit (0);
if ( (VCSInfoString = XLALGetVersionString(0)) == NULL ) {
XLALPrintError("XLALGetVersionString(0) failed.\n");
exit(1);
}
if ( uvar.version ) {
printf ("%s\n", VCSInfoString );
exit(0);
}
/* Initialize code-setup */
LAL_CALL ( InitPFS(&status, &GV, &uvar ), &status);
{ /* Calculating the F-Statistic */
REAL8 al1, al2, al3;
REAL8 Ap2 = SQ(GV.aPlus);
REAL8 Ac2 = SQ(GV.aCross);
REAL8 cos2psi2 = SQ( cos(2*uvar.psi) );
REAL8 sin2psi2 = SQ( sin(2*uvar.psi) );
al1 = Ap2 * cos2psi2 + Ac2 * sin2psi2; /* A1^2 + A3^2 */
al2 = Ap2 * sin2psi2 + Ac2 * cos2psi2; /* A2^2 + A4^2 */
al3 = ( Ap2 - Ac2 ) * sin(2.0*uvar.psi) * cos(2.0*uvar.psi); /* A1 A2 + A3 A4 */
/* SNR^2 */
rho2 = GV.Mmunu.Sinv_Tsft * (GV.Mmunu.Ad * al1 + GV.Mmunu.Bd * al2 + 2.0 * GV.Mmunu.Cd * al3 );
}
if (uvar.printFstat)
fprintf(stdout, "\n%.1f\n", 4.0 + rho2);
/* output predicted Fstat-value into file, if requested */
if (uvar.outputFstat)
{
FILE *fpFstat = NULL;
CHAR *logstr = NULL;
if ( (fpFstat = fopen (uvar.outputFstat, "wb")) == NULL)
{
XLALPrintError ("\nError opening file '%s' for writing..\n\n", uvar.outputFstat);
return (PREDICTFSTAT_ESYS);
}
/* log search-footprint at head of output-file */
LAL_CALL( LALUserVarGetLog (&status, &logstr, UVAR_LOGFMT_CMDLINE ), &status );
fprintf(fpFstat, "%%%% cmdline: %s\n", logstr );
LALFree ( logstr );
fprintf ( fpFstat, "%s\n", VCSInfoString );
/* append 'dataSummary' */
fprintf (fpFstat, "%s", GV.dataSummary );
/* output E[2F] and std[2F] */
fprintf (fpFstat, "twoF_expected = %g;\n", 4.0 + rho2);
fprintf (fpFstat, "twoF_sigma = %g;\n", sqrt( 4.0 * ( 2.0 + rho2 ) ) );
/* output antenna-pattern matrix MNat_mu_nu = matrix(A, B, C) */
{
/* compute A = <a^2>, B=<b^2>, C=<ab> from the 'discretized versions Ad, Bc, Cd */
REAL8 A = GV.Mmunu.Ad / GV.numSFTs;
REAL8 B = GV.Mmunu.Bd / GV.numSFTs;
REAL8 C = GV.Mmunu.Cd / GV.numSFTs;
REAL8 D = A * B - C * C;
fprintf (fpFstat, "A = %f;\n", A );
fprintf (fpFstat, "B = %f;\n", B );
fprintf (fpFstat, "C = %f;\n", C );
fprintf (fpFstat, "D = %f;\n", D );
}
fclose (fpFstat);
} /* if outputFstat */
/* Free config-Variables and userInput stuff */
LAL_CALL (LALDestroyUserVars (&status), &status);
LALFree ( GV.dataSummary );
XLALFree ( VCSInfoString );
/* did we forget anything ? */
LALCheckMemoryLeaks();
return 0;
} /* main() */
/*============================================================
* FUNCTION definitions
*============================================================*/
int
main(int argc, char *argv[])
{
static LALStatus status; /* LALStatus pointer */
UserVariables_t XLAL_INIT_DECL(uvar);
ConfigVariables_t XLAL_INIT_DECL(cfg);
UINT4 k, numBins, numIFOs, maxNumSFTs, X, alpha;
REAL8 Freq0, dFreq, normPSD;
UINT4 finalBinSize, finalBinStep, finalNumBins;
REAL8Vector *overSFTs = NULL; /* one frequency bin over SFTs */
REAL8Vector *overIFOs = NULL; /* one frequency bin over IFOs */
REAL8Vector *finalPSD = NULL; /* math. operation PSD over SFTs and IFOs */
REAL8Vector *finalNormSFT = NULL; /* normalised SFT power */
vrbflg = 1; /* verbose error-messages */
/* set LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
/* register and read user variables */
if (initUserVars(argc, argv, &uvar) != XLAL_SUCCESS)
return EXIT_FAILURE;
MultiSFTVector *inputSFTs = NULL;
if ( ( inputSFTs = XLALReadSFTs ( &cfg, &uvar ) ) == NULL )
{
XLALPrintError ("Call to XLALReadSFTs() failed with xlalErrno = %d\n", xlalErrno );
return EXIT_FAILURE;
}
/* clean sfts if required */
if ( XLALUserVarWasSet( &uvar.linefiles ) )
{
RandomParams *randPar=NULL;
FILE *fpRand=NULL;
INT4 seed, ranCount;
if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) {
fprintf(stderr,"Error in opening /dev/urandom" );
return EXIT_FAILURE;
}
if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) {
fprintf(stderr,"Error in getting random seed" );
return EXIT_FAILURE;
}
LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status );
LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar.maxBinsClean, uvar.blocksRngMed, uvar.linefiles, randPar), &status);
LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status);
fclose(fpRand);
} /* end cleaning */
LogPrintf (LOG_DEBUG, "Computing spectrogram and PSD ... ");
/* get power running-median rngmed[ |data|^2 ] from SFTs */
MultiPSDVector *multiPSD = NULL;
XLAL_CHECK_MAIN( ( multiPSD = XLALNormalizeMultiSFTVect ( inputSFTs, uvar.blocksRngMed, NULL ) ) != NULL, XLAL_EFUNC);
/* restrict this PSD to just the "physical" band if requested using {--Freq, --FreqBand} */
if ( ( XLALCropMultiPSDandSFTVectors ( multiPSD, inputSFTs, cfg.firstBin, cfg.lastBin )) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALCropMultiPSDandSFTVectors (inputPSD, inputSFTs, %d, %d) failed with xlalErrno = %d\n", __func__, cfg.firstBin, cfg.lastBin, xlalErrno );
return EXIT_FAILURE;
}
/* start frequency and frequency spacing */
Freq0 = multiPSD->data[0]->data[0].f0;
dFreq = multiPSD->data[0]->data[0].deltaF;
/* number of raw bins in final PSD */
numBins = multiPSD->data[0]->data[0].data->length;
if ( (finalPSD = XLALCreateREAL8Vector ( numBins )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* number of IFOs */
numIFOs = multiPSD->length;
if ( (overIFOs = XLALCreateREAL8Vector ( numIFOs )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* maximum number of SFTs */
maxNumSFTs = 0;
for (X = 0; X < numIFOs; ++X) {
maxNumSFTs = GSL_MAX(maxNumSFTs, multiPSD->data[X]->length);
}
if ( (overSFTs = XLALCreateREAL8Vector ( maxNumSFTs )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* normalize rngmd(power) to get proper *single-sided* PSD: Sn = (2/Tsft) rngmed[|data|^2]] */
normPSD = 2.0 * dFreq;
/* loop over frequency bins in final PSD */
for (k = 0; k < numBins; ++k) {
/* loop over IFOs */
for (X = 0; X < numIFOs; ++X) {
/* number of SFTs for this IFO */
UINT4 numSFTs = multiPSD->data[X]->length;
/* copy PSD frequency bins and normalise multiPSD for later use */
for (alpha = 0; alpha < numSFTs; ++alpha) {
multiPSD->data[X]->data[alpha].data->data[k] *= normPSD;
overSFTs->data[alpha] = multiPSD->data[X]->data[alpha].data->data[k];
}
/* compute math. operation over SFTs for this IFO */
overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.PSDmthopSFTs);
if ( isnan( overIFOs->data[X] ) )
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X );
} /* for IFOs X */
/* compute math. operation over IFOs for this frequency */
finalPSD->data[k] = math_op(overIFOs->data, numIFOs, uvar.PSDmthopIFOs);
if ( isnan ( finalPSD->data[k] ) )
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in finalPSD->data[k=%d] = NAN ... exiting\n", k );
} /* for freq bins k */
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
/* compute normalised SFT power */
if (uvar.outputNormSFT) {
LogPrintf (LOG_DEBUG, "Computing normalised SFT power ... ");
if ( (finalNormSFT = XLALCreateREAL8Vector ( numBins )) == NULL ) {
LogPrintf (LOG_CRITICAL, "Out of memory!\n");
return EXIT_FAILURE;
}
/* loop over frequency bins in SFTs */
for (k = 0; k < numBins; ++k) {
/* loop over IFOs */
for (X = 0; X < numIFOs; ++X) {
/* number of SFTs for this IFO */
UINT4 numSFTs = inputSFTs->data[X]->length;
/* compute SFT power */
for (alpha = 0; alpha < numSFTs; ++alpha) {
COMPLEX8 bin = inputSFTs->data[X]->data[alpha].data->data[k];
overSFTs->data[alpha] = crealf(bin)*crealf(bin) + cimagf(bin)*cimagf(bin);
}
/* compute math. operation over SFTs for this IFO */
overIFOs->data[X] = math_op(overSFTs->data, numSFTs, uvar.nSFTmthopSFTs);
if ( isnan ( overIFOs->data[X] ))
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in overIFOs->data[X=%d] = NAN ... exiting\n", X );
} /* over IFOs */
/* compute math. operation over IFOs for this frequency */
finalNormSFT->data[k] = math_op(overIFOs->data, numIFOs, uvar.nSFTmthopIFOs);
if ( isnan( finalNormSFT->data[k] ) )
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in bin finalNormSFT->data[k=%d] = NAN ... exiting\n", k );
} /* over freq bins */
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
}
/* output spectrograms */
if ( uvar.outputSpectBname ) {
LAL_CALL ( LALfwriteSpectrograms ( &status, uvar.outputSpectBname, multiPSD ), &status );
}
/* ---------- if user requested it, output complete MultiPSDVector over IFOs X, timestamps and freq-bins into ASCI file(s) */
if ( uvar.dumpMultiPSDVector ) {
if ( XLALDumpMultiPSDVector ( uvar.outputPSD, multiPSD ) != XLAL_SUCCESS ) {
XLALPrintError ("%s: XLALDumpMultiPSDVector() failed, xlalErrnor = %d\n", __func__, xlalErrno );
return EXIT_FAILURE;
}
} /* if uvar.dumpMultiPSDVector */
/* ----- if requested, compute data-quality factor 'Q' -------------------- */
if ( uvar.outputQ )
{
REAL8FrequencySeries *Q;
if ( (Q = XLALComputeSegmentDataQ ( multiPSD, cfg.dataSegment )) == NULL ) {
XLALPrintError ("%s: XLALComputeSegmentDataQ() failed with xlalErrno = %d\n", __func__, xlalErrno );
return EXIT_FAILURE;
}
if ( XLAL_SUCCESS != XLALWriteREAL8FrequencySeries_to_file ( Q, uvar.outputQ ) ) {
return EXIT_FAILURE;
}
XLALDestroyREAL8FrequencySeries ( Q );
} /* if outputQ */
/* ---------- BINNING if requested ---------- */
/* work out bin size */
if (XLALUserVarWasSet(&uvar.binSize)) {
finalBinSize = uvar.binSize;
}
else if (XLALUserVarWasSet(&uvar.binSizeHz)) {
finalBinSize = (UINT4)floor(uvar.binSizeHz / dFreq + 0.5); /* round to nearest bin */
}
else {
finalBinSize = 1;
}
/* work out bin step */
if (XLALUserVarWasSet(&uvar.binStep)) {
finalBinStep = uvar.binStep;
}
else if (XLALUserVarWasSet(&uvar.binStepHz)) {
finalBinStep = (UINT4)floor(uvar.binStepHz / dFreq + 0.5); /* round to nearest bin */
}
else {
finalBinStep = finalBinSize;
}
/* work out total number of bins */
finalNumBins = (UINT4)floor((numBins - finalBinSize) / finalBinStep) + 1;
/* write final PSD to file */
if (XLALUserVarWasSet(&uvar.outputPSD)) {
FILE *fpOut = NULL;
if ((fpOut = fopen(uvar.outputPSD, "wb")) == NULL) {
LogPrintf ( LOG_CRITICAL, "Unable to open output file %s for writing...exiting \n", uvar.outputPSD );
return EXIT_FAILURE;
}
/* write header info in comments */
if ( XLAL_SUCCESS != XLALOutputVersionString ( fpOut, 0 ) )
XLAL_ERROR ( XLAL_EFUNC );
/* write the command-line */
for (int a = 0; a < argc; a++)
fprintf(fpOut,"%%%% argv[%d]: '%s'\n", a, argv[a]);
/* write column headings */
fprintf(fpOut,"%%%% columns:\n%%%% FreqBinStart");
if (uvar.outFreqBinEnd)
fprintf(fpOut," FreqBinEnd");
fprintf(fpOut," PSD");
if (uvar.outputNormSFT)
fprintf(fpOut," normSFTpower");
fprintf(fpOut,"\n");
LogPrintf(LOG_DEBUG, "Printing PSD to file ... ");
for (k = 0; k < finalNumBins; ++k) {
UINT4 b = k * finalBinStep;
REAL8 f0 = Freq0 + b * dFreq;
REAL8 f1 = f0 + finalBinStep * dFreq;
fprintf(fpOut, "%f", f0);
if (uvar.outFreqBinEnd)
fprintf(fpOut, " %f", f1);
REAL8 psd = math_op(&(finalPSD->data[b]), finalBinSize, uvar.PSDmthopBins);
if ( isnan ( psd ))
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in psd[k=%d] = NAN ... exiting\n", k );
fprintf(fpOut, " %e", psd);
if (uvar.outputNormSFT) {
REAL8 nsft = math_op(&(finalNormSFT->data[b]), finalBinSize, uvar.nSFTmthopBins);
if ( isnan ( nsft ))
XLAL_ERROR ( EXIT_FAILURE, "Found Not-A-Number in nsft[k=%d] = NAN ... exiting\n", k );
fprintf(fpOut, " %f", nsft);
}
fprintf(fpOut, "\n");
} // k < finalNumBins
LogPrintfVerbatim ( LOG_DEBUG, "done.\n");
fclose(fpOut);
}
/* we are now done with the psd */
XLALDestroyMultiPSDVector ( multiPSD);
XLALDestroyMultiSFTVector ( inputSFTs);
XLALDestroyUserVars();
XLALDestroyREAL8Vector ( overSFTs );
XLALDestroyREAL8Vector ( overIFOs );
XLALDestroyREAL8Vector ( finalPSD );
XLALDestroyREAL8Vector ( finalNormSFT );
LALCheckMemoryLeaks();
return EXIT_SUCCESS;
} /* main() */
int main(int argc, char *argv[]){
/* LALStatus pointer */
static LALStatus status;
/* time and velocity */
static LIGOTimeGPSVector timeV;
static REAL8Cart3CoorVector velV;
static REAL8Vector timeDiffV;
LIGOTimeGPS firstTimeStamp;
/* standard pulsar sft types */
MultiSFTVector *inputSFTs = NULL;
UINT4 binsSFT;
UINT4 sftFminBin;
UINT4 numsft;
INT4 k;
FILE *fp=NULL;
/* information about all the ifos */
MultiDetectorStateSeries *mdetStates = NULL;
UINT4 numifo;
/* vector of weights */
REAL8Vector weightsV;
/* ephemeris */
EphemerisData *edat=NULL;
static UCHARPeakGram pg1;
static HoughTemplate pulsarTemplate;
static REAL8Vector foft;
/* miscellaneous */
UINT4 mObsCoh;
REAL8 timeBase, deltaF;
REAL8 numberCount;
/* Chi2Test parameters */
HoughParamsTest chi2Params;
REAL8Vector numberCountV; /* Vector with the number count of each block inside */
REAL8 numberCountTotal; /* Sum over all the numberCounts */
REAL8 chi2;
/* sft constraint variables */
LIGOTimeGPS startTimeGPS, endTimeGPS;
LIGOTimeGPSVector *inputTimeStampsVector=NULL;
REAL8 alphaPeak, meanN, sigmaN;
/* user input variables */
BOOLEAN uvar_help, uvar_weighAM, uvar_weighNoise;
INT4 uvar_blocksRngMed, uvar_nfSizeCylinder, uvar_maxBinsClean;
REAL8 uvar_startTime, uvar_endTime;
REAL8 uvar_fStart, uvar_peakThreshold, uvar_fSearchBand;
REAL8 uvar_Alpha, uvar_Delta, uvar_Freq, uvar_fdot;
REAL8 uvar_AlphaWeight, uvar_DeltaWeight;
CHAR *uvar_earthEphemeris=NULL;
CHAR *uvar_sunEphemeris=NULL;
CHAR *uvar_sftDir=NULL;
CHAR *uvar_timeStampsFile=NULL;
CHAR *uvar_outfile=NULL;
LALStringVector *uvar_linefiles=NULL;
INT4 uvar_p;
/* Set up the default parameters */
/* LAL error-handler */
lal_errhandler = LAL_ERR_EXIT;
uvar_help = FALSE;
uvar_weighAM = TRUE;
uvar_weighNoise = TRUE;
uvar_blocksRngMed = BLOCKSRNGMED;
uvar_nfSizeCylinder = NFSIZE;
uvar_fStart = F0;
uvar_fSearchBand = FBAND;
uvar_peakThreshold = THRESHOLD;
uvar_maxBinsClean = 100;
uvar_startTime= 0;
uvar_endTime = LAL_INT4_MAX;
uvar_Alpha = 1.0;
uvar_Delta = 1.0;
uvar_Freq = 310.0;
uvar_fdot = 0.0;
uvar_AlphaWeight = uvar_Alpha;
uvar_DeltaWeight = uvar_Delta;
uvar_p = NBLOCKSTEST;
chi2Params.length=uvar_p;
chi2Params.numberSFTp=NULL;
chi2Params.sumWeight=NULL;
chi2Params.sumWeightSquare=NULL;
uvar_outfile = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_outfile, "./tempout");
uvar_earthEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_earthEphemeris,EARTHEPHEMERIS);
uvar_sunEphemeris = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_sunEphemeris,SUNEPHEMERIS);
uvar_sftDir = (CHAR *)LALCalloc( MAXFILENAMELENGTH , sizeof(CHAR));
strcpy(uvar_sftDir,SFTDIRECTORY);
/* register user input variables */
LAL_CALL( LALRegisterBOOLUserVar( &status, "help", 'h', UVAR_HELP, "Print this message", &uvar_help), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fStart", 'f', UVAR_OPTIONAL, "Start search frequency", &uvar_fStart), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fSearchBand", 'b', UVAR_OPTIONAL, "Search frequency band", &uvar_fSearchBand), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "startTime", 0, UVAR_OPTIONAL, "GPS start time of observation", &uvar_startTime), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "endTime", 0, UVAR_OPTIONAL, "GPS end time of observation", &uvar_endTime), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "timeStampsFile", 0, UVAR_OPTIONAL, "Input time-stamps file", &uvar_timeStampsFile), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "peakThreshold", 0, UVAR_OPTIONAL, "Peak selection threshold", &uvar_peakThreshold), &status);
LAL_CALL( LALRegisterBOOLUserVar( &status, "weighAM", 0, UVAR_OPTIONAL, "Use amplitude modulation weights", &uvar_weighAM), &status);
LAL_CALL( LALRegisterBOOLUserVar( &status, "weighNoise", 0, UVAR_OPTIONAL, "Use SFT noise weights", &uvar_weighNoise), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "earthEphemeris", 'E', UVAR_OPTIONAL, "Earth Ephemeris file", &uvar_earthEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sunEphemeris", 'S', UVAR_OPTIONAL, "Sun Ephemeris file", &uvar_sunEphemeris), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "sftDir", 'D', UVAR_REQUIRED, "SFT filename pattern", &uvar_sftDir), &status);
LAL_CALL( LALRegisterLISTUserVar( &status, "linefiles", 0, UVAR_OPTIONAL, "Comma separated List of linefiles (filenames must contain IFO name)",
&uvar_linefiles), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "Alpha", 0, UVAR_OPTIONAL, "Sky location (longitude)", &uvar_Alpha), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "Delta", 0, UVAR_OPTIONAL, "Sky location (latitude)", &uvar_Delta), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "Freq", 0, UVAR_OPTIONAL, "Template frequency", &uvar_Freq), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "fdot", 0, UVAR_OPTIONAL, "First spindown", &uvar_fdot), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "AlphaWeight", 0, UVAR_OPTIONAL, "sky Alpha for weight calculation", &uvar_AlphaWeight), &status);
LAL_CALL( LALRegisterREALUserVar( &status, "DeltaWeight", 0, UVAR_OPTIONAL, "sky Delta for weight calculation", &uvar_DeltaWeight), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "nfSizeCylinder", 0, UVAR_OPTIONAL, "Size of cylinder of PHMDs", &uvar_nfSizeCylinder), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "blocksRngMed", 0, UVAR_OPTIONAL, "Running Median block size", &uvar_blocksRngMed), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "maxBinsClean", 0, UVAR_OPTIONAL, "Maximum number of bins in cleaning", &uvar_maxBinsClean), &status);
LAL_CALL( LALRegisterSTRINGUserVar( &status, "outfile", 0, UVAR_OPTIONAL, "output file name", &uvar_outfile), &status);
LAL_CALL( LALRegisterINTUserVar( &status, "pdatablock", 'p', UVAR_OPTIONAL, "Number of data blocks for veto tests", &uvar_p), &status);
/* read all command line variables */
LAL_CALL( LALUserVarReadAllInput(&status, argc, argv), &status);
/* exit if help was required */
if (uvar_help)
exit(0);
/* very basic consistency checks on user input */
if ( uvar_fStart < 0 ) {
fprintf(stderr, "start frequency must be positive\n");
exit(1);
}
if ( uvar_fSearchBand < 0 ) {
fprintf(stderr, "search frequency band must be positive\n");
exit(1);
}
if ( uvar_peakThreshold < 0 ) {
fprintf(stderr, "peak selection threshold must be positive\n");
exit(1);
}
/***** start main calculations *****/
chi2Params.length=uvar_p;
chi2Params.numberSFTp = (UINT4 *)LALMalloc( uvar_p*sizeof(UINT4));
chi2Params.sumWeight = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8));
chi2Params.sumWeightSquare = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8));
/* read sft Files and set up weights */
{
/* new SFT I/O data types */
SFTCatalog *catalog = NULL;
static SFTConstraints constraints;
REAL8 doppWings, f_min, f_max;
/* set detector constraint */
constraints.detector = NULL;
if ( LALUserVarWasSet( &uvar_startTime ) ) {
XLALGPSSetREAL8(&startTimeGPS, uvar_startTime);
constraints.minStartTime = &startTimeGPS;
}
if ( LALUserVarWasSet( &uvar_endTime ) ) {
XLALGPSSetREAL8(&endTimeGPS, uvar_endTime);
constraints.maxEndTime = &endTimeGPS;
}
if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) {
LAL_CALL ( LALReadTimestampsFile ( &status, &inputTimeStampsVector, uvar_timeStampsFile), &status);
constraints.timestamps = inputTimeStampsVector;
}
/* get sft catalog */
LAL_CALL( LALSFTdataFind( &status, &catalog, uvar_sftDir, &constraints), &status);
if ( (catalog == NULL) || (catalog->length == 0) ) {
fprintf (stderr,"Unable to match any SFTs with pattern '%s'\n", uvar_sftDir );
exit(1);
}
/* now we can free the inputTimeStampsVector */
if ( LALUserVarWasSet( &uvar_timeStampsFile ) ) {
LALDestroyTimestampVector ( &status, &inputTimeStampsVector);
}
/* get some sft parameters */
mObsCoh = catalog->length; /* number of sfts */
deltaF = catalog->data->header.deltaF; /* frequency resolution */
timeBase= 1.0/deltaF; /* coherent integration time */
// unused: UINT8 f0Bin = floor( uvar_fStart * timeBase + 0.5); /* initial search frequency */
// unused: INT4 length = uvar_fSearchBand * timeBase; /* total number of search bins - 1 */
/* catalog is ordered in time so we can get start, end time and tObs*/
firstTimeStamp = catalog->data[0].header.epoch;
// unused: LIGOTimeGPS lastTimeStamp = catalog->data[mObsCoh - 1].header.epoch;
/* allocate memory for velocity vector */
velV.length = mObsCoh;
velV.data = NULL;
velV.data = (REAL8Cart3Coor *)LALCalloc(mObsCoh, sizeof(REAL8Cart3Coor));
/* allocate memory for timestamps vector */
timeV.length = mObsCoh;
timeV.data = NULL;
timeV.data = (LIGOTimeGPS *)LALCalloc( mObsCoh, sizeof(LIGOTimeGPS));
/* allocate memory for vector of time differences from start */
timeDiffV.length = mObsCoh;
timeDiffV.data = NULL;
timeDiffV.data = (REAL8 *)LALCalloc(mObsCoh, sizeof(REAL8));
/* add wings for Doppler modulation and running median block size*/
doppWings = (uvar_fStart + uvar_fSearchBand) * VTOT;
f_min = uvar_fStart - doppWings - (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF;
f_max = uvar_fStart + uvar_fSearchBand + doppWings + (uvar_blocksRngMed + uvar_nfSizeCylinder) * deltaF;
/* read sft files making sure to add extra bins for running median */
/* read the sfts */
LAL_CALL( LALLoadMultiSFTs ( &status, &inputSFTs, catalog, f_min, f_max), &status);
/* clean sfts if required */
if ( LALUserVarWasSet( &uvar_linefiles ) )
{
RandomParams *randPar=NULL;
FILE *fpRand=NULL;
INT4 seed, ranCount;
if ( (fpRand = fopen("/dev/urandom", "r")) == NULL ) {
fprintf(stderr,"Error in opening /dev/urandom" );
exit(1);
}
if ( (ranCount = fread(&seed, sizeof(seed), 1, fpRand)) != 1 ) {
fprintf(stderr,"Error in getting random seed" );
exit(1);
}
LAL_CALL ( LALCreateRandomParams (&status, &randPar, seed), &status );
LAL_CALL( LALRemoveKnownLinesInMultiSFTVector ( &status, inputSFTs, uvar_maxBinsClean, uvar_blocksRngMed, uvar_linefiles, randPar), &status);
LAL_CALL ( LALDestroyRandomParams (&status, &randPar), &status);
fclose(fpRand);
} /* end cleaning */
/* SFT info -- assume all SFTs have same length */
numifo = inputSFTs->length;
binsSFT = inputSFTs->data[0]->data->data->length;
sftFminBin = (INT4) floor(inputSFTs->data[0]->data[0].f0 * timeBase + 0.5);
LAL_CALL( LALDestroySFTCatalog( &status, &catalog ), &status);
} /* end of sft reading block */
/* get detector velocities weights vector, and timestamps */
{
MultiNoiseWeights *multweight = NULL;
MultiPSDVector *multPSD = NULL;
UINT4 iIFO, iSFT, j;
/* get ephemeris */
edat = (EphemerisData *)LALCalloc(1, sizeof(EphemerisData));
(*edat).ephiles.earthEphemeris = uvar_earthEphemeris;
(*edat).ephiles.sunEphemeris = uvar_sunEphemeris;
LAL_CALL( LALInitBarycenter( &status, edat), &status);
/* normalize sfts */
LAL_CALL( LALNormalizeMultiSFTVect (&status, &multPSD, inputSFTs, uvar_blocksRngMed), &status);
/* set up weights */
weightsV.length = mObsCoh;
weightsV.data = (REAL8 *)LALCalloc(1, mObsCoh * sizeof(REAL8));
/* initialize all weights to unity */
LAL_CALL( LALHOUGHInitializeWeights( &status, &weightsV), &status);
/* compute multi noise weights if required */
if ( uvar_weighNoise ) {
LAL_CALL ( LALComputeMultiNoiseWeights ( &status, &multweight, multPSD, uvar_blocksRngMed, 0), &status);
}
/* we are now done with the psd */
LAL_CALL ( LALDestroyMultiPSDVector ( &status, &multPSD), &status);
/* get information about all detectors including velocity and timestamps */
/* note that this function returns the velocity at the
mid-time of the SFTs -- should not make any difference */
LAL_CALL ( LALGetMultiDetectorStates ( &status, &mdetStates, inputSFTs, edat), &status);
/* copy the timestamps, weights, and velocity vector */
for (j = 0, iIFO = 0; iIFO < numifo; iIFO++ ) {
numsft = mdetStates->data[iIFO]->length;
for ( iSFT = 0; iSFT < numsft; iSFT++, j++) {
velV.data[j].x = mdetStates->data[iIFO]->data[iSFT].vDetector[0];
velV.data[j].y = mdetStates->data[iIFO]->data[iSFT].vDetector[1];
velV.data[j].z = mdetStates->data[iIFO]->data[iSFT].vDetector[2];
if ( uvar_weighNoise )
weightsV.data[j] = multweight->data[iIFO]->data[iSFT];
/* mid time of sfts */
timeV.data[j] = mdetStates->data[iIFO]->data[iSFT].tGPS;
} /* loop over SFTs */
} /* loop over IFOs */
if ( uvar_weighNoise ) {
LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status);
}
/* compute the time difference relative to startTime for all SFTs */
for(j = 0; j < mObsCoh; j++)
timeDiffV.data[j] = XLALGPSDiff( timeV.data + j, &firstTimeStamp );
if ( uvar_weighNoise ) {
LAL_CALL ( LALDestroyMultiNoiseWeights ( &status, &multweight), &status);
}
} /* end block for noise weights, velocity and time */
/* calculate amplitude modulation weights if required */
if (uvar_weighAM)
{
MultiAMCoeffs *multiAMcoef = NULL;
UINT4 iIFO, iSFT;
SkyPosition skypos;
/* get the amplitude modulation coefficients */
skypos.longitude = uvar_AlphaWeight;
skypos.latitude = uvar_DeltaWeight;
skypos.system = COORDINATESYSTEM_EQUATORIAL;
LAL_CALL ( LALGetMultiAMCoeffs ( &status, &multiAMcoef, mdetStates, skypos), &status);
/* loop over the weights and multiply them by the appropriate
AM coefficients */
for ( k = 0, iIFO = 0; iIFO < numifo; iIFO++) {
numsft = mdetStates->data[iIFO]->length;
for ( iSFT = 0; iSFT < numsft; iSFT++, k++) {
REAL8 a, b;
a = multiAMcoef->data[iIFO]->a->data[iSFT];
b = multiAMcoef->data[iIFO]->b->data[iSFT];
weightsV.data[k] *= (a*a + b*b);
} /* loop over SFTs */
} /* loop over IFOs */
LAL_CALL( LALHOUGHNormalizeWeights( &status, &weightsV), &status);
XLALDestroyMultiAMCoeffs ( multiAMcoef );
} /* end AM weights calculation */
/* misc. memory allocations */
/* memory for one spindown */
pulsarTemplate.spindown.length = 1;
pulsarTemplate.spindown.data = NULL;
pulsarTemplate.spindown.data = (REAL8 *)LALMalloc(sizeof(REAL8));
/* copy template parameters */
pulsarTemplate.spindown.data[0] = uvar_fdot;
pulsarTemplate.f0 = uvar_Freq;
pulsarTemplate.latitude = uvar_Delta;
pulsarTemplate.longitude = uvar_Alpha;
/* memory for f(t) vector */
foft.length = mObsCoh;
foft.data = NULL;
foft.data = (REAL8 *)LALMalloc(mObsCoh*sizeof(REAL8));
/* memory for peakgram */
pg1.length = binsSFT;
pg1.data = NULL;
pg1.data = (UCHAR *)LALCalloc( binsSFT, sizeof(UCHAR));
/* memory for number Count Vector */
numberCountV.length = uvar_p;
numberCountV.data = NULL;
numberCountV.data = (REAL8 *)LALMalloc( uvar_p*sizeof(REAL8));
/* block for calculating peakgram and number count */
{
UINT4 iIFO, iSFT, ii, numberSFTp;
INT4 ind;
REAL8 sumWeightSquare;
SFTtype *sft;
/* compute mean and sigma for noise only */
/* first calculate the sum of the weights squared */
sumWeightSquare = 0.0;
for ( k = 0; k < (INT4)mObsCoh; k++)
sumWeightSquare += weightsV.data[k] * weightsV.data[k];
/* probability of selecting a peak expected mean and standard deviation for noise only */
alphaPeak = exp( - uvar_peakThreshold);
meanN = mObsCoh* alphaPeak;
sigmaN = sqrt(sumWeightSquare * alphaPeak * (1.0 - alphaPeak));
/* the received frequency as a function of time */
LAL_CALL( ComputeFoft(&status, &foft, &pulsarTemplate, &timeDiffV, &velV, timeBase), &status);
LAL_CALL(SplitSFTs(&status, &weightsV, &chi2Params), &status);
/* loop over SFT, generate peakgram and get number count */
UINT4 j;
j=0;
iIFO=0;
iSFT=0;
numsft = mdetStates->data[iIFO]->length;
for (k=0 ; k<uvar_p ; k++ ){
numberSFTp=chi2Params.numberSFTp[k];
numberCount = 0;
for (ii=0 ; (ii < numberSFTp)&&(iIFO<numifo) ; ii++) {
sft = inputSFTs->data[iIFO]->data + iSFT;
LAL_CALL (SFTtoUCHARPeakGram( &status, &pg1, sft, uvar_peakThreshold), &status);
ind = floor( foft.data[j]*timeBase - sftFminBin + 0.5);
numberCount += pg1.data[ind]*weightsV.data[j];
j++;
iSFT++;
if (iSFT >= numsft){
iIFO++;
iSFT=0;
if (iIFO<numifo){
numsft = mdetStates->data[iIFO]->length;
}
}
} /* loop over SFTs */
numberCountV.data[k]=numberCount;
} /* loop over blocks */
}
/* Chi2 Test */
{
REAL8 eta; /* Auxiliar variable */
REAL8 nj, sumWeightj, sumWeightSquarej;
numberCountTotal=0;
chi2=0;
for(k=0; k<uvar_p ; k++){
numberCountTotal += numberCountV.data[k];
}
eta=numberCountTotal/mObsCoh;
INT4 j;
for(j=0 ; j<(uvar_p) ; j++){
nj=numberCountV.data[j];
sumWeightj=chi2Params.sumWeight[j];
sumWeightSquarej=chi2Params.sumWeightSquare[j];
chi2 += (nj-sumWeightj*eta)*(nj-sumWeightj*eta)/(sumWeightSquarej*eta*(1-eta));
}
}
fp = fopen(uvar_outfile , "w");
setvbuf(fp, (char *)NULL, _IOLBF, 0);
fprintf(fp, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot);
/* fprintf(stdout, "%g %g %g %g %g %g %g %g \n", (numberCountTotal - meanN)/sigmaN, meanN ,sigmaN, chi2, uvar_Freq, uvar_Alpha, uvar_Delta, uvar_fdot);*/
fclose(fp);
/* free memory */
LALFree(pulsarTemplate.spindown.data);
LALFree(timeV.data);
LALFree(timeDiffV.data);
LALFree(foft.data);
LALFree(velV.data);
LALFree(weightsV.data);
XLALDestroyMultiDetectorStateSeries ( mdetStates );
LALFree(edat->ephemE);
LALFree(edat->ephemS);
LALFree(edat);
LAL_CALL (LALDestroyMultiSFTVector(&status, &inputSFTs), &status );
LALFree(pg1.data);
LALFree(numberCountV.data);
LALFree(chi2Params.numberSFTp);
LALFree(chi2Params.sumWeight);
LALFree(chi2Params.sumWeightSquare);
LAL_CALL (LALDestroyUserVars(&status), &status);
LALCheckMemoryLeaks();
if ( lalDebugLevel )
REPORTSTATUS ( &status);
return status.statusCode;
}
/* main program loop */
INT4 main(INT4 argc, CHAR *argv[])
{
/* status */
LALStatus status = blank_status;
/* LALgetopt flags */
static int text_flag;
static int cat_flag;
static int analyse_flag;
static int powerlaw_flag;
/* counters */
INT4 i, j;
/* combined statistics variables */
REAL8 numerator = 0;
REAL8 denominator = 0;
REAL8 yOpt = 0;
REAL8 sigmaOpt = 0;
REAL8 confidence = 0.95;
REAL8 zeta;
REAL8 upperlimit;
/* pdf */
REAL8 exponent;
REAL8 pdf[100];
REAL8 min_omega;
REAL8 max_omega;
REAL8 min_alpha = -1;
REAL8 max_alpha = 1;
REAL8 omega;
REAL8 alpha;
/* powerlaw pdf */
REAL8 pdf_powerlaw[100][100];
REAL8 freq;
REAL8 freq_ref = 100;
REAL8 omega_numerator;
REAL8 omega_denominator;
REAL8 sigma2_denominator;
REAL8 omega_hat[100];
REAL8 sigma2_omega_hat[100];
/* program option variables */
CHAR *outputFileName = NULL;
/* xml data structures */
LIGOLwXMLStream xmlStream;
INT4 numSegments = 0;
StochasticTable *stochHead = NULL;
StochasticTable *thisStoch = NULL;
MetadataTable outputTable;
StochasticTable **stochHandle = NULL;
/* text output file */
FILE *out;
FILE *pdf_out;
FILE *omega_out;
FILE *sigma_out;
/* parse command line arguments */
while (1)
{
/* LALgetopt arguments */
static struct LALoption long_options[] =
{
/* options that set a flag */
{"verbose", no_argument, &vrbflg, 1},
{"text", no_argument, &text_flag, 1},
{"cat-only", no_argument, &cat_flag, 1},
{"analyse-only", no_argument, &analyse_flag, 1},
{"powerlaw-pdf", no_argument, &powerlaw_flag, 1},
/* options that don't set a flag */
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"output", required_argument, 0, 'o'},
{"confidence", required_argument, 0, 'c'},
{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, "hvo:c:", long_options, &option_index);
/* detect the end of the options */
if (c == - 1)
{
/* end of options, break loop */
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 parseing option %s with argument %s\n", \
long_options[option_index].name, LALoptarg);
exit(1);
}
break;
case 'h':
fprintf(stdout, USAGE);
exit(0);
break;
case 'v':
/* display version info and exit */
fprintf(stdout, "Stochastic Post Processing: Bayesian\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);
break;
case 'c':
/* confidence level */
confidence = atof(LALoptarg);
if ((confidence >= 1) || (confidence <= 0))
{
fprintf(stderr, "invalid argument to --%s\n" \
"confidence must be between 0 and 1, exclusive " \
"(%.2f specified)\n", long_options[option_index].name, \
confidence);
exit(1);
}
break;
case '?':
exit(1);
break;
default:
fprintf(stderr, "Unknown error while parsing options\n");
exit(1);
}
}
/* read in the input data from the rest of the arguments */
if (LALoptind < argc)
{
for (i = LALoptind; i < argc; ++i)
{
struct stat infileStatus;
/* if the named file does not exist, exit with an error */
if (stat(argv[i], &infileStatus) == -1)
{
fprintf(stderr, "Error opening input file \"%s\"\n", argv[i]);
exit(1);
}
if (!stochHead)
{
stochHandle = &stochHead;
}
else
{
stochHandle = &thisStoch->next;
}
/* read in the stochastic table */
numSegments = LALStochasticTableFromLIGOLw(stochHandle, argv[i]);
if (numSegments < 0)
{
fprintf(stderr, "Unable to read stochastic_table from \"%s\"\n", \
argv[i]);
exit(1);
}
else if (numSegments > 0)
{
if (vrbflg)
{
fprintf(stdout, "Read in %d segments from file \"%s\"\n", \
numSegments, argv[i]);
}
/* scroll to end of list */
thisStoch = *stochHandle;
while (thisStoch->next)
{
thisStoch = thisStoch->next;
}
}
}
}
if (!cat_flag)
{
/* combine statistics */
for (thisStoch = stochHead; thisStoch; thisStoch = thisStoch->next)
{
numerator += thisStoch->cc_stat / (thisStoch->cc_sigma * \
thisStoch->cc_sigma);
denominator += 1./(thisStoch->cc_sigma * thisStoch->cc_sigma);
}
yOpt = (1./stochHead->duration.gpsSeconds) * (numerator / denominator);
sigmaOpt = (1./stochHead->duration.gpsSeconds) * (1./sqrt(denominator));
/* report point estimate and sigma */
fprintf(stdout, "yOpt = %e\n", yOpt);
fprintf(stdout, "sigmaOpt = %e\n", sigmaOpt);
/* calculate upperlimit */
zeta = yOpt / (sqrt(2) * sigmaOpt);
upperlimit = yOpt + (sqrt(2) * sigmaOpt * \
stopp_erfcinv((1 - confidence) * gsl_sf_erfc(-zeta)));
fprintf(stdout, "upperlimit = %e\n", upperlimit);
}
/* calculate pdf */
if (!powerlaw_flag)
{
/* pdf for constant spectra */
min_omega = 0;
max_omega = yOpt + (3 * sigmaOpt);
for (i = 0; i < 100; i++)
{
omega = min_omega + (((i - 1)/99.) * (max_omega - min_omega));
exponent = ((omega - yOpt) / sigmaOpt) * ((omega - yOpt) / sigmaOpt);
pdf[i] = exp(-0.5 * exponent);
}
}
else
{
/* pdf for power law spectra */
min_omega = 0;
max_omega = 1; /*(10 * yOpt)/stochHead->duration.gpsSeconds;*/
min_alpha = -4;
max_alpha = 4;
/* loop for \Omega_R */
for (i = 0; i < 100; i++)
{
/* loop for \alpha */
for (j = 0; j < 100; j++)
{
omega = min_omega + ((i/99.) * (max_omega - min_omega));
alpha = min_alpha + ((j/99.) * (max_alpha - min_alpha));
/* initialise numerator */
omega_numerator = 0;
omega_denominator = 0;
sigma2_denominator = 0;
/* loop over segments */
for (thisStoch = stochHead; thisStoch; thisStoch = thisStoch->next)
{
/* get frequency of middle of the band */
freq = thisStoch->f_min + ((thisStoch->f_max - \
thisStoch->f_min) / 2.);
/* \hat{\Omega}_R */
omega_numerator += (thisStoch->cc_stat / (thisStoch->cc_sigma * \
thisStoch->cc_sigma)) * pow((freq/freq_ref), alpha);
omega_denominator += (1. / (thisStoch->cc_sigma * \
thisStoch->cc_sigma)) * pow((freq/freq_ref), 2 * alpha);
/* sigma^2_{\hat{\Omega}_R} */
sigma2_denominator += (1. / (thisStoch->cc_sigma * \
thisStoch->cc_sigma)) * pow((freq/freq_ref), 2 * alpha);
}
/* construct \hat{\Omega}_R */
omega_hat[j] = omega_numerator / (stochHead->duration.gpsSeconds * \
omega_denominator);
/* construct sigma^2_{\hat{\Omega}_R} */
sigma2_omega_hat[j] = 1. / (stochHead->duration.gpsSeconds * \
stochHead->duration.gpsSeconds * sigma2_denominator);
/* construct pdf */
pdf_powerlaw[i][j] = exp(-0.5 * ((omega - omega_hat[j]) / \
sqrt(sigma2_omega_hat[j])) * ((omega - omega_hat[j]) / \
sqrt(sigma2_omega_hat[j])));
}
}
}
if (!cat_flag)
{
if (powerlaw_flag)
{
/* open omega and sigma output files */
if ((omega_out = fopen("omega.dat", "w")) == NULL)
{
fprintf(stderr, "Can't open file for omega output...\n");
exit(1);
}
if ((sigma_out = fopen("sigma.dat", "w")) == NULL)
{
fprintf(stderr, "Can't open file for sigma output...\n");
exit(1);
}
/* save out omega and sigma */
for (j = 0; j < 100; j++)
{
alpha = min_alpha + ((j/99.) * (max_alpha - min_alpha));
fprintf(omega_out, "%e %e\n", alpha, omega_hat[j]);
fprintf(sigma_out, "%e %e\n", alpha, sqrt(sigma2_omega_hat[j]));
}
/* close files */
fclose(omega_out);
fclose(sigma_out);
}
/* save out pdf */
if ((pdf_out = fopen("pdf.dat", "w")) == NULL)
{
fprintf(stderr, "Can't open file for pdf output...\n");
exit(1);
}
if (powerlaw_flag)
{
for (i = 0; i < 100; i++)
{
for (j = 0; j < 100; j++)
{
omega = min_omega + ((i/99.) * (max_omega - min_omega));
alpha = min_alpha + ((j/99.) * (max_alpha - min_alpha));
fprintf(pdf_out, "%e %e %e\n", omega, alpha, pdf_powerlaw[i][j]);
}
/* gnuplot */
fprintf(pdf_out, "\n");
}
}
else
{
for (i = 0; i < 100; i++)
{
omega = min_omega + (((i - 1)/99.) * (max_omega - min_omega));
fprintf(pdf_out, "%e %e\n", omega, pdf[i]);
}
}
fclose(pdf_out);
}
if (!analyse_flag)
{
/* output as text file */
if (text_flag)
{
/* open output file */
if ((out = fopen(outputFileName, "w")) == NULL)
{
fprintf(stderr, "Can't open file \"%s\" for output...\n", \
outputFileName);
exit(1);
}
/* write details of events */
for (thisStoch = stochHead; thisStoch; thisStoch = thisStoch->next)
{
fprintf(out, "%d %e %e\n", thisStoch->start_time.gpsSeconds, \
thisStoch->cc_stat, thisStoch->cc_sigma);
}
/* close output file */
fclose(out);
}
/* output as xml file */
else
{
/* open xml file stream */
memset(&xmlStream, 0, sizeof(LIGOLwXMLStream));
LAL_CALL(LALOpenLIGOLwXMLFile(&status, &xmlStream, outputFileName), \
&status);
/* write stochastic table */
if (stochHead)
{
outputTable.stochasticTable = stochHead;
LAL_CALL(LALBeginLIGOLwXMLTable(&status, &xmlStream, \
stochastic_table), &status);
LAL_CALL(LALWriteLIGOLwXMLTable(&status, &xmlStream, outputTable, \
stochastic_table), &status);
LAL_CALL(LALEndLIGOLwXMLTable(&status, &xmlStream), &status);
}
/* close xml file */
LAL_CALL(LALCloseLIGOLwXMLFile(&status, &xmlStream), &status);
}
}
/* check for memory leaks and exit */
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 );
}
REAL4 XLALCandleDistanceTD(
Approximant approximant,
REAL4 candleM1,
REAL4 candleM2,
REAL4 candlesnr,
REAL8 chanDeltaT,
INT4 nPoints,
REAL8FrequencySeries *spec,
UINT4 cut)
{
LALStatus status = blank_status;
InspiralTemplate tmplt;
REAL4Vector *waveform = NULL;
COMPLEX8Vector *waveFFT = NULL;
REAL4FFTPlan *fwdPlan = NULL;
REAL8 sigmaSq;
REAL8 distance;
UINT4 i;
memset( &tmplt, 0, sizeof(tmplt) );
/* Create storage for TD and FD template */
waveform = XLALCreateREAL4Vector( nPoints );
waveFFT = XLALCreateCOMPLEX8Vector( spec->data->length );
fwdPlan = XLALCreateForwardREAL4FFTPlan( nPoints, 0 );
/* Populate the template parameters */
tmplt.mass1 = candleM1;
tmplt.mass2 = candleM2;
tmplt.ieta = 1;
tmplt.approximant = approximant;
tmplt.tSampling = 1.0/chanDeltaT;
tmplt.order = LAL_PNORDER_PSEUDO_FOUR; /* Hardcode for EOBNR for now */
tmplt.fLower = spec->deltaF *cut;
tmplt.distance = 1.0e6 * LAL_PC_SI; /* Mpc */
tmplt.massChoice = m1Andm2;
tmplt.fCutoff = tmplt.tSampling / 2.0 - spec->deltaF;
/* From this, calculate the other parameters */
LAL_CALL( LALInspiralParameterCalc( &status, &tmplt ), &status );
/* Generate the waveform */
LAL_CALL( LALInspiralWave( &status, waveform, &tmplt ), &status );
XLALREAL4ForwardFFT( waveFFT, waveform, fwdPlan );
sigmaSq = 0.0;
for ( i = cut; i < waveFFT->length; i++ )
{
sigmaSq += ( crealf(waveFFT->data[i]) * crealf(waveFFT->data[i])
+ cimagf(waveFFT->data[i]) * cimagf(waveFFT->data[i]) )/ spec->data->data[i];
}
sigmaSq *= 4.0 * chanDeltaT / (REAL8)nPoints;
/* Now calculate the distance */
distance = sqrt( sigmaSq ) / (REAL8)candlesnr;
/* Clean up! */
XLALDestroyREAL4Vector( waveform );
XLALDestroyCOMPLEX8Vector( waveFFT );
XLALDestroyREAL4FFTPlan( fwdPlan );
return (REAL4)distance;
}
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[] )
{
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[] )
{
/* 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 );
}