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 arg_parse(int argc, char **argv, void **argtable) { struct arg_hdr **table = (struct arg_hdr **)argtable; struct arg_end *endtable; int endindex; char **argvcopy = NULL; /*printf("arg_parse(%d,%p,%p)\n",argc,argv,argtable);*/ /* reset any argtable data from previous invocations */ arg_reset(argtable); /* locate the first end-of-table marker within the array */ endindex = arg_endindex(table); endtable = (struct arg_end*)table[endindex]; /* Special case of argc==0. This can occur on Texas Instruments DSP. */ /* Failure to trap this case results in an unwanted NULL result from */ /* the malloc for argvcopy (next code block). */ if (argc==0) { /* We must still perform post-parse checks despite the absence of command line arguments */ arg_parse_check(table,endtable); /* Now we are finished */ return endtable->count; } argvcopy = malloc(sizeof(char *) * argc); if (argvcopy) { int i; /* Fill in the local copy of argv[]. We need a local copy because getopt rearranges argv[] which adversely affects susbsequent parsing attempts. */ for (i=0; i<argc; i++) argvcopy[i] = argv[i]; /* parse the command line (local copy) for tagged options */ arg_parse_tagged(argc,argvcopy,table,endtable); /* parse the command line (local copy) for untagged options */ arg_parse_untagged(argc,argvcopy,table,endtable); /* if no errors so far then perform post-parse checks otherwise dont bother */ if (endtable->count==0) arg_parse_check(table,endtable); /* release the local copt of argv[] */ free(argvcopy); } else { /* memory alloc failed */ arg_register_error(endtable,endtable,ARG_EMALLOC,NULL); } return endtable->count; }