int main(int argc, char *argv[])
{
LALFrStream *stream;
REAL8TimeSeries *series;
LIGOTimeGPS start;
XLALSetErrorHandler(XLALAbortErrorHandler);
parseargs(argc, argv);
/* get the data */
stream = XLALFrStreamCacheOpen(cache);
XLALGPSSetREAL8(&start, t0 - pad);
series = XLALFrStreamInputREAL8TimeSeries(stream, channel, &start, dt + 2.0 * pad, 0);
XLALFrStreamClose(stream);
/* manipulate the data */
if (srate > 0)
XLALResampleREAL8TimeSeries(series, 1.0 / srate);
if (minfreq > 0)
XLALHighPassREAL8TimeSeries(series, minfreq, 0.9, 8);
if (maxfreq > 0)
XLALLowPassREAL8TimeSeries(series, maxfreq, 0.9, 8);
if (pad > 0)
series = XLALResizeREAL8TimeSeries(series, pad / series->deltaT, dt / series->deltaT);
if (df > 0) { /* we are computing a spectrum */
REAL8FrequencySeries *spectrum;
REAL8FFTPlan *plan;
REAL8Window *window;
size_t seglen = 1.0 / (df * series->deltaT);
/* make sure that the time series length is commensurate with seglen */
if (((2 * series->data->length) % seglen) != 0) {
size_t newlen = ((2 * series->data->length) / seglen) * seglen;
series = XLALResizeREAL8TimeSeries(series, 0, newlen);
}
spectrum = XLALCreateREAL8FrequencySeries(series->name, &series->epoch, 0.0, df, &lalDimensionlessUnit, seglen/2 + 1);
plan = XLALCreateForwardREAL8FFTPlan(seglen, 0);
window = XLALCreateHannREAL8Window(seglen);
XLALREAL8AverageSpectrumWelch(spectrum, series, seglen, seglen/2, window, plan);
if (minfreq > 0 || maxfreq > 0) {
size_t first = minfreq / spectrum->deltaF;
size_t last = maxfreq > 0 ? maxfreq / spectrum->deltaF : spectrum->data->length;
spectrum = XLALResizeREAL8FrequencySeries(spectrum, first, last - first);
}
output_fs(outfile, spectrum);
XLALDestroyREAL8Window(window);
XLALDestroyREAL8FFTPlan(plan);
XLALDestroyREAL8FrequencySeries(spectrum);
} else { /* we are outputting a time series */
output_ts(outfile, series);
}
XLALDestroyREAL8TimeSeries(series);
return 0;
}
static void __del__(PyObject *self)
{
pylal_REAL8Window *obj = (pylal_REAL8Window *) self;
if(obj->owner)
Py_DECREF(obj->owner);
else
/* we are the owner */
XLALDestroyREAL8Window(obj->window);
self->ob_type->tp_free(self);
}
REAL8 calculate_lalsim_snr(SimInspiralTable *inj, char *IFOname, REAL8FrequencySeries *psd, REAL8 start_freq)
{
/* Calculate and return the single IFO SNR
*
* Required options:
*
* inj: SimInspiralTable entry for which the SNR has to be calculated
* IFOname: The canonical name (e.g. H1, L1, V1) name of the IFO for which the SNR must be calculated
* PSD: PSD curve to be used for the overlap integrap
* start_freq: lower cutoff of the overlap integral
*
* */
int ret=0;
INT4 errnum=0;
UINT4 j=0;
/* Fill detector site info */
LALDetector* detector=NULL;
detector=calloc(1,sizeof(LALDetector));
if(!strcmp(IFOname,"H1"))
memcpy(detector,&lalCachedDetectors[LALDetectorIndexLHODIFF],sizeof(LALDetector));
if(!strcmp(IFOname,"H2"))
memcpy(detector,&lalCachedDetectors[LALDetectorIndexLHODIFF],sizeof(LALDetector));
if(!strcmp(IFOname,"LLO")||!strcmp(IFOname,"L1"))
memcpy(detector,&lalCachedDetectors[LALDetectorIndexLLODIFF],sizeof(LALDetector));
if(!strcmp(IFOname,"V1")||!strcmp(IFOname,"VIRGO"))
memcpy(detector,&lalCachedDetectors[LALDetectorIndexVIRGODIFF],sizeof(LALDetector));
Approximant approx=TaylorF2;
approx=XLALGetApproximantFromString(inj->waveform);
LALSimulationDomain modelDomain;
if(XLALSimInspiralImplementedFDApproximants(approx)) modelDomain = LAL_SIM_DOMAIN_FREQUENCY;
else if(XLALSimInspiralImplementedTDApproximants(approx)) modelDomain = LAL_SIM_DOMAIN_TIME;
else
{
fprintf(stderr,"ERROR. Unknown approximant number %i. Unable to choose time or frequency domain model.",approx);
exit(1);
}
REAL8 m1,m2, s1x,s1y,s1z,s2x,s2y,s2z,phi0,f_min,f_max,iota,polarization;
/* No tidal PN terms until injtable is able to get them */
LALDict *LALpars= XLALCreateDict();
/* Spin and tidal interactions at the highest level (default) until injtable stores them.
* When spinO and tideO are added to injtable we can un-comment those lines and should be ok
*
int spinO = inj->spinO;
int tideO = inj->tideO;
XLALSimInspiralSetSpinOrder(waveFlags, *(LALSimInspiralSpinOrder*) spinO);
XLALSimInspiralSetTidalOrder(waveFlags, *(LALSimInspiralTidalOrder*) tideO);
*/
XLALSimInspiralWaveformParamsInsertPNPhaseOrder(LALpars,XLALGetOrderFromString(inj->waveform));
XLALSimInspiralWaveformParamsInsertPNAmplitudeOrder(LALpars,inj->amp_order);
/* Read parameters */
m1=inj->mass1*LAL_MSUN_SI;
m2=inj->mass2*LAL_MSUN_SI;
s1x=inj->spin1x;
s1y=inj->spin1y;
s1z=inj->spin1z;
s2x=inj->spin2x;
s2y=inj->spin2y;
s2z=inj->spin2z;
iota=inj->inclination;
f_min=XLALSimInspiralfLow2fStart(inj->f_lower,XLALSimInspiralWaveformParamsLookupPNAmplitudeOrder(LALpars),XLALGetApproximantFromString(inj->waveform));
phi0=inj->coa_phase;
polarization=inj->polarization;
REAL8 latitude=inj->latitude;
REAL8 longitude=inj->longitude;
LIGOTimeGPS epoch;
memcpy(&epoch,&(inj->geocent_end_time),sizeof(LIGOTimeGPS));
/* Hardcoded values of srate and segment length. If changed here they must also be changed in inspinj.c */
REAL8 srate=4096.0;
const CHAR *WF=inj->waveform;
/* Increase srate for EOB WFs */
if (strstr(WF,"EOB"))
srate=8192.0;
REAL8 segment=64.0;
f_max=(srate/2.0-(1.0/segment));
size_t seglen=(size_t) segment*srate;
REAL8 deltaF=1.0/segment;
REAL8 deltaT=1.0/srate;
/* Frequency domain h+ and hx. They are going to be filled either by a FD WF or by the FFT of a TD WF*/
COMPLEX16FrequencySeries *freqHplus;
COMPLEX16FrequencySeries *freqHcross;
freqHplus= XLALCreateCOMPLEX16FrequencySeries("fhplus",
&epoch,
0.0,
deltaF,
&lalDimensionlessUnit,
seglen/2+1
);
freqHcross=XLALCreateCOMPLEX16FrequencySeries("fhcross",
&epoch,
0.0,
deltaF,
&lalDimensionlessUnit,
seglen/2+1
);
/* If the approximant is on the FD call XLALSimInspiralChooseFDWaveform */
if (modelDomain == LAL_SIM_DOMAIN_FREQUENCY)
{
COMPLEX16FrequencySeries *hptilde=NULL;
COMPLEX16FrequencySeries *hctilde=NULL;
//We do not pass the polarization here, we assume it is taken into account when projecting h+,x onto the detector.
XLAL_TRY(ret=XLALSimInspiralChooseFDWaveform(&hptilde,&hctilde, m1, m2,
s1x, s1y, s1z, s2x, s2y, s2z,
LAL_PC_SI * 1.0e6, iota, phi0, 0., 0., 0.,
deltaF, f_min, 0.0, 0.0,
LALpars,approx),errnum);
XLALDestroyDict(LALpars);
if(!hptilde|| hptilde->data==NULL || hptilde->data->data==NULL ||!hctilde|| hctilde->data==NULL || hctilde->data->data==NULL)
{
XLALPrintError(" ERROR in XLALSimInspiralChooseFDWaveform(): error generating waveform. errnum=%d. Exiting...\n",errnum );
exit(1);
}
COMPLEX16 *dataPtr = hptilde->data->data;
for (j=0; j<(UINT4) freqHplus->data->length; ++j)
{
if(j < hptilde->data->length)
{
freqHplus->data->data[j] = dataPtr[j];
}
else
{
freqHplus->data->data[j]=0.0 + I*0.0;
}
}
dataPtr = hctilde->data->data;
for (j=0; j<(UINT4) freqHplus->data->length; ++j)
{
if(j < hctilde->data->length)
{
freqHcross->data->data[j] = dataPtr[j];
}
else
{
freqHcross->data->data[j]=0.0+0.0*I;
}
}
/* Clean */
if(hptilde) XLALDestroyCOMPLEX16FrequencySeries(hptilde);
if(hctilde) XLALDestroyCOMPLEX16FrequencySeries(hctilde);
}
else
{
/* Otherwise use XLALSimInspiralChooseTDWaveform */
REAL8FFTPlan *timeToFreqFFTPlan = XLALCreateForwardREAL8FFTPlan((UINT4) seglen, 0 );
REAL8TimeSeries *hplus=NULL;
REAL8TimeSeries *hcross=NULL;
REAL8TimeSeries *timeHplus=NULL;
REAL8TimeSeries *timeHcross=NULL;
REAL8 padding =0.4;//seconds
REAL8Window *window=XLALCreateTukeyREAL8Window(seglen,(REAL8)2.0*padding*srate/(REAL8)seglen);
REAL4 WinNorm = sqrt(window->sumofsquares/window->data->length);
timeHcross=XLALCreateREAL8TimeSeries("timeModelhCross",
&epoch,
0.0,
deltaT,
&lalStrainUnit,
seglen
);
timeHplus=XLALCreateREAL8TimeSeries("timeModelhplus",
&epoch,
0.0,
deltaT,
&lalStrainUnit,
seglen
);
for (j=0;j<(UINT4) timeHcross->data->length;++j)
timeHcross->data->data[j]=0.0;
for (j=0;j<(UINT4) timeHplus->data->length;++j)
timeHplus->data->data[j]=0.0;
XLAL_TRY(ret=XLALSimInspiralChooseTDWaveform(&hplus, &hcross, m1, m2,
s1x, s1y, s1z, s2x, s2y, s2z,
LAL_PC_SI*1.0e6, iota,
phi0, 0., 0., 0., deltaT, f_min, 0.,
LALpars, approx),
errnum);
if (ret == XLAL_FAILURE || hplus == NULL || hcross == NULL)
{
XLALPrintError(" ERROR in XLALSimInspiralChooseTDWaveform(): error generating waveform. errnum=%d. Exiting...\n",errnum );
exit(1);
}
hplus->epoch = timeHplus->epoch;
hcross->epoch = timeHcross->epoch;
XLALSimAddInjectionREAL8TimeSeries(timeHplus, hplus, NULL);
XLALSimAddInjectionREAL8TimeSeries(timeHcross, hcross, NULL);
for (j=0; j<(UINT4) timeHplus->data->length; ++j)
timeHplus->data->data[j]*=window->data->data[j];
for (j=0; j<(UINT4) timeHcross->data->length; ++j)
timeHcross->data->data[j]*=window->data->data[j];
for (j=0; j<(UINT4) freqHplus->data->length; ++j)
{
freqHplus->data->data[j]=0.0+I*0.0;
freqHcross->data->data[j]=0.0+I*0.0;
}
/* FFT into freqHplus and freqHcross */
XLALREAL8TimeFreqFFT(freqHplus,timeHplus,timeToFreqFFTPlan);
XLALREAL8TimeFreqFFT(freqHcross,timeHcross,timeToFreqFFTPlan);
for (j=0; j<(UINT4) freqHplus->data->length; ++j)
{
freqHplus->data->data[j]/=WinNorm;
freqHcross->data->data[j]/=WinNorm;
}
/* Clean... */
if ( hplus ) XLALDestroyREAL8TimeSeries(hplus);
if ( hcross ) XLALDestroyREAL8TimeSeries(hcross);
if ( timeHplus ) XLALDestroyREAL8TimeSeries(timeHplus);
if ( timeHcross ) XLALDestroyREAL8TimeSeries(timeHcross);
if (timeToFreqFFTPlan) LALFree(timeToFreqFFTPlan);
if (window) XLALDestroyREAL8Window(window);
}
/* The WF has been generated and is in freqHplus/cross. Now project into the IFO frame */
double Fplus, Fcross;
double FplusScaled, FcrossScaled;
double HSquared;
double GPSdouble=(REAL8) inj->geocent_end_time.gpsSeconds+ (REAL8) inj->geocent_end_time.gpsNanoSeconds*1.0e-9;
double gmst;
LIGOTimeGPS GPSlal;
XLALGPSSetREAL8(&GPSlal, GPSdouble);
gmst=XLALGreenwichMeanSiderealTime(&GPSlal);
/* Fill Fplus and Fcross*/
XLALComputeDetAMResponse(&Fplus, &Fcross, (const REAL4 (*)[3])detector->response,longitude, latitude, polarization, gmst);
/* And take the distance into account */
FplusScaled = Fplus / (inj->distance);
FcrossScaled = Fcross / (inj->distance);
REAL8 timedelay = XLALTimeDelayFromEarthCenter(detector->location,longitude, latitude, &GPSlal);
REAL8 timeshift = timedelay;
REAL8 twopit = LAL_TWOPI * timeshift;
UINT4 lower = (UINT4)ceil(start_freq / deltaF);
UINT4 upper = (UINT4)floor(f_max / deltaF);
REAL8 re = cos(twopit*deltaF*lower);
REAL8 im = -sin(twopit*deltaF*lower);
/* Incremental values, using cos(theta) - 1 = -2*sin(theta/2)^2 */
REAL8 dim = -sin(twopit*deltaF);
REAL8 dre = -2.0*sin(0.5*twopit*deltaF)*sin(0.5*twopit*deltaF);
REAL8 TwoDeltaToverN = 2.0 *deltaT / ((double) seglen);
REAL8 plainTemplateReal, plainTemplateImag,templateReal,templateImag;
REAL8 newRe, newIm,temp;
REAL8 this_snr=0.0;
if ( psd )
{
psd = XLALInterpolatePSD(psd, deltaF);
}
for (j=lower; j<=(UINT4) upper; ++j)
{
/* derive template (involving location/orientation parameters) from given plus/cross waveforms: */
plainTemplateReal = FplusScaled * creal(freqHplus->data->data[j])
+ FcrossScaled *creal(freqHcross->data->data[j]);
plainTemplateImag = FplusScaled * cimag(freqHplus->data->data[j])
+ FcrossScaled * cimag(freqHcross->data->data[j]);
/* do time-shifting... */
/* (also un-do 1/deltaT scaling): */
templateReal = (plainTemplateReal*re - plainTemplateImag*im) / deltaT;
templateImag = (plainTemplateReal*im + plainTemplateImag*re) / deltaT;
HSquared = templateReal*templateReal + templateImag*templateImag ;
temp = ((TwoDeltaToverN * HSquared) / psd->data->data[j]);
this_snr += temp;
/* Now update re and im for the next iteration. */
newRe = re + re*dre - im*dim;
newIm = im + re*dim + im*dre;
re = newRe;
im = newIm;
}
/* Clean */
if (freqHcross) XLALDestroyCOMPLEX16FrequencySeries(freqHcross);
if (freqHplus) XLALDestroyCOMPLEX16FrequencySeries(freqHplus);
if (detector) free(detector);
return sqrt(this_snr*2.0);
}
///
/// Make SFTs from given REAL8TimeSeries at given timestamps, potentially applying a time-domain window on each timestretch first
///
SFTVector *
XLALMakeSFTsFromREAL8TimeSeries ( const REAL8TimeSeries *timeseries, //!< input time-series
const LIGOTimeGPSVector *timestamps, //!< timestamps to produce SFTs for (can be NULL), if given must all lies within timeseries' time-span
const char *windowType, //!< optional time-domain window function to apply before FFTing
REAL8 windowBeta //!< window parameter, if any
)
{
XLAL_CHECK_NULL ( timeseries != NULL, XLAL_EINVAL, "Invalid NULL input 'timeseries'\n");
XLAL_CHECK_NULL ( timestamps != NULL, XLAL_EINVAL, "Invalid NULL input 'timestamps'\n");
REAL8 dt = timeseries->deltaT; // timeseries timestep */
REAL8 Tsft = timestamps->deltaT;
REAL8 df = 1.0 / Tsft; // SFT frequency spacing
// make sure that number of timesamples/SFT is an integer (up to possible rounding error 'eps')
REAL8 timestepsSFT0 = Tsft / dt;
UINT4 timestepsSFT = lround ( timestepsSFT0 );
XLAL_CHECK_NULL ( fabs ( timestepsSFT0 - timestepsSFT ) / timestepsSFT0 < eps, XLAL_ETOL,
"Inconsistent sampling-step (dt=%g) and Tsft=%g: must be integer multiple Tsft/dt = %g >= %g\n",
dt, Tsft, timestepsSFT0, eps );
// prepare window function if requested
REAL8Window *window = NULL;
if ( windowType != NULL ) {
XLAL_CHECK_NULL ( (window = XLALCreateNamedREAL8Window ( windowType, windowBeta, timestepsSFT )) != NULL, XLAL_EFUNC );
}
// ---------- Prepare FFT ----------
REAL8Vector *timeStretchCopy; // input array of length N
XLAL_CHECK_NULL ( (timeStretchCopy = XLALCreateREAL8Vector ( timestepsSFT )) != NULL, XLAL_EFUNC, "XLALCreateREAL4Vector(%d) failed.\n", timestepsSFT );
UINT4 numSFTBins = timestepsSFT / 2 + 1; // number of positive frequency-bins + 'DC' to be stored in SFT
fftw_complex *fftOut; // output array of length N/2 + 1
XLAL_CHECK_NULL ( (fftOut = fftw_malloc ( numSFTBins * sizeof(fftOut[0]) )) != NULL, XLAL_ENOMEM, "fftw_malloc(%d*sizeof(complex)) failed\n", numSFTBins );
fftw_plan fftplan; // FFTW plan
LAL_FFTW_WISDOM_LOCK;
XLAL_CHECK_NULL ( (fftplan = fftw_plan_dft_r2c_1d ( timestepsSFT, timeStretchCopy->data, fftOut, FFTW_ESTIMATE)) != NULL, XLAL_EFUNC ); // FIXME: or try FFTW_MEASURE
LAL_FFTW_WISDOM_UNLOCK;
LIGOTimeGPS tStart = timeseries->epoch;
// get last possible start-time for an SFT
REAL8 duration = round ( timeseries->data->length * dt ); // rounded to seconds
LIGOTimeGPS tLast = tStart;
XLALGPSAdd( &tLast, duration - Tsft );
// check that all timestamps lie within [tStart, tLast]
for ( UINT4 i = 0; i < timestamps->length; i ++ )
{
char buf1[256], buf2[256];
XLAL_CHECK_NULL ( XLALGPSDiff ( &tStart, &(timestamps->data[i]) ) <= 0, XLAL_EDOM, "Timestamp i=%d: %s before start-time %s\n",
i, XLALGPSToStr ( buf1, &(timestamps->data[i]) ), XLALGPSToStr ( buf2, &tStart ) );
XLAL_CHECK_NULL ( XLALGPSDiff ( &tLast, &(timestamps->data[i]) ) >=0, XLAL_EDOM, "Timestamp i=%d: %s after last start-time %s\n",
i, XLALGPSToStr ( buf1, &(timestamps->data[i]) ), XLALGPSToStr ( buf2, &tLast ) );
}
UINT4 numSFTs = timestamps->length;
// prepare output SFT-vector
SFTVector *sftvect;
XLAL_CHECK_NULL ( (sftvect = XLALCreateSFTVector ( numSFTs, numSFTBins )) != NULL, XLAL_EFUNC,
"XLALCreateSFTVector(numSFTs=%d, numBins=%d) failed.\n", numSFTs, numSFTBins );
// main loop: apply FFT to the requested time-stretches and store in output SFTs
for ( UINT4 iSFT = 0; iSFT < numSFTs; iSFT++ )
{
SFTtype *thisSFT = &(sftvect->data[iSFT]); // point to current SFT-slot to store output in
// find the start-bin for this SFT in the time-series
REAL8 offset = XLALGPSDiff ( &(timestamps->data[iSFT]), &tStart );
INT4 offsetBins = lround ( offset / dt );
// copy timeseries-data for that SFT into local buffer
memcpy ( timeStretchCopy->data, timeseries->data->data + offsetBins, timeStretchCopy->length * sizeof(timeStretchCopy->data[0]) );
// window the current time series stretch if required
REAL8 sigma_window = 1;
if ( window != NULL )
{
sigma_window = sqrt ( window->sumofsquares / window->data->length );
for( UINT4 iBin = 0; iBin < timeStretchCopy->length; iBin++ ) {
timeStretchCopy->data[iBin] *= window->data->data[iBin];
}
} // if window
// FFT this time-stretch
fftw_execute ( fftplan );
// fill the header of the i'th output SFT */
strcpy ( thisSFT->name, timeseries->name );
thisSFT->epoch = timestamps->data[iSFT];
thisSFT->f0 = timeseries->f0; // SFT starts at heterodyning frequency
thisSFT->deltaF = df;
// normalize DFT-data to conform to v2 specification ==> multiply DFT by (dt/sigma{window})
// the SFT normalization in case of windowing follows the conventions detailed in the SFTv2 specification,
// namely LIGO-T040164, and in particular Eqs.(3),(4) and (6) in T010095-00.pdf
// https://dcc.ligo.org/cgi-bin/private/DocDB/ShowDocument?.submit=Number&docid=T010095
// https://dcc.ligo.org/DocDB/0026/T010095/000/T010095-00.pdf
REAL8 norm = dt / sigma_window;
for ( UINT4 k = 0; k < numSFTBins ; k ++ ) {
thisSFT->data->data[k] = (COMPLEX8) ( norm * fftOut[k] );
}
// correct heterodyning-phase, IF NECESSARY: ie if (fHet * tStart) is not an integer, such that phase-corr = multiple of 2pi
if ( ( (INT4)timeseries->f0 != timeseries->f0 ) || (timeseries->epoch.gpsNanoSeconds != 0) || (thisSFT->epoch.gpsNanoSeconds != 0) ) {
XLAL_CHECK_NULL ( XLALcorrect_phase ( thisSFT, timeseries->epoch) == XLAL_SUCCESS, XLAL_EFUNC );
}
} // for iSFT < numSFTs
// free memory
fftw_free ( fftOut );
LAL_FFTW_WISDOM_LOCK;
fftw_destroy_plan ( fftplan );
LAL_FFTW_WISDOM_UNLOCK;
XLALDestroyREAL8Vector ( timeStretchCopy );
XLALDestroyREAL8Window ( window );
return sftvect;
} // XLALMakeSFTsFromREAL8TimeSeries()
static void _display(int n, double kaiser_beta, double creighton_beta, double tukey_beta, double gauss_beta)
{
REAL8Window *rectangle = XLALCreateRectangularREAL8Window(n);
REAL8Window *hann = XLALCreateHannREAL8Window(n);
REAL8Window *welch = XLALCreateWelchREAL8Window(n);
REAL8Window *bartlett = XLALCreateBartlettREAL8Window(n);
REAL8Window *parzen = XLALCreateParzenREAL8Window(n);
REAL8Window *papoulis = XLALCreatePapoulisREAL8Window(n);
REAL8Window *hamming = XLALCreateHammingREAL8Window(n);
REAL8Window *kaiser = XLALCreateKaiserREAL8Window(n, kaiser_beta);
REAL8Window *creighton = XLALCreateCreightonREAL8Window(n, creighton_beta);
REAL8Window *tukey = XLALCreateTukeyREAL8Window(n, tukey_beta);
REAL8Window *gauss = XLALCreateGaussREAL8Window(n, gauss_beta);
REAL8Window *lanczos = XLALCreateLanczosREAL8Window(n);
int i;
printf("n = %d\n", n);
printf("kaiser beta = %g\n", kaiser_beta);
printf("creighton beta = %g\n", creighton_beta);
printf("tukey beta = %g\n", tukey_beta);
printf("gaussian beta = %g\n", gauss_beta);
printf(" rect hann welch bartlett parzen papoulis hamming kaiser creight tukey gauss lanczos\n");
for(i = 0; i < n; i++) {
printf("%8.6f", rectangle->data->data[i]);
printf(" %8.6f", hann->data->data[i]);
printf(" %8.6f", welch->data->data[i]);
printf(" %8.6f", bartlett->data->data[i]);
printf(" %8.6f", parzen->data->data[i]);
printf(" %8.6f", papoulis->data->data[i]);
printf(" %8.6f", hamming->data->data[i]);
printf(" %8.6f", kaiser->data->data[i]);
printf(" %8.6f", creighton->data->data[i]);
printf(" %8.6f", tukey->data->data[i]);
printf(" %8.6f", gauss->data->data[i]);
printf(" %8.6f", lanczos->data->data[i]);
printf("\n");
}
printf("\n");
XLALDestroyREAL8Window(rectangle);
XLALDestroyREAL8Window(hann);
XLALDestroyREAL8Window(welch);
XLALDestroyREAL8Window(bartlett);
XLALDestroyREAL8Window(parzen);
XLALDestroyREAL8Window(papoulis);
XLALDestroyREAL8Window(hamming);
XLALDestroyREAL8Window(kaiser);
XLALDestroyREAL8Window(creighton);
XLALDestroyREAL8Window(tukey);
XLALDestroyREAL8Window(gauss);
XLALDestroyREAL8Window(lanczos);
}
static int test_parameter_safety(void)
{
REAL4Window *window1;
REAL8Window *window2;
int fail = 0;
window1 = XLALCreateKaiserREAL4Window(10, -1);
if(window1) {
fprintf(stderr, "error: single-precision Kaiser window accepted out-of-range parameter\n");
XLALDestroyREAL4Window(window1);
fail = 1;
}
window2 = XLALCreateKaiserREAL8Window(10, -1);
if(window1) {
fprintf(stderr, "error: double-precision Kaiser window accepted out-of-range parameter\n");
XLALDestroyREAL8Window(window2);
fail = 1;
}
window1 = XLALCreateCreightonREAL4Window(10, -1);
if(window1) {
fprintf(stderr, "error: single-precision Creighton window accepted out-of-range parameter\n");
XLALDestroyREAL4Window(window1);
fail = 1;
}
window2 = XLALCreateCreightonREAL8Window(10, -1);
if(window1) {
fprintf(stderr, "error: double-precision Creighton window accepted out-of-range parameter\n");
XLALDestroyREAL8Window(window2);
fail = 1;
}
window1 = XLALCreateTukeyREAL4Window(10, -1);
if(window1) {
fprintf(stderr, "error: single-precision Tukey window accepted out-of-range parameter\n");
XLALDestroyREAL4Window(window1);
fail = 1;
}
window1 = XLALCreateTukeyREAL4Window(10, 2);
if(window1) {
fprintf(stderr, "error: single-precision Tukey window accepted out-of-range parameter\n");
XLALDestroyREAL4Window(window1);
fail = 1;
}
window2 = XLALCreateTukeyREAL8Window(10, -1);
if(window1) {
fprintf(stderr, "error: double-precision Tukey window accepted out-of-range parameter\n");
XLALDestroyREAL8Window(window2);
fail = 1;
}
window2 = XLALCreateTukeyREAL8Window(10, 2);
if(window1) {
fprintf(stderr, "error: double-precision Tukey window accepted out-of-range parameter\n");
XLALDestroyREAL8Window(window2);
fail = 1;
}
window1 = XLALCreateGaussREAL4Window(10, -1);
if(window1) {
fprintf(stderr, "error: single-precision Gauss window accepted out-of-range parameter\n");
XLALDestroyREAL4Window(window1);
fail = 1;
}
window2 = XLALCreateGaussREAL8Window(10, -1);
if(window1) {
fprintf(stderr, "error: double-precision Gauss window accepted out-of-range parameter\n");
XLALDestroyREAL8Window(window2);
fail = 1;
}
return fail;
}
static void free_double_windows(REAL8Window **windows)
{
int i;
for(i = 0; i < NWINDOWS; i++)
XLALDestroyREAL8Window(windows[i]);
}
