/** * \brief Provides an interface between code build from \ref lalinspiral_findchirp and * various simulation packages for injecting chirps into data. * \author Brown, D. A. and Creighton, T. D * * Injects the signals described * in the linked list of \c SimInspiralTable structures \c events * into the data \c chan. The response function \c resp should * contain the response function to use when injecting the signals into the data. */ void LALFindChirpInjectIMR ( LALStatus *status, REAL4TimeSeries *chan, SimInspiralTable *events, SimRingdownTable *ringdownevents, COMPLEX8FrequencySeries *resp, INT4 injectSignalType ) { UINT4 k; DetectorResponse detector; SimInspiralTable *thisEvent = NULL; SimRingdownTable *thisRingdownEvent = NULL; PPNParamStruc ppnParams; CoherentGW waveform, *wfm; INT8 waveformStartTime; REAL4TimeSeries signalvec; COMPLEX8Vector *unity = NULL; CHAR warnMsg[512]; #if 0 UINT4 n; UINT4 i; #endif INITSTATUS(status); ATTATCHSTATUSPTR( status ); ASSERT( chan, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); ASSERT( chan->data, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); ASSERT( chan->data->data, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); ASSERT( events, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); ASSERT( resp, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); ASSERT( resp->data, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); ASSERT( resp->data->data, status, FINDCHIRPH_ENULL, FINDCHIRPH_MSGENULL ); /* * * set up structures and parameters needed * */ /* fixed waveform injection parameters */ memset( &ppnParams, 0, sizeof(PPNParamStruc) ); ppnParams.deltaT = chan->deltaT; ppnParams.lengthIn = 0; ppnParams.ppn = NULL; /* * * compute the transfer function from the given response function * */ /* allocate memory and copy the parameters describing the freq series */ memset( &detector, 0, sizeof( DetectorResponse ) ); detector.transfer = (COMPLEX8FrequencySeries *) LALCalloc( 1, sizeof(COMPLEX8FrequencySeries) ); if ( ! detector.transfer ) { ABORT( status, FINDCHIRPH_EALOC, FINDCHIRPH_MSGEALOC ); } memcpy( &(detector.transfer->epoch), &(resp->epoch), sizeof(LIGOTimeGPS) ); detector.transfer->f0 = resp->f0; detector.transfer->deltaF = resp->deltaF; detector.site = (LALDetector *) LALMalloc( sizeof(LALDetector) ); /* set the detector site */ switch ( chan->name[0] ) { case 'H': *(detector.site) = lalCachedDetectors[LALDetectorIndexLHODIFF]; LALWarning( status, "computing waveform for Hanford." ); break; case 'L': *(detector.site) = lalCachedDetectors[LALDetectorIndexLLODIFF]; LALWarning( status, "computing waveform for Livingston." ); break; case 'G': *(detector.site) = lalCachedDetectors[LALDetectorIndexGEO600DIFF]; LALWarning( status, "computing waveform for GEO600." ); break; case 'T': *(detector.site) = lalCachedDetectors[LALDetectorIndexTAMA300DIFF]; LALWarning( status, "computing waveform for TAMA300." ); break; case 'V': *(detector.site) = lalCachedDetectors[LALDetectorIndexVIRGODIFF]; LALWarning( status, "computing waveform for Virgo." ); break; default: LALFree( detector.site ); detector.site = NULL; LALWarning( status, "Unknown detector site, computing plus mode " "waveform with no time delay" ); break; } /* set up units for the transfer function */ if (XLALUnitDivide( &(detector.transfer->sampleUnits), &lalADCCountUnit, &lalStrainUnit ) == NULL) { ABORTXLAL(status); } /* invert the response function to get the transfer function */ LALCCreateVector( status->statusPtr, &( detector.transfer->data ), resp->data->length ); CHECKSTATUSPTR( status ); LALCCreateVector( status->statusPtr, &unity, resp->data->length ); CHECKSTATUSPTR( status ); for ( k = 0; k < resp->data->length; ++k ) { unity->data[k] = 1.0; } LALCCVectorDivide( status->statusPtr, detector.transfer->data, unity, resp->data ); CHECKSTATUSPTR( status ); LALCDestroyVector( status->statusPtr, &unity ); CHECKSTATUSPTR( status ); thisRingdownEvent = ringdownevents; /* * * loop over the signals and inject them into the time series * */ for ( thisEvent = events; thisEvent; thisEvent = thisEvent->next) { /* * * generate waveform and inject it into the data * */ /* clear the waveform structure */ memset( &waveform, 0, sizeof(CoherentGW) ); LALGenerateInspiral(status->statusPtr, &waveform, thisEvent, &ppnParams); CHECKSTATUSPTR( status ); /* add the ringdown */ wfm = XLALGenerateInspRing( &waveform, thisEvent, thisRingdownEvent, injectSignalType ); if ( !wfm ) { fprintf( stderr, "Failed to generate the waveform \n" ); if (xlalErrno == XLAL_EFAILED) { fprintf( stderr, "Too much merger\n"); XLALDestroyREAL4TimeSeries( chan ); xlalErrno = XLAL_SUCCESS; return; } else exit ( 1 ); } waveform = *wfm; LALInfo( status, ppnParams.termDescription ); if ( thisEvent->geocent_end_time.gpsSeconds ) { /* get the gps start time of the signal to inject */ waveformStartTime = XLALGPSToINT8NS( &(thisEvent->geocent_end_time) ); waveformStartTime -= (INT8) ( 1000000000.0 * ppnParams.tc ); } else { LALInfo( status, "Waveform start time is zero: injecting waveform " "into center of data segment" ); /* center the waveform in the data segment */ waveformStartTime = XLALGPSToINT8NS( &(chan->epoch) ); waveformStartTime += (INT8) ( 1000000000.0 * ((REAL8) (chan->data->length - ppnParams.length) / 2.0) * chan->deltaT ); } snprintf( warnMsg, sizeof(warnMsg)/sizeof(*warnMsg), "Injected waveform timing:\n" "thisEvent->geocent_end_time.gpsSeconds = %d\n" "thisEvent->geocent_end_time.gpsNanoSeconds = %d\n" "ppnParams.tc = %e\n" "waveformStartTime = %" LAL_INT8_FORMAT "\n", thisEvent->geocent_end_time.gpsSeconds, thisEvent->geocent_end_time.gpsNanoSeconds, ppnParams.tc, waveformStartTime ); LALInfo( status, warnMsg ); /* clear the signal structure */ memset( &signalvec, 0, sizeof(REAL4TimeSeries) ); /* 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) ); /* set the start time of the signal vector to the start time of the chan */ signalvec.epoch = chan->epoch; /* set the parameters for the signal time series */ signalvec.deltaT = chan->deltaT; if ( ( signalvec.f0 = chan->f0 ) != 0 ) { ABORT( status, FINDCHIRPH_EHETR, FINDCHIRPH_MSGEHETR ); } signalvec.sampleUnits = lalADCCountUnit; /* simulate the detectors response to the inspiral */ LALSCreateVector( status->statusPtr, &(signalvec.data), chan->data->length ); CHECKSTATUSPTR( status ); LALSimulateCoherentGW( status->statusPtr, &signalvec, &waveform, &detector ); CHECKSTATUSPTR( status ); /* *****************************************************************************/ #if 0 FILE *fp; char fname[512]; UINT4 jj, kplus, kcross; snprintf( fname, sizeof(fname) / sizeof(*fname), "waveform-%d-%d-%s.txt", thisEvent->geocent_end_time.gpsSeconds, thisEvent->geocent_end_time.gpsNanoSeconds, thisEvent->waveform ); fp = fopen( fname, "w" ); for( jj = 0, kplus = 0, kcross = 1; jj < waveform.phi->data->length; ++jj, kplus += 2, kcross +=2 ) { fprintf(fp, "%d %e %e %le %e\n", jj, waveform.a->data->data[kplus], waveform.a->data->data[kcross], waveform.phi->data->data[jj], waveform.f->data->data[jj]); } fclose( fp ); #endif /* ********************************************************************************/ #if 0 FILE *fp; char fname[512]; UINT4 jj; snprintf( fname, sizeof(fname) / sizeof(*fname), "waveform-%d-%d-%s.txt", thisEvent->geocent_end_time.gpsSeconds, thisEvent->geocent_end_time.gpsNanoSeconds, thisEvent->waveform ); fp = fopen( fname, "w" ); for( jj = 0; jj < signalvec.data->length; ++jj ) { fprintf(fp, "%d %e %e \n", jj, signalvec.data->data[jj]); } fclose( fp ); #endif /* ********************************************************************************/ /* inject the signal into the data channel */ LALSSInjectTimeSeries( status->statusPtr, chan, &signalvec ); CHECKSTATUSPTR( status ); /* allocate and go to next SimRingdownTable */ if( thisEvent->next ) thisRingdownEvent = thisRingdownEvent->next = (SimRingdownTable *) calloc( 1, sizeof(SimRingdownTable) ); else thisRingdownEvent->next = NULL; /* destroy the signal */ LALSDestroyVector( status->statusPtr, &(signalvec.data) ); CHECKSTATUSPTR( status ); LALSDestroyVectorSequence( status->statusPtr, &(waveform.a->data) ); CHECKSTATUSPTR( status ); LALSDestroyVector( status->statusPtr, &(waveform.f->data) ); CHECKSTATUSPTR( status ); LALDDestroyVector( status->statusPtr, &(waveform.phi->data) ); CHECKSTATUSPTR( status ); if ( waveform.shift ) { LALSDestroyVector( status->statusPtr, &(waveform.shift->data) ); CHECKSTATUSPTR( status ); } LALFree( waveform.a ); LALFree( waveform.f ); LALFree( waveform.phi ); if ( waveform.shift ) { LALFree( waveform.shift ); } } LALCDestroyVector( status->statusPtr, &( detector.transfer->data ) ); CHECKSTATUSPTR( status ); if ( detector.site ) LALFree( detector.site ); LALFree( detector.transfer ); DETATCHSTATUSPTR( status ); RETURN( status ); }
void LALRingInjectSignals( LALStatus *stat, REAL4TimeSeries *series, SimRingdownTable *injections, COMPLEX8FrequencySeries *resp, INT4 calType ) { UINT4 k; INT4 injStartTime; INT4 injStopTime; DetectorResponse detector; COMPLEX8Vector *unity = NULL; CoherentGW waveform; RingParamStruc ringParam; REAL4TimeSeries signalvec; SimRingdownTable *simRingdown=NULL; LALDetector *tmpDetector=NULL /*,*nullDetector=NULL*/; COMPLEX8FrequencySeries *transfer = NULL; INITSTATUS(stat); ATTATCHSTATUSPTR( stat ); /* set up start and end of injection zone TODO: fix this hardwired 10 */ injStartTime = series->epoch.gpsSeconds - 10; injStopTime = series->epoch.gpsSeconds + 10 + (INT4)(series->data->length * series->deltaT); /* *compute the transfer function */ /* allocate memory and copy the parameters describing the freq series */ memset( &detector, 0, sizeof( DetectorResponse ) ); transfer = (COMPLEX8FrequencySeries *) LALCalloc( 1, sizeof(COMPLEX8FrequencySeries) ); if ( ! transfer ) { ABORT( stat, GENERATERINGH_EMEM, GENERATERINGH_MSGEMEM ); } memcpy( &(transfer->epoch), &(resp->epoch), sizeof(LIGOTimeGPS) ); transfer->f0 = resp->f0; transfer->deltaF = resp->deltaF; tmpDetector = detector.site = (LALDetector *) LALMalloc( sizeof(LALDetector) ); /* set the detector site */ switch ( series->name[0] ) { case 'H': *(detector.site) = lalCachedDetectors[LALDetectorIndexLHODIFF]; LALWarning( stat, "computing waveform for Hanford." ); break; case 'L': *(detector.site) = lalCachedDetectors[LALDetectorIndexLLODIFF]; LALWarning( stat, "computing waveform for Livingston." ); break; default: LALFree( detector.site ); detector.site = NULL; tmpDetector = NULL; LALWarning( stat, "Unknown detector site, computing plus mode " "waveform with no time delay" ); break; } /* set up units for the transfer function */ if (XLALUnitDivide( &(detector.transfer->sampleUnits), &lalADCCountUnit, &lalStrainUnit ) == NULL) { ABORTXLAL(stat); } /* invert the response function to get the transfer function */ LALCCreateVector( stat->statusPtr, &( transfer->data ), resp->data->length ); CHECKSTATUSPTR( stat ); LALCCreateVector( stat->statusPtr, &unity, resp->data->length ); CHECKSTATUSPTR( stat ); for ( k = 0; k < resp->data->length; ++k ) { unity->data[k] = 1.0; } LALCCVectorDivide( stat->statusPtr, transfer->data, unity, resp->data ); CHECKSTATUSPTR( stat ); LALCDestroyVector( stat->statusPtr, &unity ); CHECKSTATUSPTR( stat ); /* Set up a time series to hold signal in ADC counts */ signalvec.deltaT = series->deltaT; if ( ( signalvec.f0 = series->f0 ) != 0 ) { ABORT( stat, GENERATERINGH_EMEM, GENERATERINGH_MSGEMEM ); } signalvec.sampleUnits = lalADCCountUnit; signalvec.data=NULL; LALSCreateVector( stat->statusPtr, &(signalvec.data), series->data->length ); CHECKSTATUSPTR( stat ); /* loop over list of waveforms and inject into data stream */ simRingdown = injections; while ( simRingdown ) { /* only do the work if the ring is in injection zone */ if( (injStartTime - simRingdown->geocent_start_time.gpsSeconds) * (injStopTime - simRingdown->geocent_start_time.gpsSeconds) > 0 ) { simRingdown = simRingdown->next; continue; } /* set the ring params */ ringParam.deltaT = series->deltaT; if( !( strcmp( simRingdown->coordinates, "HORIZON" ) ) ) { ringParam.system = COORDINATESYSTEM_HORIZON; } else if ( !( strcmp( simRingdown->coordinates, "ZENITH" ) ) ) { /* set coordinate system for completeness */ ringParam.system = COORDINATESYSTEM_EQUATORIAL; detector.site = NULL; } else if ( !( strcmp( simRingdown->coordinates, "GEOGRAPHIC" ) ) ) { ringParam.system = COORDINATESYSTEM_GEOGRAPHIC; } else if ( !( strcmp( simRingdown->coordinates, "EQUATORIAL" ) ) ) { ringParam.system = COORDINATESYSTEM_EQUATORIAL; } else if ( !( strcmp( simRingdown->coordinates, "ECLIPTIC" ) ) ) { ringParam.system = COORDINATESYSTEM_ECLIPTIC; } else if ( !( strcmp( simRingdown->coordinates, "GALACTIC" ) ) ) { ringParam.system = COORDINATESYSTEM_GALACTIC; } else ringParam.system = COORDINATESYSTEM_EQUATORIAL; /* generate the ring */ memset( &waveform, 0, sizeof(CoherentGW) ); LALGenerateRing( stat->statusPtr, &waveform, series, simRingdown, &ringParam ); CHECKSTATUSPTR( stat ); /* print the waveform to a file */ if ( 0 ) { FILE *fp; char fname[512]; UINT4 jj, kplus, kcross; snprintf( fname, sizeof(fname) / sizeof(*fname), "waveform-%d-%d-%s.txt", simRingdown->geocent_start_time.gpsSeconds, simRingdown->geocent_start_time.gpsNanoSeconds, simRingdown->waveform ); fp = fopen( fname, "w" ); for( jj = 0, kplus = 0, kcross = 1; jj < waveform.phi->data->length; ++jj, kplus += 2, kcross +=2 ) { fprintf(fp, "%d %e %e %le %e\n", jj, waveform.a->data->data[kplus], waveform.a->data->data[kcross], waveform.phi->data->data[jj], waveform.f->data->data[jj]); } fclose( fp ); } /* end */ #if 0 fprintf( stderr, "a->epoch->gpsSeconds = %d\na->epoch->gpsNanoSeconds = %d\n", waveform.a->epoch.gpsSeconds, waveform.a->epoch.gpsNanoSeconds ); fprintf( stderr, "phi->epoch->gpsSeconds = %d\nphi->epoch->gpsNanoSeconds = %d\n", waveform.phi->epoch.gpsSeconds, waveform.phi->epoch.gpsNanoSeconds ); fprintf( stderr, "f->epoch->gpsSeconds = %d\nf->epoch->gpsNanoSeconds = %d\n", waveform.f->epoch.gpsSeconds, waveform.f->epoch.gpsNanoSeconds ); #endif /* must set the epoch of signal since it's used by coherent GW */ signalvec.epoch = series->epoch; memset( signalvec.data->data, 0, signalvec.data->length * sizeof(REAL4) ); /* decide which way to calibrate the data; defaul to old way */ if( calType ) detector.transfer=NULL; else detector.transfer=transfer; /* convert this into an ADC signal */ LALSimulateCoherentGW( stat->statusPtr, &signalvec, &waveform, &detector ); CHECKSTATUSPTR( stat ); /* print the waveform to a file */ if ( 0 ) { FILE *fp; char fname[512]; UINT4 jj; snprintf( fname, sizeof(fname) / sizeof(*fname), "signal-%d-%d-%s.txt", simRingdown->geocent_start_time.gpsSeconds, simRingdown->geocent_start_time.gpsNanoSeconds, simRingdown->waveform ); fp = fopen( fname, "w" ); for( jj = 0; jj < signalvec.data->length; ++jj ) { fprintf( fp, "%d %le\n", jj, signalvec.data->data[jj] ); } fclose( fp ); } /* end */ #if 0 fprintf( stderr, "series.epoch->gpsSeconds = %d\nseries.epoch->gpsNanoSeconds = %d\n", series->epoch.gpsSeconds, series->epoch.gpsNanoSeconds ); fprintf( stderr, "signalvec->epoch->gpsSeconds = %d\nsignalvec->epoch->gpsNanoSeconds = %d\n", signalvec.epoch.gpsSeconds, signalvec.epoch.gpsNanoSeconds ); #endif /* if calibration using RespFilt */ if( calType == 1 ) XLALRespFilt(&signalvec, transfer); /* inject the signal into the data channel */ LALSSInjectTimeSeries( stat->statusPtr, series, &signalvec ); CHECKSTATUSPTR( stat ); /* free memory in coherent GW structure. TODO: fix this */ LALSDestroyVectorSequence( stat->statusPtr, &( waveform.a->data ) ); CHECKSTATUSPTR( stat ); LALSDestroyVector( stat->statusPtr, &( waveform.f->data ) ); CHECKSTATUSPTR( stat ); LALDDestroyVector( stat->statusPtr, &( waveform.phi->data ) ); CHECKSTATUSPTR( stat ); LALFree( waveform.a ); waveform.a = NULL; LALFree( waveform.f ); waveform.f = NULL; LALFree( waveform.phi ); waveform.phi = NULL; /* reset the detector site information in case it changed */ detector.site = tmpDetector; /* move on to next one */ simRingdown = simRingdown->next; } /* destroy the signal */ LALSDestroyVector( stat->statusPtr, &(signalvec.data) ); CHECKSTATUSPTR( stat ); LALCDestroyVector( stat->statusPtr, &( transfer->data ) ); CHECKSTATUSPTR( stat ); if ( detector.site ) LALFree( detector.site ); LALFree( transfer ); DETATCHSTATUSPTR( stat ); RETURN( stat ); }
int main(int argc, char **argv) { /* Command-line parsing variables. */ int arg; /* command-line argument counter */ static LALStatus stat; /* status structure */ CHAR *sourcefile = NULL; /* name of sourcefile */ CHAR *respfile = NULL; /* name of respfile */ CHAR *infile = NULL; /* name of infile */ CHAR *outfile = NULL; /* name of outfile */ INT4 seed = 0; /* random number seed */ INT4 sec = SEC; /* ouput epoch.gpsSeconds */ INT4 nsec = NSEC; /* ouput epoch.gpsNanoSeconds */ INT4 npt = NPT; /* number of output points */ REAL8 dt = DT; /* output sampling interval */ REAL4 sigma = SIGMA; /* noise amplitude */ /* File reading variables. */ FILE *fp = NULL; /* generic file pointer */ BOOLEAN ok = 1; /* whether input format is correct */ UINT4 i; /* generic index over file lines */ INT8 epoch; /* epoch stored as an INT8 */ /* Other global variables. */ RandomParams *params = NULL; /* parameters of pseudorandom sequence */ DetectorResponse detector; /* the detector in question */ INT2TimeSeries output; /* detector ACD output */ /******************************************************************* * PARSE ARGUMENTS (arg stores the current position) * *******************************************************************/ /* Exit gracefully if no arguments were given. if ( argc <= 1 ) { INFO( "No testing done." ); return 0; } */ arg = 1; while ( arg < argc ) { /* Parse source file option. */ if ( !strcmp( argv[arg], "-s" ) ) { if ( argc > arg + 1 ) { arg++; sourcefile = argv[arg++]; }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Parse response file option. */ else if ( !strcmp( argv[arg], "-r" ) ) { if ( argc > arg + 1 ) { arg++; respfile = argv[arg++]; }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Parse input file option. */ else if ( !strcmp( argv[arg], "-i" ) ) { if ( argc > arg + 1 ) { arg++; infile = argv[arg++]; }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Parse noise output option. */ else if ( !strcmp( argv[arg], "-n" ) ) { if ( argc > arg + 5 ) { arg++; sec = atoi( argv[arg++] ); nsec = atoi( argv[arg++] ); npt = atoi( argv[arg++] ); dt = atof( argv[arg++] ); sigma = atof( argv[arg++] ); }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Parse output file option. */ else if ( !strcmp( argv[arg], "-o" ) ) { if ( argc > arg + 1 ) { arg++; outfile = argv[arg++]; }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Parse debug level option. */ else if ( !strcmp( argv[arg], "-d" ) ) { if ( argc > arg + 1 ) { arg++; }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Parse random seed option. */ else if ( !strcmp( argv[arg], "-e" ) ) { if ( argc > arg + 1 ) { arg++; seed = atoi( argv[arg++] ); }else{ ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* Check for unrecognized options. */ else if ( argv[arg][0] == '-' ) { ERROR( BASICINJECTTESTC_EARG, BASICINJECTTESTC_MSGEARG, 0 ); LALPrintError( USAGE, *argv ); return BASICINJECTTESTC_EARG; } } /* End of argument parsing loop. */ /* Check for redundant or bad argument values. */ CHECKVAL( npt, 0, 2147483647 ); CHECKVAL( dt, 0, LAL_REAL4_MAX ); /******************************************************************* * SETUP * *******************************************************************/ /* Set up output, detector, and random parameter structures. */ output.data = NULL; detector.transfer = (COMPLEX8FrequencySeries *) LALMalloc( sizeof(COMPLEX8FrequencySeries) ); if ( !(detector.transfer) ) { ERROR( BASICINJECTTESTC_EMEM, BASICINJECTTESTC_MSGEMEM, 0 ); return BASICINJECTTESTC_EMEM; } detector.transfer->data = NULL; detector.site = NULL; SUB( LALCreateRandomParams( &stat, ¶ms, seed ), &stat ); /* Set up units. */ output.sampleUnits = lalADCCountUnit; if (XLALUnitDivide( &(detector.transfer->sampleUnits), &lalADCCountUnit, &lalStrainUnit ) == NULL) { return LAL_EXLAL; } /* Read response function. */ if ( respfile ) { REAL4VectorSequence *resp = NULL; /* response as vector sequence */ COMPLEX8Vector *response = NULL; /* response as complex vector */ COMPLEX8Vector *unity = NULL; /* vector of complex 1's */ if ( ( fp = fopen( respfile, "r" ) ) == NULL ) { ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE, respfile ); return BASICINJECTTESTC_EFILE; } /* Read header. */ ok &= ( fscanf( fp, "# epoch = %" LAL_INT8_FORMAT "\n", &epoch ) == 1 ); I8ToLIGOTimeGPS( &( detector.transfer->epoch ), epoch ); ok &= ( fscanf( fp, "# f0 = %lf\n", &( detector.transfer->f0 ) ) == 1 ); ok &= ( fscanf( fp, "# deltaF = %lf\n", &( detector.transfer->deltaF ) ) == 1 ); if ( !ok ) { ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT, respfile ); return BASICINJECTTESTC_EINPUT; } /* Read and convert body to a COMPLEX8Vector. */ SUB( LALSReadVectorSequence( &stat, &resp, fp ), &stat ); fclose( fp ); if ( resp->vectorLength != 2 ) { ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT, respfile ); return BASICINJECTTESTC_EINPUT; } SUB( LALCCreateVector( &stat, &response, resp->length ), &stat ); memcpy( response->data, resp->data, 2*resp->length*sizeof(REAL4) ); SUB( LALSDestroyVectorSequence( &stat, &resp ), &stat ); /* Convert response function to a transfer function. */ SUB( LALCCreateVector( &stat, &unity, response->length ), &stat ); for ( i = 0; i < response->length; i++ ) { unity->data[i] = 1.0; } SUB( LALCCreateVector( &stat, &( detector.transfer->data ), response->length ), &stat ); SUB( LALCCVectorDivide( &stat, detector.transfer->data, unity, response ), &stat ); SUB( LALCDestroyVector( &stat, &response ), &stat ); SUB( LALCDestroyVector( &stat, &unity ), &stat ); } /* No response file, so generate a unit response. */ else { I8ToLIGOTimeGPS( &( detector.transfer->epoch ), EPOCH ); detector.transfer->f0 = 0.0; detector.transfer->deltaF = 1.5*FSTOP; SUB( LALCCreateVector( &stat, &( detector.transfer->data ), 2 ), &stat ); detector.transfer->data->data[0] = 1.0; detector.transfer->data->data[1] = 1.0; } /* Read input data. */ if ( infile ) { REAL4VectorSequence *input = NULL; /* input as vector sequence */ if ( ( fp = fopen( infile, "r" ) ) == NULL ) { ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE, infile ); return BASICINJECTTESTC_EFILE; } /* Read header. */ ok &= ( fscanf( fp, "# epoch = %" LAL_INT8_FORMAT "\n", &epoch ) == 1 ); I8ToLIGOTimeGPS( &( output.epoch ), epoch ); ok &= ( fscanf( fp, "# deltaT = %lf\n", &( output.deltaT ) ) == 1 ); if ( !ok ) { ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT, infile ); return BASICINJECTTESTC_EINPUT; } /* Read and convert body. */ SUB( LALSReadVectorSequence( &stat, &input, fp ), &stat ); fclose( fp ); if ( input->vectorLength != 1 ) { ERROR( BASICINJECTTESTC_EINPUT, BASICINJECTTESTC_MSGEINPUT, infile ); return BASICINJECTTESTC_EINPUT; } SUB( LALI2CreateVector( &stat, &( output.data ), input->length ), &stat ); for ( i = 0; i < input->length; i++ ) output.data->data[i] = (INT2)( input->data[i] ); SUB( LALSDestroyVectorSequence( &stat, &input ), &stat ); } /* No input file, so generate one randomly. */ else { output.epoch.gpsSeconds = sec; output.epoch.gpsNanoSeconds = nsec; output.deltaT = dt; SUB( LALI2CreateVector( &stat, &( output.data ), npt ), &stat ); if ( sigma == 0 ) { memset( output.data->data, 0, npt*sizeof(INT2) ); } else { REAL4Vector *deviates = NULL; /* unit Gaussian deviates */ SUB( LALSCreateVector( &stat, &deviates, npt ), &stat ); SUB( LALNormalDeviates( &stat, deviates, params ), &stat ); for ( i = 0; i < (UINT4)( npt ); i++ ) output.data->data[i] = (INT2) floor( sigma*deviates->data[i] + 0.5 ); SUB( LALSDestroyVector( &stat, &deviates ), &stat ); } } /******************************************************************* * INJECTION * *******************************************************************/ /* Open sourcefile. */ if ( sourcefile ) { if ( ( fp = fopen( sourcefile, "r" ) ) == NULL ) { ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE, sourcefile ); return BASICINJECTTESTC_EFILE; } } /* For each line in the sourcefile... */ while ( ok ) { PPNParamStruc ppnParams; /* wave generation parameters */ REAL4 m1, m2, dist, inc, phic; /* unconverted parameters */ CoherentGW waveform; /* amplitude and phase structure */ REAL4TimeSeries signalvec; /* GW signal */ REAL8 time; /* length of GW signal */ CHAR timeCode; /* code for signal time alignment */ CHAR message[MSGLEN]; /* warning/info messages */ /* Read and convert input line. */ if ( sourcefile ) { ok &= ( fscanf( fp, "%c %" LAL_INT8_FORMAT " %f %f %f %f %f\n", &timeCode, &epoch, &m1, &m2, &dist, &inc, &phic ) == 7 ); ppnParams.mTot = m1 + m2; ppnParams.eta = m1*m2/( ppnParams.mTot*ppnParams.mTot ); ppnParams.d = dist*LAL_PC_SI*1000.0; ppnParams.inc = inc*LAL_PI/180.0; ppnParams.phi = phic*LAL_PI/180.0; } else { timeCode = 'i'; ppnParams.mTot = M1 + M2; ppnParams.eta = M1*M2/( ppnParams.mTot*ppnParams.mTot ); ppnParams.d = DIST; ppnParams.inc = INC; ppnParams.phi = PHIC; epoch = EPOCH; } if ( ok ) { /* Set up other parameter structures. */ ppnParams.epoch.gpsSeconds = ppnParams.epoch.gpsNanoSeconds = 0; ppnParams.position.latitude = ppnParams.position.longitude = 0.0; ppnParams.position.system = COORDINATESYSTEM_EQUATORIAL; ppnParams.psi = 0.0; ppnParams.fStartIn = FSTART; ppnParams.fStopIn = FSTOP; ppnParams.lengthIn = 0; ppnParams.ppn = NULL; ppnParams.deltaT = DELTAT; memset( &waveform, 0, sizeof(CoherentGW) ); /* Generate waveform at zero epoch. */ SUB( LALGeneratePPNInspiral( &stat, &waveform, &ppnParams ), &stat ); snprintf( message, MSGLEN, "%d: %s", ppnParams.termCode, ppnParams.termDescription ); INFO( message ); if ( ppnParams.dfdt > 2.0 ) { snprintf( message, MSGLEN, "Waveform sampling interval is too large:\n" "\tmaximum df*dt = %f", ppnParams.dfdt ); WARNING( message ); } /* Compute epoch for waveform. */ time = waveform.a->data->length*DELTAT; if ( timeCode == 'f' ) epoch -= (INT8)( 1000000000.0*time ); else if ( timeCode == 'c' ) epoch -= (INT8)( 1000000000.0*ppnParams.tc ); I8ToLIGOTimeGPS( &( waveform.a->epoch ), epoch ); waveform.f->epoch = waveform.phi->epoch = waveform.a->epoch; /* Generate and inject signal. */ signalvec.epoch = waveform.a->epoch; signalvec.epoch.gpsSeconds -= 1; signalvec.deltaT = output.deltaT/4.0; signalvec.f0 = 0; signalvec.data = NULL; time = ( time + 2.0 )/signalvec.deltaT; SUB( LALSCreateVector( &stat, &( signalvec.data ), (UINT4)time ), &stat ); SUB( LALSimulateCoherentGW( &stat, &signalvec, &waveform, &detector ), &stat ); SUB( LALSI2InjectTimeSeries( &stat, &output, &signalvec, params ), &stat ); SUB( LALSDestroyVectorSequence( &stat, &( waveform.a->data ) ), &stat ); SUB( LALSDestroyVector( &stat, &( waveform.f->data ) ), &stat ); SUB( LALDDestroyVector( &stat, &( waveform.phi->data ) ), &stat ); LALFree( waveform.a ); LALFree( waveform.f ); LALFree( waveform.phi ); SUB( LALSDestroyVector( &stat, &( signalvec.data ) ), &stat ); } /* If there is no source file, inject only one source. */ if ( !sourcefile ) ok = 0; } /* Input file is exhausted (or has a badly-formatted line ). */ if ( sourcefile ) fclose( fp ); /******************************************************************* * CLEANUP * *******************************************************************/ /* Print output file. */ if ( outfile ) { if ( ( fp = fopen( outfile, "w" ) ) == NULL ) { ERROR( BASICINJECTTESTC_EFILE, BASICINJECTTESTC_MSGEFILE, outfile ); return BASICINJECTTESTC_EFILE; } epoch = 1000000000LL*(INT8)( output.epoch.gpsSeconds ); epoch += (INT8)( output.epoch.gpsNanoSeconds ); fprintf( fp, "# epoch = %" LAL_INT8_FORMAT "\n", epoch ); fprintf( fp, "# deltaT = %23.16e\n", output.deltaT ); for ( i = 0; i < output.data->length; i++ ) fprintf( fp, "%8.1f\n", (REAL4)( output.data->data[i] ) ); fclose( fp ); } /* Destroy remaining memory. */ SUB( LALDestroyRandomParams( &stat, ¶ms ), &stat ); SUB( LALI2DestroyVector( &stat, &( output.data ) ), &stat ); SUB( LALCDestroyVector( &stat, &( detector.transfer->data ) ), &stat ); LALFree( detector.transfer ); /* Done! */ LALCheckMemoryLeaks(); INFO( BASICINJECTTESTC_MSGENORM ); return BASICINJECTTESTC_ENORM; }
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 ); }