static void destroyCoherentGW( CoherentGW *waveform )
{
if ( waveform->h )
{
XLALDestroyREAL4VectorSequence( waveform->h->data );
LALFree( waveform->a );
}
if ( waveform->a )
{
XLALDestroyREAL4VectorSequence( waveform->a->data );
LALFree( waveform->a );
}
if ( waveform->phi )
{
XLALDestroyREAL8Vector( waveform->phi->data );
LALFree( waveform->phi );
}
if ( waveform->f )
{
XLALDestroyREAL4Vector( waveform->f->data );
LALFree( waveform->f );
}
if ( waveform->shift )
{
XLALDestroyREAL4Vector( waveform->shift->data );
LALFree( waveform->shift );
}
return;
}
void XLALSQTPNDestroyCoherentGW(CoherentGW *wave) {
//static const char *func = "LALSQTPNDestroyCoherentGW";
if (wave->a) {
if (wave->a->data) {
XLALDestroyREAL4VectorSequence(wave->a->data);
}
XLALFree(wave->a);
}
if (wave->f) {
if (wave->f->data) {
XLALDestroyREAL4Vector(wave->f->data);
}
XLALFree(wave->f);
}
if (wave->phi) {
if (wave->phi->data) {
XLALDestroyREAL8Vector(wave->phi->data);
}
XLALFree(wave->phi);
}
if (wave->shift) {
if (wave->shift->data) {
XLALDestroyREAL4Vector(wave->shift->data);
}
XLALFree(wave->shift);
}
}
/** Main driver funtion for doing Numerical Relativity Injections */
void LALDriveNRInject( LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeSeries *injData, /**< The time series to inject into */
SimInspiralTable *injections, /**< The list of injections to perform */
NumRelInjectParams *params /**< Parameters */
)
{
REAL4TimeVectorSeries *sumStrain = NULL;
SimInspiralTable *thisInj = NULL; /* current injection */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* loop over injections */
for ( thisInj = injections; thisInj; thisInj = thisInj->next )
{
TRY( LALAddStrainModes(status->statusPtr, &sumStrain, params->nrCatalog,
params->modeLlo, params->modeLhi, thisInj), status);
TRY( LALInjectStrainGW( status->statusPtr, injData, sumStrain, thisInj, params->ifo, params->dynRange), status);
XLALDestroyREAL4VectorSequence ( sumStrain->data );
LALFree( sumStrain );
sumStrain = NULL;
} /* end loop over injections */
DETATCHSTATUSPTR(status);
RETURN(status);
}
/**
* Main function for injecting numetrical relativity waveforms.
* Takes as input a list of injections, and adds h(t) to a given
* timeseries for a specified ifo and a dynamic range factor.
*/
void InjectNumRelWaveforms (LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeSeries *chan, /**< [out] the output time series */
SimInspiralTable *injections, /**< [in] list of injections */
CHAR ifo[3], /**< [in] 2 char code for interferometer */
REAL8 dynRange, /**< [in] dynamic range factor for scaling time series */
REAL8 freqLowCutoff, /**< [in] Lower cutoff frequency */
REAL8 snrLow, /**< [in] lower cutoff value of snr */
REAL8 snrHigh, /**< TO BE DOCUMENTED */
CHAR *fname) /**< [in] higher cutoff value of snr */
{
REAL4TimeVectorSeries *tempStrain=NULL;
SimInspiralTable *thisInj = NULL;
REAL8 startFreq, startFreqHz, massTotal;
REAL8 thisSNR;
SimInspiralTable *simTableOut=NULL;
SimInspiralTable *thisInjOut=NULL;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
ASSERT( chan, status, INSPIRALH_ENULL, INSPIRALH_MSGENULL );
ASSERT( ifo, status, INSPIRALH_ENULL, INSPIRALH_MSGENULL );
/* loop over injections */
for ( thisInj = injections; thisInj; thisInj = thisInj->next )
{
startFreq = start_freq_from_frame_url(thisInj->numrel_data);
massTotal = (thisInj->mass1 + thisInj->mass2) * LAL_MTSUN_SI;
startFreqHz = startFreq / ( LAL_TWOPI * massTotal);
if (startFreqHz < freqLowCutoff)
{
TRY( AddNumRelStrainModes( status->statusPtr, &tempStrain, thisInj),
status);
thisSNR = calculate_ligo_snr_from_strain( tempStrain, thisInj, ifo);
/* set channel name */
snprintf( chan->name, LALNameLength * sizeof( CHAR ),
"%s:STRAIN", ifo );
if ((thisSNR < snrHigh) && (thisSNR > snrLow))
{
/* simTableOut will be null only the first time */
if ( simTableOut == NULL) {
simTableOut = (SimInspiralTable *)LALCalloc( 1, sizeof(SimInspiralTable) );
memcpy(simTableOut, thisInj, sizeof(*thisInj));
simTableOut->next = NULL;
thisInjOut = simTableOut;
}
else {
thisInjOut->next = (SimInspiralTable *)LALCalloc( 1, sizeof(SimInspiralTable) );
memcpy(thisInjOut->next, thisInj, sizeof(*thisInj));
thisInjOut->next->next = NULL;
thisInjOut = thisInjOut->next;
}
TRY( LALInjectStrainGW( status->statusPtr, chan, tempStrain, thisInj,
ifo, dynRange), status);
}
XLALDestroyREAL4VectorSequence ( tempStrain->data);
tempStrain->data = NULL;
LALFree(tempStrain);
tempStrain = NULL;
}
} /* loop over injectionsj */
/* write and free the output simInspiral table */
if ( simTableOut ) {
LIGOLwXMLStream xmlfp;
MetadataTable dummyTable;
dummyTable.simInspiralTable = simTableOut;
/* write the xml table of actual injections */
memset( &xmlfp, 0, sizeof(LIGOLwXMLStream) );
TRY( LALOpenLIGOLwXMLFile( status->statusPtr, &xmlfp, fname ), status );
TRY( LALBeginLIGOLwXMLTable( status->statusPtr, &xmlfp, sim_inspiral_table ),
status );
TRY( LALWriteLIGOLwXMLTable( status->statusPtr, &xmlfp, dummyTable,
sim_inspiral_table ), status );
TRY( LALEndLIGOLwXMLTable ( status->statusPtr, &xmlfp ), status );
TRY( LALCloseLIGOLwXMLFile ( status->statusPtr, &xmlfp ), status );
}
while (simTableOut) {
thisInjOut = simTableOut;
simTableOut = simTableOut->next;
LALFree(thisInjOut);
}
DETATCHSTATUSPTR(status);
RETURN(status);
}
void AddNumRelStrainModes( LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeVectorSeries **outStrain, /**< [out] h+, hx data */
SimInspiralTable *thisinj /**< [in] injection data */)
{
INT4 modeL, modeM, modeLlo, modeLhi;
INT4 len, lenPlus, lenCross, k;
CHAR *channel_name_plus;
CHAR *channel_name_cross;
LALFrStream *frStream = NULL;
LALCache frCache;
LIGOTimeGPS epoch;
REAL4TimeSeries *seriesPlus=NULL;
REAL4TimeSeries *seriesCross=NULL;
REAL8 massMpc;
REAL4TimeVectorSeries *sumStrain=NULL;
REAL4TimeVectorSeries *tempStrain=NULL;
/* NRWaveMetaData thisMetaData; */
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
modeLlo = thisinj->numrel_mode_min;
modeLhi = thisinj->numrel_mode_max;
/* create a frame cache and open the frame stream */
frCache.length = 1;
frCache.list = LALCalloc(1, sizeof(frCache.list[0]));
frCache.list[0].url = thisinj->numrel_data;
frStream = XLALFrStreamCacheOpen( &frCache );
/* the total mass of the binary in Mpc */
massMpc = (thisinj->mass1 + thisinj->mass2) * LAL_MRSUN_SI / ( LAL_PC_SI * 1.0e6);
/* start time of waveform -- set it to something */
epoch.gpsSeconds = 0;
epoch.gpsNanoSeconds = 0;
/* loop over l values */
for ( modeL = modeLlo; modeL <= modeLhi; modeL++ ) {
/* loop over m values */
for ( modeM = -modeL; modeM <= modeL; modeM++ ) {
/* read numrel waveform */
/* first the plus polarization */
channel_name_plus = XLALGetNinjaChannelName("plus", modeL, modeM);
/*get number of data points */
lenPlus = XLALFrStreamGetVectorLength ( channel_name_plus, frStream );
/* now the cross polarization */
channel_name_cross = XLALGetNinjaChannelName("cross", modeL, modeM);
/*get number of data points */
lenCross = XLALFrStreamGetVectorLength ( channel_name_cross, frStream );
/* skip on to next mode if mode doesn't exist */
if ( (lenPlus <= 0) || (lenCross <= 0) || (lenPlus != lenCross) ) {
XLALClearErrno();
LALFree(channel_name_plus);
LALFree(channel_name_cross);
continue;
}
/* note: lenPlus and lenCross must be equal if we got this far*/
/* len = lenPlus; */
len = lenPlus;
/* allocate and read the plus/cross time series */
seriesPlus = XLALCreateREAL4TimeSeries ( channel_name_plus, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(seriesPlus->data->data, 0, seriesPlus->data->length*sizeof(REAL4));
XLALFrStreamGetREAL4TimeSeries ( seriesPlus, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_plus);
seriesCross = XLALCreateREAL4TimeSeries ( channel_name_cross, &epoch, 0, 0, &lalDimensionlessUnit, len);
memset(seriesCross->data->data, 0, seriesCross->data->length*sizeof(REAL4));
XLALFrStreamGetREAL4TimeSeries ( seriesCross, frStream );
XLALFrStreamRewind( frStream );
LALFree(channel_name_cross);
/* allocate memory for tempStrain */
tempStrain = LALCalloc(1, sizeof(*tempStrain));
tempStrain->data = XLALCreateREAL4VectorSequence(2, len);
tempStrain->deltaT = LAL_MTSUN_SI * (thisinj->mass1 + thisinj->mass2) * seriesPlus->deltaT ;
tempStrain->f0 = seriesPlus->f0;
tempStrain->sampleUnits = seriesPlus->sampleUnits;
memset(tempStrain->data->data, 0, tempStrain->data->length * tempStrain->data->vectorLength*sizeof(REAL4));
/* now copy the data and scale amplitude corresponding to distance of 1Mpc*/
for (k = 0; k < len; k++) {
tempStrain->data->data[k] = massMpc * seriesPlus->data->data[k];
tempStrain->data->data[len + k] = massMpc * seriesCross->data->data[k]; }
/* we are done with seriesPlus and Cross for this iteration */
XLALDestroyREAL4TimeSeries (seriesPlus);
XLALDestroyREAL4TimeSeries (seriesCross);
seriesPlus = NULL;
seriesCross = NULL;
/* compute the h+ and hx for given inclination and coalescence phase*/
XLALOrientNRWave( tempStrain, modeL, modeM, thisinj->inclination, thisinj->coa_phase );
if (sumStrain == NULL) {
sumStrain = LALCalloc(1, sizeof(*sumStrain));
sumStrain->data = XLALCreateREAL4VectorSequence(2, tempStrain->data->vectorLength);
sumStrain->deltaT = tempStrain->deltaT;
sumStrain->f0 = tempStrain->f0;
sumStrain->sampleUnits = tempStrain->sampleUnits;
memset(sumStrain->data->data,0.0,2*tempStrain->data->vectorLength*sizeof(REAL4));
sumStrain = XLALSumStrain( sumStrain, tempStrain );
} else {
sumStrain = XLALSumStrain( sumStrain, tempStrain );
}
/* clear memory for strain */
if (tempStrain->data != NULL) {
XLALDestroyREAL4VectorSequence ( tempStrain->data );
LALFree( tempStrain );
tempStrain = NULL;
}
} /* end loop over modeM values */
} /* end loop over modeL values */
XLALFrStreamClose( frStream );
LALFree(frCache.list);
*outStrain = sumStrain;
DETATCHSTATUSPTR(status);
RETURN(status);
}
void
LALTaylorT4WaveformForInjection(
LALStatus *status,
CoherentGW *waveform,
InspiralTemplate *params,
PPNParamStruc *ppnParams
)
{
UINT4 count, i;
REAL8 phiC;
REAL4Vector *a = NULL; /* pointers to generated amplitude data */
REAL4Vector *ff = NULL; /* pointers to generated frequency data */
REAL8Vector *phi = NULL; /* pointer to generated phase data */
InspiralInit paramsInit;
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* Make sure parameter and waveform structures exist. */
ASSERT( params, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL );
ASSERT(waveform, status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL);
ASSERT( !( waveform->a ), status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL );
ASSERT( !( waveform->h ), status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL );
ASSERT( !( waveform->f ), status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL );
ASSERT( !( waveform->phi ), status, LALINSPIRALH_ENULL, LALINSPIRALH_MSGENULL );
params->ampOrder = (LALPNOrder) 0;
XLALPrintInfo( "WARNING: Amp Order has been reset to %d", params->ampOrder);
/* Compute some parameters*/
LALInspiralInit(status->statusPtr, params, ¶msInit);
CHECKSTATUSPTR(status);
if (paramsInit.nbins == 0)
{
XLALPrintError( "Error: Estimated length of injection is zero.\n" );
ABORT( status, LALINSPIRALH_ESIZE, LALINSPIRALH_MSGESIZE );
}
/* Now we can allocate memory and vector for coherentGW structure*/
ff = XLALCreateREAL4Vector( paramsInit.nbins );
a = XLALCreateREAL4Vector( 2*paramsInit.nbins );
phi = XLALCreateREAL8Vector( paramsInit.nbins );
if ( !ff || !a || !phi )
{
if ( ff )
XLALDestroyREAL4Vector( ff );
if ( a )
XLALDestroyREAL4Vector( a );
if ( phi )
XLALDestroyREAL8Vector( phi );
ABORTXLAL( status );
}
/* Call the engine function */
LALTaylorT4WaveformEngine(status->statusPtr, NULL, NULL, a, ff,
phi, &count, params, ¶msInit);
BEGINFAIL( status )
{
XLALDestroyREAL4Vector( ff );
XLALDestroyREAL4Vector( a );
XLALDestroyREAL8Vector( phi );
}
ENDFAIL( status );
/*wrap the phase vector*/
phiC = phi->data[count-1] ;
for (i = 0; i < count; i++)
{
phi->data[i] = phi->data[i] - phiC + ppnParams->phi;
}
/* Allocate the waveform structures. */
if ( ( waveform->a = (REAL4TimeVectorSeries *)
LALCalloc(1, sizeof(REAL4TimeVectorSeries) ) ) == NULL )
{
XLALDestroyREAL4Vector( ff );
XLALDestroyREAL4Vector( a );
XLALDestroyREAL8Vector( phi );
ABORT( status, LALINSPIRALH_EMEM,
LALINSPIRALH_MSGEMEM );
}
if ( ( waveform->f = (REAL4TimeSeries *)
LALCalloc(1, sizeof(REAL4TimeSeries) ) ) == NULL )
{
LALFree( waveform->a ); waveform->a = NULL;
XLALDestroyREAL4Vector( ff );
XLALDestroyREAL4Vector( a );
XLALDestroyREAL8Vector( phi );
ABORT( status, LALINSPIRALH_EMEM,
LALINSPIRALH_MSGEMEM );
}
if ( ( waveform->phi = (REAL8TimeSeries *)
LALCalloc(1, sizeof(REAL8TimeSeries) ) ) == NULL )
{
LALFree( waveform->a ); waveform->a = NULL;
LALFree( waveform->f ); waveform->f = NULL;
XLALDestroyREAL4Vector( ff );
XLALDestroyREAL4Vector( a );
XLALDestroyREAL8Vector( phi );
ABORT( status, LALINSPIRALH_EMEM,
LALINSPIRALH_MSGEMEM );
}
waveform->a->data = XLALCreateREAL4VectorSequence( (UINT4)count, 2 );
waveform->f->data = XLALCreateREAL4Vector( count );
waveform->phi->data = XLALCreateREAL8Vector( count );
if ( !waveform->a->data || !waveform->f->data || !waveform->phi->data )
{
if ( waveform->a->data )
XLALDestroyREAL4VectorSequence( waveform->a->data );
if ( waveform->f->data )
XLALDestroyREAL4Vector( waveform->f->data );
if ( waveform->phi->data )
XLALDestroyREAL8Vector( waveform->phi->data );
LALFree( waveform->a ); waveform->a = NULL;
LALFree( waveform->f ); waveform->f = NULL;
XLALDestroyREAL4Vector( ff );
XLALDestroyREAL4Vector( a );
XLALDestroyREAL8Vector( phi );
ABORTXLAL( status );
}
memcpy(waveform->f->data->data , ff->data, count*(sizeof(REAL4)));
memcpy(waveform->a->data->data , a->data, 2*count*(sizeof(REAL4)));
memcpy(waveform->phi->data->data ,phi->data, count*(sizeof(REAL8)));
waveform->a->deltaT = waveform->f->deltaT = waveform->phi->deltaT
= ppnParams->deltaT;
waveform->a->sampleUnits = lalStrainUnit;
waveform->f->sampleUnits = lalHertzUnit;
waveform->phi->sampleUnits = lalDimensionlessUnit;
waveform->position = ppnParams->position;
waveform->psi = ppnParams->psi;
snprintf( waveform->a->name, LALNameLength, "T4 inspiral amplitude" );
snprintf( waveform->f->name, LALNameLength, "T4 inspiral frequency" );
snprintf( waveform->phi->name, LALNameLength, "T4 inspiral phase" );
/* --- fill some output ---*/
ppnParams->tc = (double)(count-1) / params->tSampling ;
ppnParams->length = count;
ppnParams->dfdt = ((REAL4)(waveform->f->data->data[count-1]
- waveform->f->data->data[count-2])) * ppnParams->deltaT;
ppnParams->fStop = params->fFinal;
ppnParams->termCode = GENERATEPPNINSPIRALH_EFSTOP;
ppnParams->termDescription = GENERATEPPNINSPIRALH_MSGEFSTOP;
ppnParams->fStart = ppnParams->fStartIn;
/* --- free memory --- */
XLALDestroyREAL4Vector( ff );
XLALDestroyREAL4Vector( a );
XLALDestroyREAL8Vector( phi );
DETATCHSTATUSPTR(status);
RETURN (status);
}
/** Put the main functionalities of nr_wave.c together */
void
LALAddStrainModes(
LALStatus *status, /**< pointer to LALStatus structure */
REAL4TimeVectorSeries **outStrain, /**< h+, hx data */
NRWaveCatalog *nrCatalog, /**< NR wave metadata struct */
INT4 modeLlo, /**< contains modeLlo and modeLhi */
INT4 modeLhi, /**< modeLhi */
const SimInspiralTable *thisInj /**< injection */)
{
INT4 modeL, modeM;
REAL4TimeVectorSeries *sumStrain=NULL;
REAL4TimeVectorSeries *tempStrain=NULL;
NRWaveMetaData thisMetaData;
INITSTATUS(status);
ATTATCHSTATUSPTR (status);
/* loop over l values */
for ( modeL = modeLlo; modeL <= modeLhi; modeL++ )
{
/* loop over m values */
for ( modeM = -modeL; modeM <= modeL; modeM++ )
{
/* find nearest matching numrel waveform */
XLALFindNRFile( &thisMetaData, nrCatalog, thisInj, modeL, modeM );
/* read numrel waveform */
TRY( LALReadNRWave( status->statusPtr, &tempStrain, thisInj->mass1 +
thisInj->mass2, thisMetaData.filename ), status );
/* compute the h+ and hx for given inclination and coalescence phase*/
XLALOrientNRWave( tempStrain, thisMetaData.mode[0],
thisMetaData.mode[1], thisInj->inclination, thisInj->coa_phase );
if (sumStrain == NULL) {
sumStrain = LALCalloc(1, sizeof(*sumStrain));
sumStrain->data = XLALCreateREAL4VectorSequence(2, tempStrain->data->vectorLength);
sumStrain->deltaT = tempStrain->deltaT;
sumStrain->f0 = tempStrain->f0;
sumStrain->sampleUnits = tempStrain->sampleUnits;
memset(sumStrain->data->data,0.0,2*tempStrain->data->vectorLength*sizeof(REAL4));
sumStrain = XLALSumStrain( sumStrain, tempStrain );
}
else {
sumStrain = XLALSumStrain( sumStrain, tempStrain );
}
/*fprintf(stdout, "\nInjecting NR waveform from file %s", thisMetaData.filename);*/
/* clear memory for strain */
XLALDestroyREAL4VectorSequence ( tempStrain->data );
LALFree( tempStrain );
tempStrain = NULL;
} /* end loop over modeM values */
} /* end loop over modeL values */
/*fprintf(stdout, "\nNR injections done\n");*/
*outStrain = sumStrain;
DETATCHSTATUSPTR(status);
RETURN(status);
}
/* ----------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
LALStatus status = empty_status;
CHAR filename[128];
NRWaveCatalog nrcatalog;
UINT4 k, length;
REAL4TimeVectorSeries *nrdata=NULL;
argc=0;
sprintf(filename, "NRWaveIOTest.data");
SHOULD_WORK (LALReadNRWave(&status, &nrdata, 10.0, filename), &status);
length = nrdata->data->vectorLength;
for (k = 0; k < length; k++) {
fprintf(stdout, "%e %e %e\n", k*nrdata->deltaT, nrdata->data->data[k],
nrdata->data->data[length+k]);
}
fprintf(stdout, "%%filename=%s, deltaT=%e sec, Heterodyne Freq.=%e, length=%d \n",
nrdata->name, nrdata->deltaT, nrdata->f0, nrdata->data->vectorLength);
XLALDestroyREAL4VectorSequence ( nrdata->data );
LALFree(nrdata);
/* test config file reading */
sprintf(filename, "example.cfg");
SHOULD_WORK (LALNRDataFind( &status, &nrcatalog, ".", filename), &status);
fprintf(stdout, "config file %s contains %d waves\n", filename, nrcatalog.length);
for ( k = 0; k < nrcatalog.length; k++) {
fprintf(stdout,"\n\n Wave # %d:\n", k);
fprintf(stdout, "Mass ratio = %f, spin1=(%f,%f,%f), spin2=(%f,%f, %f), l=%d, m=%d, datafile=%s\n",
nrcatalog.data[k].massRatio, nrcatalog.data[k].spin1[0], nrcatalog.data[k].spin1[1],
nrcatalog.data[k].spin1[2], nrcatalog.data[k].spin2[0], nrcatalog.data[k].spin1[1],
nrcatalog.data[k].spin1[2], nrcatalog.data[k].mode[0], nrcatalog.data[k].mode[1],
nrcatalog.data[k].filename);
}
SHOULD_WORK (LALReadNRWave(&status, &nrdata, 10.0, nrcatalog.data[0].filename), &status);
for (k = 0; k < length; k++) {
fprintf(stdout, "%e %e %e\n", k*nrdata->deltaT, nrdata->data->data[k],
nrdata->data->data[length+k]);
}
fprintf(stdout, "%%filename=%s, deltaT=%e sec, Heterodyne Freq.=%e, length=%d \n",
nrdata->name, nrdata->deltaT, nrdata->f0, nrdata->data->vectorLength);
XLALDestroyREAL4VectorSequence ( nrdata->data );
LALFree(nrdata);
LALFree(nrcatalog.data);
LALCheckMemoryLeaks();
INFO( NRWAVEIOTESTC_MSGENORM );
return NRWAVEIOTESTC_ENORM;
}
