REAL8 calculate_ligo_snr_from_strain( REAL4TimeVectorSeries *strain,
SimInspiralTable *thisInj,
const CHAR ifo[3])
{
REAL8 ret = -1, snrSq, freq, psdValue;
REAL8 sampleRate = 4096, deltaF;
REAL4TimeSeries *chan = NULL;
REAL4FFTPlan *pfwd;
COMPLEX8FrequencySeries *fftData;
UINT4 k;
/* create the time series */
chan = XLALCalculateNRStrain( strain, thisInj, ifo, sampleRate );
deltaF = chan->deltaT * strain->data->vectorLength;
fftData = XLALCreateCOMPLEX8FrequencySeries( chan->name, &(chan->epoch),
0, deltaF, &lalDimensionlessUnit,
chan->data->length/2 + 1 );
/* perform the fft */
pfwd = XLALCreateForwardREAL4FFTPlan( chan->data->length, 0 );
XLALREAL4TimeFreqFFT( fftData, chan, pfwd );
/* compute the SNR for initial LIGO at design */
for ( snrSq = 0, k = 0; k < fftData->data->length; k++ )
{
freq = fftData->deltaF * k;
if ( ifo[0] == 'V' )
{
if (freq < 35)
continue;
LALVIRGOPsd( NULL, &psdValue, freq );
psdValue /= 9e-46;
}
else
{
if (freq < 40)
continue;
LALLIGOIPsd( NULL, &psdValue, freq );
}
fftData->data->data[k] /= 3e-23;
snrSq += crealf(fftData->data->data[k]) * crealf(fftData->data->data[k]) / psdValue;
snrSq += cimagf(fftData->data->data[k]) * cimagf(fftData->data->data[k]) / psdValue;
}
snrSq *= 4*fftData->deltaF;
XLALDestroyREAL4FFTPlan( pfwd );
XLALDestroyCOMPLEX8FrequencySeries( fftData );
XLALDestroyREAL4Vector ( chan->data);
LALFree(chan);
ret = sqrt(snrSq);
return ret;
}
int
test_XLALSincInterpolateSFT ( void )
{
REAL8 f0 = 0; // heterodyning frequency
REAL8 sigmaN = 0.001;
REAL8 dt = 0.1; // sampling frequency = 10Hz
LIGOTimeGPS epoch = { 100, 0 };
REAL8 tStart = XLALGPSGetREAL8 ( &epoch );
UINT4 numSamples = 1000;
REAL8 Tspan = numSamples * dt;
REAL8 df = 1.0 / Tspan;
UINT4 numSamples0padded = 3 * numSamples;
REAL8 Tspan0padded = numSamples0padded * dt;
REAL8 df0padded = 1.0 / Tspan0padded;
UINT4 numBins = NhalfPosDC ( numSamples );
UINT4 numBins0padded = NhalfPosDC ( numSamples0padded );
// original timeseries
REAL4TimeSeries* ts;
XLAL_CHECK ( (ts = XLALCreateREAL4TimeSeries ( "test TS_in", &epoch, f0, dt, &emptyLALUnit, numSamples )) != NULL, XLAL_EFUNC );
for ( UINT4 j = 0; j < numSamples; j ++ ) {
ts->data->data[j] = crealf ( testSignal ( tStart + j * dt, sigmaN ) );
} // for j < numSamples
// zero-padded to double length
REAL4TimeSeries* ts0padded;
XLAL_CHECK ( (ts0padded = XLALCreateREAL4TimeSeries ( "test TS_padded", &epoch, f0, dt, &emptyLALUnit, numSamples0padded )) != NULL, XLAL_EFUNC );
memcpy ( ts0padded->data->data, ts->data->data, numSamples * sizeof(ts0padded->data->data[0]) );
memset ( ts0padded->data->data + numSamples, 0, (numSamples0padded - numSamples) * sizeof(ts0padded->data->data[0]) );
// compute FFT on ts and ts0padded
REAL4FFTPlan *plan, *plan0padded;
XLAL_CHECK ( (plan = XLALCreateForwardREAL4FFTPlan ( numSamples, 0 )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( (plan0padded = XLALCreateForwardREAL4FFTPlan ( numSamples0padded, 0 )) != NULL, XLAL_EFUNC );
COMPLEX8Vector *fft, *fft0padded;
XLAL_CHECK ( (fft = XLALCreateCOMPLEX8Vector ( numBins )) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( (fft0padded = XLALCreateCOMPLEX8Vector ( numBins0padded )) != NULL, XLAL_ENOMEM );
XLAL_CHECK ( XLALREAL4ForwardFFT ( fft, ts->data, plan ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALREAL4ForwardFFT ( fft0padded, ts0padded->data, plan0padded ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyREAL4TimeSeries ( ts );
XLALDestroyREAL4TimeSeries ( ts0padded );
XLALDestroyREAL4FFTPlan( plan );
XLALDestroyREAL4FFTPlan( plan0padded );
SFTtype XLAL_INIT_DECL(tmp);
tmp.f0 = f0;
tmp.deltaF = df;
tmp.data = fft;
REAL8 Band = 0.5/dt - f0;
SFTtype *sft = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &sft, &tmp, f0, Band ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyCOMPLEX8Vector ( fft );
tmp.f0 = f0;
tmp.deltaF = df0padded;
tmp.data = fft0padded;
SFTtype *sft0padded = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &sft0padded, &tmp, f0, Band ) == XLAL_SUCCESS, XLAL_EFUNC );
XLALDestroyCOMPLEX8Vector ( fft0padded );
// ---------- interpolate input SFT onto frequency bins of padded-ts FFT for comparison
UINT4 Dterms = 16;
REAL8 safetyBins = (Dterms + 1.0); // avoid truncated interpolation to minimize errors, set to 0 for seeing boundary-effects [they're not so bad...]
REAL8 fMin = f0 + safetyBins * df;
fMin = round(fMin / df0padded) * df0padded;
UINT4 numBinsOut = numBins0padded - 3 * safetyBins;
REAL8 BandOut = (numBinsOut-1) * df0padded;
SFTtype *sftUpsampled = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &sftUpsampled, sft0padded, fMin + 0.5*df0padded, BandOut - df0padded ) == XLAL_SUCCESS, XLAL_EFUNC );
SFTtype *sftInterpolated;
XLAL_CHECK ( (sftInterpolated = XLALSincInterpolateSFT ( sft, fMin, df0padded, numBinsOut, Dterms )) != NULL, XLAL_EFUNC );
// ----- out debug info
if ( lalDebugLevel & LALINFO )
{
XLAL_CHECK ( write_SFTdata ( "SFT_in.dat", sft ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ( "SFT_in0padded.dat", sft0padded ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ( "SFT_upsampled.dat", sftUpsampled ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ( "SFT_interpolated.dat", sftInterpolated ) == XLAL_SUCCESS, XLAL_EFUNC );
} // if LALINFO
// ---------- check accuracy of interpolation
VectorComparison XLAL_INIT_DECL(tol);
tol.relErr_L1 = 8e-2;
tol.relErr_L2 = 8e-2;
tol.angleV = 8e-2;
tol.relErr_atMaxAbsx = 4e-3;
tol.relErr_atMaxAbsy = 4e-3;
XLALPrintInfo ("Comparing Dirichlet SFT interpolation with upsampled SFT:\n");
XLAL_CHECK ( XLALCompareSFTs ( sftUpsampled, sftInterpolated, &tol ) == XLAL_SUCCESS, XLAL_EFUNC );
// ---------- free memory
XLALDestroySFT ( sft );
XLALDestroySFT ( sft0padded );
XLALDestroySFT ( sftUpsampled );
XLALDestroySFT ( sftInterpolated );
return XLAL_SUCCESS;
} // test_XLALSincInterpolateSFT()
/**
* Unit-Test for function XLALSFTVectorToLFT().
* Generates random data (timeseries + corresponding SFTs),
* then feeds the SFTs into XLALSFTVectorToLFT()
* and checks correctness of output Fourier transform by
* comparing to FT of original real-valued timeseries.
*
* \note This indirectly also checks XLALSFTVectorToCOMPLEX8TimeSeries()
* which is used by XLALSFTVectorToLFT().
*
* returns XLAL_SUCCESS on success, XLAL-error otherwise
*/
int
test_XLALSFTVectorToLFT ( void )
{
// ----- generate real-valued random timeseries and corresponding SFTs
REAL4TimeSeries *tsR4 = NULL;
SFTVector *sfts0 = NULL;
XLAL_CHECK ( XLALgenerateRandomData ( &tsR4, &sfts0 ) == XLAL_SUCCESS, XLAL_EFUNC );
UINT4 numSamplesR4 = tsR4->data->length;
REAL8 dt_R4 = tsR4->deltaT;
REAL8 TspanR4 = numSamplesR4 * dt_R4;
// ----- consider only the frequency band [3Hz, 4Hz]
REAL8 out_fMin = 3;
REAL8 out_Band = 1;
SFTVector *sftsBand;
XLAL_CHECK ( (sftsBand = XLALExtractBandFromSFTVector ( sfts0, out_fMin, out_Band )) != NULL, XLAL_EFUNC );
XLALDestroySFTVector ( sfts0 );
// ----- 1) compute FFT on original REAL4 timeseries -----
REAL4FFTPlan *planR4;
XLAL_CHECK ( (planR4 = XLALCreateForwardREAL4FFTPlan ( numSamplesR4, 0 )) != NULL, XLAL_EFUNC );
SFTtype *lft0;
XLAL_CHECK ( (lft0 = XLALCreateSFT ( numSamplesR4/2+1 )) != NULL, XLAL_EFUNC );
XLAL_CHECK ( XLALREAL4ForwardFFT ( lft0->data, tsR4->data, planR4 ) == XLAL_SUCCESS, XLAL_EFUNC );
strcpy ( lft0->name, tsR4->name );
lft0->f0 = 0;
lft0->epoch = tsR4->epoch;
REAL8 dfLFT = 1.0 / TspanR4;
lft0->deltaF = dfLFT;
// ----- extract frequency band of interest
SFTtype *lftR4 = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &lftR4, lft0, out_fMin, out_Band ) == XLAL_SUCCESS, XLAL_EFUNC );
for ( UINT4 k=0; k < lftR4->data->length; k ++ ) {
lftR4->data->data[k] *= dt_R4;
}
// ----- 2) compute LFT directly from SFTs ----------
SFTtype *lftSFTs0;
XLAL_CHECK ( (lftSFTs0 = XLALSFTVectorToLFT ( sftsBand, 1 )) != NULL, XLAL_EFUNC );
XLALDestroySFTVector ( sftsBand );
// ----- re-extract frequency band of interest
SFTtype *lftSFTs = NULL;
XLAL_CHECK ( XLALExtractBandFromSFT ( &lftSFTs, lftSFTs0, out_fMin, out_Band ) == XLAL_SUCCESS, XLAL_EFUNC );
if ( lalDebugLevel & LALINFO )
{ // ----- write debug output
XLAL_CHECK ( XLALdumpREAL4TimeSeries ( "TS_R4.dat", tsR4 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ("LFT_R4T.dat", lftR4 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( write_SFTdata ("LFT_SFTs.dat", lftSFTs ) == XLAL_SUCCESS, XLAL_EFUNC );
} // end: debug output
// ========== compare resulting LFTs ==========
VectorComparison XLAL_INIT_DECL(tol0);
XLALPrintInfo ("Comparing LFT with itself: should give 0 for all measures\n");
XLAL_CHECK ( XLALCompareSFTs ( lftR4, lftR4, &tol0 ) == XLAL_SUCCESS, XLAL_EFUNC );
XLAL_CHECK ( XLALCompareSFTs ( lftSFTs, lftSFTs, &tol0 ) == XLAL_SUCCESS, XLAL_EFUNC );
VectorComparison XLAL_INIT_DECL(tol);
tol.relErr_L1 = 4e-2;
tol.relErr_L2 = 5e-2;
tol.angleV = 5e-2; // rad
tol.relErr_atMaxAbsx = 1.2e-2;
tol.relErr_atMaxAbsy = 1.2e-2;
XLALPrintInfo ("Comparing LFT from REAL4-timeseries, to LFT from heterodyned COMPLEX8-timeseries:\n");
XLAL_CHECK ( XLALCompareSFTs ( lftR4, lftSFTs, &tol ) == XLAL_SUCCESS, XLAL_EFUNC );
// ---------- free memory ----------
XLALDestroyREAL4TimeSeries ( tsR4 );
XLALDestroyREAL4FFTPlan ( planR4 );
XLALDestroySFT ( lft0 );
XLALDestroySFT ( lftR4 );
XLALDestroySFT ( lftSFTs );
XLALDestroySFT ( lftSFTs0 );
return XLAL_SUCCESS;
} // test_XLALSFTVectorToLFT()
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;
}
/**
* Cluster candidates by frequency, period, and modulation depth using templates
* \param [out] output Pointer to pointer of a candidateVector
* \param [in] input Pointer to a candidateVector
* \param [in] ffdata Pointer to ffdataStruct
* \param [in] params Pointer to inputParamsStruct
* \param [in] ffplanenoise Pointer to REAL4Vector of 2nd FFT background powers
* \param [in] fbinaveratios Pointer to REAL4Vector of normalized SFT background
* \param [in] sftexist Pointer to INT4Vector of existing SFTs
* \param [in] option Flag to use Gaussian templates (0) or exact templates (1)
* \return Status value
*/
INT4 clusterCandidates(candidateVector **output, candidateVector *input, ffdataStruct *ffdata, inputParamsStruct *params, REAL4Vector *ffplanenoise, REAL4Vector *fbinaveratios, INT4Vector *sftexist, INT4 option)
{
XLAL_CHECK( input != NULL && ffdata != NULL && params != NULL && ffplanenoise != NULL && fbinaveratios != NULL && sftexist != NULL, XLAL_EINVAL );
INT4 ii, jj, kk, loc, loc2, numcandoutlist;
REAL8 avefsig, aveperiod, mindf, maxdf;
//Allocate int vectors for storage
INT4Vector *locs = NULL, *locs2 = NULL, *usedcandidate = NULL;
XLAL_CHECK( (locs = XLALCreateINT4Vector(input->numofcandidates)) != NULL, XLAL_EFUNC );
XLAL_CHECK( (locs2 = XLALCreateINT4Vector(input->numofcandidates)) != NULL, XLAL_EFUNC );
XLAL_CHECK( (usedcandidate = XLALCreateINT4Vector(input->numofcandidates)) != NULL, XLAL_EFUNC );
//Initialize arrays
for (ii=0; ii<(INT4)input->numofcandidates; ii++) {
locs->data[ii] = -1;
locs2->data[ii] = -1;
usedcandidate->data[ii] = 0;
}
//Set default if bad option given
if (option!=0 && option!=1) option = 0;
//Make FFT plan if option 1 is given
REAL4FFTPlan *plan = NULL;
if (option==1) XLAL_CHECK( (plan = XLALCreateForwardREAL4FFTPlan(ffdata->numffts, 1)) != NULL, XLAL_EFUNC );
numcandoutlist = 0;
for (ii=0; ii<(INT4)input->numofcandidates; ii++) {
//Make note of first candidate available
locs->data[0] = ii;
loc = 1;
INT4 foundany = 0; //Switch to determine if any other candidates in the group. 1 if true
INT4 iter = 1;
//Find any in the list that are within +1/2 bin in first FFT frequency
for (jj=ii+1; jj<(INT4)input->numofcandidates; jj++) {
if ( usedcandidate->data[jj] == 0 && (input->data[jj].fsig-input->data[locs->data[0]].fsig <= 0.5*iter/params->Tcoh+1.0e-6 && input->data[jj].fsig-input->data[locs->data[0]].fsig >= -0.25*iter/params->Tcoh) ) {
locs->data[loc] = jj;
loc++;
if (foundany==0) foundany = 1;
}
} /* for jj < input->numofcandidates */
//Keep checking as long as there are more connected frequencies going higher in frequency
while (foundany==1) {
foundany = 0;
iter++;
for (jj=ii+1; jj<(INT4)input->numofcandidates; jj++) {
if ( usedcandidate->data[jj] == 0 && (input->data[jj].fsig-input->data[locs->data[0]].fsig-0.25/params->Tcoh <= 0.5*iter/params->Tcoh && input->data[jj].fsig-input->data[locs->data[0]].fsig+0.25/params->Tcoh >= 0.5*iter/params->Tcoh) ) {
locs->data[loc] = jj;
loc++;
if (foundany==0) foundany = 1;
}
} /* for jj < input->numofcandidates */
} /* while foundany==1 */
//Now check frequencies 1/2 bin below and keep going as long as there are more connected frequencies
foundany = 1;
iter = 0;
while (foundany==1) {
foundany = 0;
iter++;
for (jj=ii+1; jj<(INT4)input->numofcandidates; jj++) {
if ( usedcandidate->data[jj] == 0 && (input->data[locs->data[0]].fsig-input->data[jj].fsig-0.25/params->Tcoh <= 0.5*iter/params->Tcoh && input->data[locs->data[0]].fsig-input->data[jj].fsig+0.25/params->Tcoh >= 0.5*iter/params->Tcoh) ) {
locs->data[loc] = jj;
loc++;
if (foundany==0) foundany = 1;
}
} /* for jj < input->numofcandidates */
} /* while foundany==1 */
//Using the list of locations, find the subset that have periods within 1 bin
//of the second FFT frequencies
INT4 subsetloc = 0;
INT4 nextsubsetloc = 0;
INT4 subsetlocset = 0;
loc2 = 0;
for (jj=subsetloc; jj<loc; jj++) {
if ( usedcandidate->data[locs->data[jj]] == 0 && fabs(params->Tobs/input->data[locs->data[jj]].period - params->Tobs/input->data[locs->data[subsetloc]].period) <= 1.0 ) {
locs2->data[loc2] = locs->data[jj];
loc2++;
} else if (usedcandidate->data[locs->data[jj]] == 0 && subsetlocset == 0) {
subsetlocset = 1;
nextsubsetloc = jj;
}
if (jj+1 == loc) {
if (subsetlocset==1) {
subsetloc = nextsubsetloc; //Reset subsetloc and jj to the next candidate period
jj = subsetloc-1;
subsetlocset = 0; //Reset the logic of whether there are any more periods to go
}
//find best candidate moddepth
fprintf(stderr,"Finding best modulation depth with number to try %d\n",loc2);
avefsig = 0.0, aveperiod = 0.0, mindf = 0.0, maxdf = 0.0;
REAL8 weight = 0.0, bestmoddepth = 0.0, bestR = 0.0, besth0 = 0.0, bestProb = 0.0;
INT4 bestproberrcode = 0;
for (kk=0; kk<loc2; kk++) {
avefsig += input->data[locs2->data[kk]].fsig*(input->data[locs2->data[kk]].prob*input->data[locs2->data[kk]].prob);
aveperiod += input->data[locs2->data[kk]].period*(input->data[locs2->data[kk]].prob*input->data[locs2->data[kk]].prob);
weight += input->data[locs2->data[kk]].prob*input->data[locs2->data[kk]].prob;
if (mindf > input->data[locs2->data[kk]].moddepth || mindf == 0.0) mindf = input->data[locs2->data[kk]].moddepth;
if (maxdf < input->data[locs2->data[kk]].moddepth) maxdf = input->data[locs2->data[kk]].moddepth;
if (loc2==1 && input->data[locs2->data[kk]].fsig>=params->fmin && input->data[locs2->data[kk]].fsig<(params->fmin+params->fspan) && input->data[locs2->data[kk]].period>=params->Pmin && input->data[locs2->data[kk]].period<=params->Pmax) {
besth0 = input->data[locs2->data[kk]].h0;
bestmoddepth = input->data[locs2->data[kk]].moddepth;
bestR = input->data[locs2->data[kk]].stat;
bestProb = input->data[locs2->data[kk]].prob;
bestproberrcode = input->data[locs2->data[kk]].proberrcode;
}
usedcandidate->data[locs2->data[kk]] = 1;
} /* for kk < loc2 */
avefsig = avefsig/weight;
aveperiod = aveperiod/weight;
INT4 proberrcode = 0;
if (loc2 > 1 && aveperiod >= params->Pmin && aveperiod <= params->Pmax) {
INT4 numofmoddepths = (INT4)floorf(2*(maxdf-mindf)*params->Tcoh)+1;
candidate cand;
templateStruct *template = NULL;
XLAL_CHECK( (template = new_templateStruct(params->maxtemplatelength)) != NULL, XLAL_EFUNC );
int main( int argc, char **argv )
{
INT4 i,j;
struct coh_PTF_params *params = NULL;
ProcessParamsTable *procpar = NULL;
REAL4FFTPlan *fwdplan = NULL;
REAL4FFTPlan *psdplan = NULL;
REAL4FFTPlan *revplan = NULL;
COMPLEX8FFTPlan *invPlan = NULL;
REAL4TimeSeries *channel[LAL_NUM_IFO+1];
REAL4FrequencySeries *invspec[LAL_NUM_IFO+1];
RingDataSegments *segments[LAL_NUM_IFO+1];
INT4 numTmplts = 0;
INT4 startTemplate = -1; /* index of first template */
INT4 stopTemplate = -1; /* index of last template */
INT4 numSegments = 0;
InspiralTemplate *PTFtemplate = NULL;
InspiralTemplate *PTFbankhead = NULL;
SnglInspiralTable *PTFSpinTmplt = NULL;
SnglInspiralTable *PTFSpinTmpltHead = NULL;
SnglInspiralTable *PTFNoSpinTmplt = NULL;
SnglInspiralTable *PTFNoSpinTmpltHead = NULL;
SnglInspiralTable *PTFLastTmplt = NULL;
FindChirpTemplate *fcTmplt = NULL;
FindChirpTmpltParams *fcTmpltParams = NULL;
FindChirpInitParams *fcInitParams = NULL;
UINT4 numPoints,ifoNumber,spinTemplate;
REAL8Array *PTFM[LAL_NUM_IFO+1];
REAL8Array *PTFN[LAL_NUM_IFO+1];
COMPLEX8VectorSequence *PTFqVec[LAL_NUM_IFO+1];
time_t startTime;
LALDetector *detectors[LAL_NUM_IFO+1];
REAL4 *timeOffsets;
REAL4 *Fplus;
REAL8 FplusTmp;
REAL4 *Fcross;
REAL8 FcrossTmp;
REAL8 detLoc[3];
REAL4TimeSeries UNUSED *pValues[10];
REAL4TimeSeries UNUSED *gammaBeta[2];
LIGOTimeGPS segStartTime;
MultiInspiralTable *eventList = NULL;
UINT4 numDetectors = 0;
UINT4 singleDetector = 0;
char bankFileName[256];
startTime = time(NULL);
/* set error handlers to abort on error */
set_abrt_on_error();
/* options are parsed and debug level is set here... */
/* no lal mallocs before this! */
params = coh_PTF_get_params( argc, argv );
/* create process params */
procpar = create_process_params( argc, argv, PROGRAM_NAME );
verbose("Read input params %ld \n", time(NULL)-startTime);
/* create forward and reverse fft plans */
fwdplan = coh_PTF_get_fft_fwdplan( params );
psdplan = coh_PTF_get_fft_psdplan( params );
revplan = coh_PTF_get_fft_revplan( params );
verbose("Made fft plans %ld \n", time(NULL)-startTime);
/* Determine if we are analyzing single or multiple ifo data */
for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++)
{
if ( params->haveTrig[ifoNumber] )
{
numDetectors++;
}
}
/* NULL out the pValues pointer array */
for ( i = 0 ; i < 10 ; i++ )
{
pValues[i] = NULL;
}
gammaBeta[0] = NULL;
gammaBeta[1] = NULL;
if (numDetectors == 0 )
{
fprintf(stderr,"You have not specified any detectors to analyse");
return 1;
}
else if (numDetectors == 1 )
{
fprintf(stdout,"You have only specified one detector, why are you using the coherent code? \n");
singleDetector = 1;
}
/* Convert the file names */
if ( params->bankFile )
strncpy(bankFileName,params->bankFile,sizeof(bankFileName)-1);
REAL4 *timeSlideVectors;
timeSlideVectors=LALCalloc(1, (LAL_NUM_IFO+1)*
params->numOverlapSegments*sizeof(REAL4));
memset(timeSlideVectors, 0,
(LAL_NUM_IFO+1) * params->numOverlapSegments * sizeof(REAL4));
for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++)
{
/* Initialize some of the structures */
channel[ifoNumber] = NULL;
invspec[ifoNumber] = NULL;
segments[ifoNumber] = NULL;
PTFM[ifoNumber] = NULL;
PTFN[ifoNumber] = NULL;
PTFqVec[ifoNumber] = NULL;
if ( params->haveTrig[ifoNumber] )
{
/* Read in data from the various ifos */
channel[ifoNumber] = coh_PTF_get_data(params,params->channel[ifoNumber],\
params->dataCache[ifoNumber],ifoNumber );
coh_PTF_rescale_data (channel[ifoNumber],1E20);
/* compute the spectrum */
invspec[ifoNumber] = coh_PTF_get_invspec( channel[ifoNumber], fwdplan,\
revplan, psdplan, params );
/* create the segments */
segments[ifoNumber] = coh_PTF_get_segments( channel[ifoNumber],\
invspec[ifoNumber], fwdplan, ifoNumber, timeSlideVectors, params );
numSegments = segments[ifoNumber]->numSgmnt;
verbose("Created segments for one ifo %ld \n", time(NULL)-startTime);
}
}
/* Determine time delays and response functions */
timeOffsets = LALCalloc(1, numSegments*LAL_NUM_IFO*sizeof( REAL4 ));
Fplus = LALCalloc(1, numSegments*LAL_NUM_IFO*sizeof( REAL4 ));
Fcross = LALCalloc(1, numSegments*LAL_NUM_IFO*sizeof( REAL4 ));
for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++)
{
detectors[ifoNumber] = LALCalloc( 1, sizeof( *detectors[ifoNumber] ));
XLALReturnDetector(detectors[ifoNumber] ,ifoNumber);
for ( i = 0; i < 3; i++ )
{
detLoc[i] = (double) detectors[ifoNumber]->location[i];
}
for ( j = 0; j < numSegments; ++j )
{
/* Despite being called segStartTime we use the time at the middle
* of a segment */
segStartTime = params->startTime;
/*XLALGPSAdd(&segStartTime,(j+1)*params->segmentDuration/2.0);*/
XLALGPSAdd(&segStartTime,8.5*params->segmentDuration/2.0);
/*XLALGPSMultiply(&segStartTime,0.);
XLALGPSAdd(&segStartTime,874610713.072549154);*/
timeOffsets[j*LAL_NUM_IFO+ifoNumber] = (REAL4)
XLALTimeDelayFromEarthCenter(detLoc,params->rightAscension,
params->declination,&segStartTime);
XLALComputeDetAMResponse(&FplusTmp, &FcrossTmp,
(const REAL4 (*)[3])detectors[ifoNumber]->response,params->rightAscension,
params->declination,0.,XLALGreenwichMeanSiderealTime(&segStartTime));
Fplus[j*LAL_NUM_IFO + ifoNumber] = (REAL4) FplusTmp;
Fcross[j*LAL_NUM_IFO + ifoNumber] = (REAL4) FcrossTmp;
}
LALFree(detectors[ifoNumber]);
}
numPoints = floor( params->segmentDuration * params->sampleRate + 0.5 );
/* Initialize some of the structures */
ifoNumber = LAL_NUM_IFO;
channel[ifoNumber] = NULL;
invspec[ifoNumber] = NULL;
segments[ifoNumber] = NULL;
PTFM[ifoNumber] = NULL;
PTFN[ifoNumber] = NULL;
PTFqVec[ifoNumber] = NULL;
/* Create the relevant structures that will be needed */
fcInitParams = LALCalloc( 1, sizeof( *fcInitParams ));
fcTmplt = LALCalloc( 1, sizeof( *fcTmplt ) );
fcTmpltParams = LALCalloc ( 1, sizeof( *fcTmpltParams ) );
fcTmpltParams->approximant = FindChirpPTF;
fcTmplt->PTFQtilde =
XLALCreateCOMPLEX8VectorSequence( 5, numPoints / 2 + 1 );
/* fcTmplt->PTFBinverse = XLALCreateArrayL( 2, 5, 5 );
fcTmplt->PTFB = XLALCreateArrayL( 2, 5, 5 );*/
fcTmplt->PTFQ = XLALCreateVectorSequence( 5, numPoints );
fcTmpltParams->PTFphi = XLALCreateVector( numPoints );
fcTmpltParams->PTFomega_2_3 = XLALCreateVector( numPoints );
fcTmpltParams->PTFe1 = XLALCreateVectorSequence( 3, numPoints );
fcTmpltParams->PTFe2 = XLALCreateVectorSequence( 3, numPoints );
fcTmpltParams->fwdPlan =
XLALCreateForwardREAL4FFTPlan( numPoints, 1 );
fcTmpltParams->deltaT = 1.0/params->sampleRate;
for( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++)
{
if ( params->haveTrig[ifoNumber] )
{
PTFM[ifoNumber] = XLALCreateREAL8ArrayL( 2, 5, 5 );
PTFN[ifoNumber] = XLALCreateREAL8ArrayL( 2, 5, 5 );
PTFqVec[ifoNumber] = XLALCreateCOMPLEX8VectorSequence ( 5, numPoints );
}
}
/* Create an inverser FFT plan */
invPlan = XLALCreateReverseCOMPLEX8FFTPlan( numPoints, 1 );
/* Read in the tmpltbank xml file */
numTmplts = InspiralTmpltBankFromLIGOLw( &PTFtemplate,bankFileName,
startTemplate, stopTemplate );
PTFbankhead = PTFtemplate;
/*fake_template (PTFtemplate);*/
for (i = 0; (i < numTmplts); PTFtemplate = PTFtemplate->next, i++)
{
/* Determine if we can model this template as non-spinning */
spinTemplate = 1;
if (PTFtemplate->chi < 0.1)
spinTemplate = 0;
PTFtemplate->approximant = FindChirpPTF;
PTFtemplate->order = LAL_PNORDER_TWO;
PTFtemplate->fLower = 38.;
/* Generate the Q freq series of the template */
coh_PTF_template(fcTmplt,PTFtemplate,fcTmpltParams);
verbose("Generated template %d at %ld \n", i, time(NULL)-startTime);
for ( ifoNumber = 0; ifoNumber < LAL_NUM_IFO; ifoNumber++)
{
if ( params->haveTrig[ifoNumber] )
{
memset( PTFM[ifoNumber]->data, 0, 25 * sizeof(REAL8) );
memset( PTFN[ifoNumber]->data, 0, 25 * sizeof(REAL8) );
memset( PTFqVec[ifoNumber]->data, 0,
5 * numPoints * sizeof(COMPLEX8) );
coh_PTF_normalize(params,fcTmplt,invspec[ifoNumber],PTFM[ifoNumber],
PTFN[ifoNumber],PTFqVec[ifoNumber],
&segments[ifoNumber]->sgmnt[0],invPlan,1);
}
}
spinTemplate = coh_PTF_spin_checker(PTFM,PTFN,params,singleDetector,Fplus,Fcross,numSegments/2);
if (spinTemplate)
verbose("Template %d treated as spin at %ld \n",i,time(NULL)-startTime);
else
verbose("Template %d treated as non spin at %ld \n",i,time(NULL)-startTime);
if (spinTemplate)
{
if ( !PTFSpinTmplt )
{
PTFSpinTmpltHead = conv_insp_tmpl_to_sngl_table(PTFtemplate,i);
PTFSpinTmplt = PTFSpinTmpltHead;
}
else
{
PTFLastTmplt = PTFSpinTmplt;
PTFSpinTmplt = conv_insp_tmpl_to_sngl_table(PTFtemplate,i);
PTFLastTmplt->next = PTFSpinTmplt;
}
}
else
{
if ( !PTFNoSpinTmplt )
{
PTFNoSpinTmpltHead = conv_insp_tmpl_to_sngl_table(PTFtemplate,i);
PTFNoSpinTmplt = PTFNoSpinTmpltHead;
}
else
{
PTFLastTmplt = PTFNoSpinTmplt;
PTFNoSpinTmplt = conv_insp_tmpl_to_sngl_table(PTFtemplate,i);
PTFLastTmplt->next = PTFNoSpinTmplt;
}
}
if (! PTFtemplate->event_id)
{
PTFtemplate->event_id = (EventIDColumn *)
LALCalloc(1, sizeof(EventIDColumn) );
PTFtemplate->event_id->id = i;
}
}
coh_PTF_output_tmpltbank(params->spinBankName,PTFSpinTmpltHead,procpar,params);
coh_PTF_output_tmpltbank(params->noSpinBankName,PTFNoSpinTmpltHead,procpar,params);
verbose("Generated output xml files, cleaning up and exiting at %ld \n",
time(NULL)-startTime);
LALFree(timeSlideVectors);
coh_PTF_cleanup(params,procpar,fwdplan,psdplan,revplan,invPlan,channel,
invspec,segments,eventList,NULL,PTFbankhead,fcTmplt,fcTmpltParams,
fcInitParams,PTFM,PTFN,PTFqVec,timeOffsets,NULL,Fplus,Fcross,NULL,NULL,\
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
while ( PTFSpinTmpltHead )
{
PTFSpinTmplt = PTFSpinTmpltHead;
PTFSpinTmpltHead = PTFSpinTmplt->next;
if ( PTFSpinTmplt->event_id )
{
LALFree( PTFSpinTmplt->event_id );
}
LALFree( PTFSpinTmplt );
}
while ( PTFNoSpinTmpltHead )
{
PTFNoSpinTmplt = PTFNoSpinTmpltHead;
PTFNoSpinTmpltHead = PTFNoSpinTmplt->next;
if ( PTFNoSpinTmplt->event_id )
{
LALFree( PTFNoSpinTmplt->event_id );
}
LALFree( PTFNoSpinTmplt );
}
LALCheckMemoryLeaks();
return 0;
}
