int XLALREAL4TimeFreqFFT(
COMPLEX8FrequencySeries *freq,
const REAL4TimeSeries *time,
const REAL4FFTPlan *plan
)
{
UINT4 k;
if ( ! freq || ! time || ! plan )
XLAL_ERROR( XLAL_EFAULT );
if ( time->deltaT <= 0.0 )
XLAL_ERROR( XLAL_EINVAL );
/* perform the transform */
if ( XLALREAL4ForwardFFT( freq->data, time->data, plan ) == XLAL_FAILURE )
XLAL_ERROR( XLAL_EFUNC );
/* adjust the units */
if ( ! XLALUnitMultiply( &freq->sampleUnits, &time->sampleUnits, &lalSecondUnit ) )
XLAL_ERROR( XLAL_EFUNC );
/* remaining fields */
if ( time->f0 ) /* TODO: need to figure out what to do here */
XLALPrintWarning( "XLAL Warning - frequency series may have incorrect f0" );
freq->f0 = 0.0; /* FIXME: what if heterodyned data? */
freq->epoch = time->epoch;
freq->deltaF = 1.0 / ( time->deltaT * time->data->length );
/* provide the correct scaling of the result */
for ( k = 0; k < freq->data->length; ++k )
freq->data->data[k] *= time->deltaT;
return 0;
}
int XLALREAL4FreqTimeFFT(
REAL4TimeSeries *time,
const COMPLEX8FrequencySeries *freq,
const REAL4FFTPlan *plan
)
{
UINT4 j;
if ( ! freq || ! time || ! plan )
XLAL_ERROR( XLAL_EFAULT );
if ( freq->deltaF <= 0.0 )
XLAL_ERROR( XLAL_EINVAL );
/* perform the transform */
if ( XLALREAL4ReverseFFT( time->data, freq->data, plan ) == XLAL_FAILURE )
XLAL_ERROR( XLAL_EFUNC );
/* adjust the units */
if ( ! XLALUnitMultiply( &time->sampleUnits, &freq->sampleUnits, &lalHertzUnit ) )
XLAL_ERROR( XLAL_EFUNC );
/* remaining fields */
if ( freq->f0 ) /* TODO: need to figure out what to do here */
XLALPrintWarning( "XLAL Warning - time series may have incorrect f0" );
time->f0 = 0.0; /* FIXME: what if heterodyned data? */
time->epoch = freq->epoch;
time->deltaT = 1.0 / ( freq->deltaF * time->data->length );
/* provide the correct scaling of the result */
for ( j = 0; j < time->data->length; ++j )
time->data->data[j] *= freq->deltaF;
return 0;
}
/** UNDOCUMENTED */
LALUnit * XLALUnitDivide( LALUnit *output, const LALUnit *unit1, const LALUnit *unit2 )
{
LALUnit scratch;
/* invert unit2 and then multiply by unit1 */
if ( ! XLALUnitInvert( &scratch, unit2 ) )
XLAL_ERROR_NULL( XLAL_EFUNC );
if ( ! XLALUnitMultiply( output, unit1, &scratch ) )
XLAL_ERROR_NULL( XLAL_EFUNC );
return output;
}
int XLALCOMPLEX16FreqTimeFFT(
COMPLEX16TimeSeries *time,
const COMPLEX16FrequencySeries *freq,
const COMPLEX16FFTPlan *plan
)
{
COMPLEX16Vector *tmp;
UINT4 k;
if ( ! freq || ! time || ! plan )
XLAL_ERROR( XLAL_EFAULT );
if ( freq->deltaF <= 0.0 )
XLAL_ERROR( XLAL_EINVAL );
if ( plan->sign != 1 )
XLAL_ERROR( XLAL_EINVAL );
/* create temporary workspace */
tmp = XLALCreateCOMPLEX16Vector( freq->data->length );
if ( ! tmp )
XLAL_ERROR( XLAL_EFUNC );
/* pack the frequency series and multiply by deltaF */
for ( k = 0; k < freq->data->length / 2; ++k )
tmp->data[k+(freq->data->length+1)/2] = freq->deltaF * freq->data->data[k];
for ( k = freq->data->length / 2; k < freq->data->length; ++k )
tmp->data[k-freq->data->length/2] = freq->deltaF * freq->data->data[k];
/* perform transform */
if ( XLALCOMPLEX16VectorFFT( time->data, tmp, plan ) == XLAL_FAILURE )
{
int saveErrno = xlalErrno;
xlalErrno = 0;
XLALDestroyCOMPLEX16Vector( tmp );
xlalErrno = saveErrno;
XLAL_ERROR( XLAL_EFUNC );
}
/* destroy temporary workspace */
XLALDestroyCOMPLEX16Vector( tmp );
if ( xlalErrno )
XLAL_ERROR( XLAL_EFUNC );
/* adjust the units */
if ( ! XLALUnitMultiply( &time->sampleUnits, &freq->sampleUnits, &lalHertzUnit ) )
XLAL_ERROR( XLAL_EFUNC );
/* remaining fields */
time->f0 = freq->f0 + freq->deltaF * floor( freq->data->length / 2 );
time->epoch = freq->epoch;
time->deltaT = 1.0 / ( freq->deltaF * freq->data->length );
return 0;
}
int XLALCOMPLEX8TimeFreqFFT(
COMPLEX8FrequencySeries *freq,
const COMPLEX8TimeSeries *time,
const COMPLEX8FFTPlan *plan
)
{
COMPLEX8Vector *tmp;
UINT4 k;
if ( ! freq || ! time || ! plan )
XLAL_ERROR( XLAL_EFAULT );
if ( time->deltaT <= 0.0 )
XLAL_ERROR( XLAL_EINVAL );
if ( plan->sign != -1 )
XLAL_ERROR( XLAL_EINVAL );
/* create temporary workspace */
tmp = XLALCreateCOMPLEX8Vector( time->data->length );
if ( ! tmp )
XLAL_ERROR( XLAL_EFUNC );
/* perform transform */
if ( XLALCOMPLEX8VectorFFT( tmp, time->data, plan ) == XLAL_FAILURE )
{
int saveErrno = xlalErrno;
xlalErrno = 0;
XLALDestroyCOMPLEX8Vector( tmp );
xlalErrno = saveErrno;
XLAL_ERROR( XLAL_EFUNC );
}
/* unpack the frequency series and multiply by deltaT */
for ( k = 0; k < time->data->length / 2; ++k )
freq->data->data[k] = time->deltaT * tmp->data[k+(time->data->length+1)/2];
for ( k = time->data->length / 2; k < time->data->length; ++k )
freq->data->data[k] = time->deltaT * tmp->data[k-time->data->length/2];
/* destroy temporary workspace */
XLALDestroyCOMPLEX8Vector( tmp );
if ( xlalErrno )
XLAL_ERROR( XLAL_EFUNC );
/* adjust the units */
if ( ! XLALUnitMultiply( &freq->sampleUnits, &time->sampleUnits, &lalSecondUnit ) )
XLAL_ERROR( XLAL_EFUNC );
/* remaining fields */
freq->epoch = time->epoch;
freq->deltaF = 1.0 / ( time->deltaT * time->data->length );
freq->f0 = time->f0 - freq->deltaF * floor( time->data->length / 2 );
return 0;
}
static int IMRPhenomCGenerateFDForTD(
COMPLEX16FrequencySeries **htilde, /**< FD waveform */
const REAL8 t0, /**< time of coalescence */
const REAL8 phi0, /**< phase at peak */
const REAL8 deltaF, /**< frequency resolution */
const REAL8 m1, /**< mass of companion 1 [solar masses] */
const REAL8 m2, /**< mass of companion 2 [solar masses] */
//const REAL8 chi, /**< mass-weighted aligned-spin parameter */
const REAL8 f_min, /**< start frequency */
const REAL8 f_max, /**< end frequency */
const REAL8 distance, /**< distance to source (m) */
const BBHPhenomCParams *params, /**< from ComputeIMRPhenomCParams */
const size_t nf /**< Length of frequency vector required */
) {
static LIGOTimeGPS ligotimegps_zero = {0, 0};
size_t i;
INT4 errcode;
const REAL8 M = m1 + m2;
const REAL8 eta = m1 * m2 / (M * M);
/* Memory to temporarily store components of amplitude and phase */
/*
REAL8 phSPA, phPM, phRD, aPM, aRD;
REAL8 wPlusf1, wPlusf2, wMinusf1, wMinusf2, wPlusf0, wMinusf0;
*/
REAL8 phPhenomC = 0.0;
REAL8 aPhenomC = 0.0;
/* compute the amplitude pre-factor */
REAL8 amp0 = 2. * sqrt(5. / (64.*LAL_PI)) * M * LAL_MRSUN_SI * M * LAL_MTSUN_SI / distance;
/* allocate htilde */
size_t n = NextPow2(f_max / deltaF) + 1;
if ( n > nf )
XLAL_ERROR(XLAL_EDOM, "The required length passed as input wont fit the FD waveform\n");
else
n = nf;
*htilde = XLALCreateCOMPLEX16FrequencySeries("htilde: FD waveform", &ligotimegps_zero, 0.0,
deltaF, &lalStrainUnit, n);
memset((*htilde)->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&((*htilde)->sampleUnits), &((*htilde)->sampleUnits), &lalSecondUnit);
if (!(*htilde)) XLAL_ERROR(XLAL_EFUNC);
/* now generate the waveform */
size_t ind_max = (size_t) (f_max / deltaF);
for (i = (size_t) (f_min / deltaF); i < ind_max; i++)
{
REAL8 f = i * deltaF;
errcode = IMRPhenomCGenerateAmpPhase( &aPhenomC, &phPhenomC, f, eta, params );
if( errcode != XLAL_SUCCESS )
XLAL_ERROR(XLAL_EFUNC);
phPhenomC -= 2.*phi0; // factor of 2 b/c phi0 is orbital phase
phPhenomC += 2.*LAL_PI*f*t0; //shifting the coalescence to t=t0
/* generate the waveform */
((*htilde)->data->data)[i] = amp0 * aPhenomC * cos(phPhenomC);
((*htilde)->data->data)[i] += -I * amp0 * aPhenomC * sin(phPhenomC);
}
return XLAL_SUCCESS;
}
static int IMRPhenomCGenerateFD(
COMPLEX16FrequencySeries **htilde, /**< FD waveform */
const REAL8 phi0, /**< phase at peak */
const REAL8 deltaF, /**< frequency resolution */
const REAL8 m1, /**< mass of companion 1 [solar masses] */
const REAL8 m2, /**< mass of companion 2 [solar masses] */
//const REAL8 chi, /**< mass-weighted aligned-spin parameter */
const REAL8 f_min, /**< start frequency */
const REAL8 f_max, /**< end frequency */
const REAL8 distance, /**< distance to source (m) */
const BBHPhenomCParams *params /**< from ComputeIMRPhenomCParams */
) {
LIGOTimeGPS ligotimegps_zero = LIGOTIMEGPSZERO; // = {0, 0}
int errcode = XLAL_SUCCESS;
/*
We can't call XLAL_ERROR() directly with OpenMP on.
Keep track of return codes for each thread and in addition use flush to get out of
the parallel for loop as soon as possible if something went wrong in any thread.
*/
const REAL8 M = m1 + m2;
const REAL8 eta = m1 * m2 / (M * M);
/* Memory to temporarily store components of amplitude and phase */
/*
REAL8 phSPA, phPM, phRD, aPM, aRD;
REAL8 wPlusf1, wPlusf2, wMinusf1, wMinusf2, wPlusf0, wMinusf0;
*/
/* compute the amplitude pre-factor */
REAL8 amp0 = 2. * sqrt(5. / (64.*LAL_PI)) * M * LAL_MRSUN_SI * M * LAL_MTSUN_SI / distance;
/* allocate htilde */
size_t n = NextPow2(f_max / deltaF) + 1;
/* coalesce at t=0 */
XLALGPSAdd(&ligotimegps_zero, -1. / deltaF); // shift by overall length in time
*htilde = XLALCreateCOMPLEX16FrequencySeries("htilde: FD waveform", &ligotimegps_zero, 0.0,
deltaF, &lalStrainUnit, n);
memset((*htilde)->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&((*htilde)->sampleUnits), &((*htilde)->sampleUnits), &lalSecondUnit);
if (!(*htilde)) XLAL_ERROR(XLAL_EFUNC);
size_t ind_min = (size_t) (f_min / deltaF);
size_t ind_max = (size_t) (f_max / deltaF);
/* Set up spline for phase */
gsl_interp_accel *acc = gsl_interp_accel_alloc();
size_t L = ind_max - ind_min;
gsl_spline *phiI = gsl_spline_alloc(gsl_interp_cspline, L);
REAL8 *freqs = XLALMalloc(L*sizeof(REAL8));
REAL8 *phis = XLALMalloc(L*sizeof(REAL8));
/* now generate the waveform */
#pragma omp parallel for
for (size_t i = ind_min; i < ind_max; i++)
{
REAL8 phPhenomC = 0.0;
REAL8 aPhenomC = 0.0;
REAL8 f = i * deltaF;
int per_thread_errcode;
#pragma omp flush(errcode)
if (errcode != XLAL_SUCCESS)
goto skip;
per_thread_errcode = IMRPhenomCGenerateAmpPhase( &aPhenomC, &phPhenomC, f, eta, params );
if (per_thread_errcode != XLAL_SUCCESS) {
errcode = per_thread_errcode;
#pragma omp flush(errcode)
}
phPhenomC -= 2.*phi0; // factor of 2 b/c phi0 is orbital phase
freqs[i-ind_min] = f;
phis[i-ind_min] = -phPhenomC; // PhenomP uses cexp(-I*phPhenomC); want to use same phase adjustment code, so we will flip the sign of the phase
/* generate the waveform */
((*htilde)->data->data)[i] = amp0 * aPhenomC * cos(phPhenomC);
((*htilde)->data->data)[i] += -I * amp0 * aPhenomC * sin(phPhenomC);
skip: /* this statement intentionally left blank */;
}
if( errcode != XLAL_SUCCESS )
XLAL_ERROR(errcode);
/* Correct phasing so we coalesce at t=0 (with the definition of the epoch=-1/deltaF above) */
gsl_spline_init(phiI, freqs, phis, L);
REAL8 f_final = params->fRingDown;
XLAL_PRINT_INFO("f_ringdown = %g\n", f_final);
// Prevent gsl interpolation errors
if (f_final > freqs[L-1])
f_final = freqs[L-1];
if (f_final < freqs[0])
XLAL_ERROR(XLAL_EDOM, "f_ringdown <= f_min\n");
/* Time correction is t(f_final) = 1/(2pi) dphi/df (f_final) */
REAL8 t_corr = gsl_spline_eval_deriv(phiI, f_final, acc) / (2*LAL_PI);
XLAL_PRINT_INFO("t_corr = %g\n", t_corr);
/* Now correct phase */
for (size_t i = ind_min; i < ind_max; i++) {
REAL8 f = i * deltaF;
((*htilde)->data->data)[i] *= cexp(-2*LAL_PI * I * f * t_corr);
}
gsl_spline_free(phiI);
gsl_interp_accel_free(acc);
XLALFree(freqs);
XLALFree(phis);
return XLAL_SUCCESS;
}
/**
* Computes the stationary phase approximation to the Fourier transform of
* a chirp waveform with phase given by \eqref{eq_InspiralFourierPhase_f2}
* and amplitude given by expanding \f$1/\sqrt{\dot{F}}\f$. If the PN order is
* set to -1, then the highest implemented order is used.
*
* See arXiv:0810.5336 and arXiv:astro-ph/0504538 for spin corrections
* to the phasing.
* See arXiv:1303.7412 for spin-orbit phasing corrections at 3 and 3.5PN order
*/
int XLALSimInspiralSpinTaylorF2(
COMPLEX16FrequencySeries **hplus_out, /**< FD hplus waveform */
COMPLEX16FrequencySeries **hcross_out, /**< FD hcross waveform */
const REAL8 phi_ref, /**< reference orbital phase (rad) */
const REAL8 deltaF, /**< frequency resolution */
const REAL8 m1_SI, /**< mass of companion 1 (kg) */
const REAL8 m2_SI, /**< mass of companion 2 (kg) */
const REAL8 s1x, /**< initial value of S1x */
const REAL8 s1y, /**< initial value of S1y */
const REAL8 s1z, /**< initial value of S1z */
const REAL8 lnhatx, /**< initial value of LNhatx */
const REAL8 lnhaty, /**< initial value of LNhaty */
const REAL8 lnhatz, /**< initial value of LNhatz */
const REAL8 fStart, /**< start GW frequency (Hz) */
const REAL8 fEnd, /**< highest GW frequency (Hz) of waveform generation - if 0, end at Schwarzschild ISCO */
const REAL8 f_ref, /**< Reference GW frequency (Hz) - if 0 reference point is coalescence */
const REAL8 r, /**< distance of source (m) */
LALDict *moreParams, /**< Linked list of extra. Pass in NULL (or None in python) for standard waveform. Set "sideband",m to get a single sideband (m=-2..2) */
const INT4 phaseO, /**< twice PN phase order */
const INT4 amplitudeO /**< twice PN amplitude order */
)
{
/* external: SI; internal: solar masses */
const REAL8 m1 = m1_SI / LAL_MSUN_SI;
const REAL8 m2 = m2_SI / LAL_MSUN_SI;
const REAL8 m = m1 + m2;
const REAL8 m_sec = m * LAL_MTSUN_SI; /* total mass in seconds */
const REAL8 eta = m1 * m2 / (m * m);
const REAL8 piM = LAL_PI * m_sec;
const REAL8 vISCO = 1. / sqrt(6.);
const REAL8 fISCO = vISCO * vISCO * vISCO / piM;
REAL8 shft, amp0, f_max;
size_t i, n, iStart;
COMPLEX16 *data_plus = NULL;
COMPLEX16 *data_cross = NULL;
LIGOTimeGPS tC = {0, 0};
/* If f_ref = 0, use f_ref = f_low for everything except the phase offset */
const REAL8 v_ref = f_ref > 0. ? cbrt(piM*f_ref) : cbrt(piM*fStart);
REAL8 alpha, alpha_ref;
COMPLEX16 prec_plus, prec_cross, phasing_fac;
bool enable_precession = true; /* Handle the non-spinning case separately */
int mm;
LALSimInspiralSF2Orientation orientation;
XLALSimInspiralSF2CalculateOrientation(&orientation, m1, m2, v_ref, lnhatx, lnhaty, lnhatz, s1x, s1y, s1z);
LALSimInspiralSF2Coeffs coeffs;
XLALSimInspiralSF2CalculateCoeffs(&coeffs, m1, m2, orientation.chi, orientation.kappa);
enable_precession = orientation.chi != 0. && orientation.kappa != 1. && orientation.kappa != -1.;
alpha_ref = enable_precession ? XLALSimInspiralSF2Alpha(v_ref, coeffs) - orientation.alpha0 : 0.;
COMPLEX16 SBplus[5]; /* complex sideband factors for plus pol, mm=2 is first entry */
COMPLEX16 SBcross[5]; /* complex sideband factors for cross pol, mm=2 is first entry */
REAL8 emission[5]; /* emission factor for each sideband */
if ( !XLALSimInspiralWaveformParamsSidebandIsDefault(moreParams))
{
for(mm = -2; mm <= 2; mm++)
{
SBplus[2-mm] = XLALSimInspiralSF2Polarization(orientation.thetaJ, orientation.psiJ, mm);
SBcross[2-mm] = XLALSimInspiralSF2Polarization(orientation.thetaJ, orientation.psiJ+LAL_PI/4., mm);
}
}
else
{
memset(SBplus, 0, 5 * sizeof(COMPLEX16));
memset(SBcross, 0, 5 * sizeof(COMPLEX16));
mm = (int) XLALSimInspiralWaveformParamsLookupSideband(moreParams);
SBplus[2-mm] = XLALSimInspiralSF2Polarization(orientation.thetaJ, orientation.psiJ, mm);
SBcross[2-mm] = XLALSimInspiralSF2Polarization(orientation.thetaJ, orientation.psiJ+LAL_PI/4., mm);
}
const REAL8 chi1L = orientation.chi*orientation.kappa;
const REAL8 chi1sq = orientation.chi*orientation.chi;
/* FIXME: Cannot yet set QM constant in ChooseFDWaveform interface */
/* phasing coefficients */
PNPhasingSeries pfa;
XLALSimInspiralPNPhasing_F2(&pfa, m1, m2, chi1L, 0., chi1sq, 0., 0., moreParams);
REAL8 pfaN = 0.; REAL8 pfa1 = 0.;
REAL8 pfa2 = 0.; REAL8 pfa3 = 0.; REAL8 pfa4 = 0.;
REAL8 pfa5 = 0.; REAL8 pfl5 = 0.;
REAL8 pfa6 = 0.; REAL8 pfl6 = 0.;
REAL8 pfa7 = 0.; REAL8 pfa8 = 0.;
switch (phaseO)
{
case -1:
case 7:
pfa7 = pfa.v[7];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 6:
pfa6 = pfa.v[6];
pfl6 = pfa.vlogv[6];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 5:
pfa5 = pfa.v[5];
pfl5 = pfa.vlogv[5];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 4:
pfa4 = pfa.v[4];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 3:
pfa3 = pfa.v[3];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 2:
pfa2 = pfa.v[2];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 1:
pfa1 = pfa.v[1];
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case 0:
pfaN = pfa.v[0];
break;
default:
XLAL_ERROR(XLAL_ETYPE, "Invalid phase PN order %d", phaseO);
}
/* Add the zeta factor to the phasing, since it looks like a pN series.
* This is the third Euler angle after alpha and beta.
*/
if (enable_precession)
{
pfa2 += 2.*coeffs.prec_fac*coeffs.zc[0];
pfa3 += 2.*coeffs.prec_fac*coeffs.zc[1];
pfa4 += 2.*coeffs.prec_fac*coeffs.zc[2];
pfl5 += 2.*coeffs.prec_fac*coeffs.zc[3];
pfa6 += 2.*coeffs.prec_fac*coeffs.zc[4];
pfa7 += 2.*coeffs.prec_fac*coeffs.zc[5];
pfa8 += 2.*coeffs.prec_fac*coeffs.zc[6];
}
/* Validate expansion order arguments.
* This must be done here instead of in the OpenMP parallel loop
* because when OpenMP parallelization is turned on, early exits
* from loops (via return or break statements) are not permitted.
*/
/* Validate amplitude PN order. */
if (amplitudeO != 0) { XLAL_ERROR(XLAL_ETYPE, "Invalid amplitude PN order %d", amplitudeO); }
/* energy coefficients - not currently used, but could for MECO
const REAL8 dETaN = 2. * XLALSimInspiralPNEnergy_0PNCoeff(eta);
const REAL8 dETa1 = 2. * XLALSimInspiralPNEnergy_2PNCoeff(eta);
const REAL8 dETa2 = 3. * XLALSimInspiralPNEnergy_4PNCoeff(eta);
const REAL8 dETa3 = 4. * XLALSimInspiralPNEnergy_6PNCoeff(eta);
*/
COMPLEX16FrequencySeries *hplus;
COMPLEX16FrequencySeries *hcross;
/* Perform some initial checks */
if (!hplus_out) XLAL_ERROR(XLAL_EFAULT);
if (!hcross_out) XLAL_ERROR(XLAL_EFAULT);
if (*hplus_out) XLAL_ERROR(XLAL_EFAULT);
if (*hcross_out) XLAL_ERROR(XLAL_EFAULT);
if (m1_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (m2_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (fStart <= 0) XLAL_ERROR(XLAL_EDOM);
if (f_ref < 0) XLAL_ERROR(XLAL_EDOM);
if (r <= 0) XLAL_ERROR(XLAL_EDOM);
/* allocate htilde */
if ( fEnd == 0. ) // End at ISCO
f_max = fISCO;
else // End at user-specified freq.
f_max = fEnd;
n = (size_t) (f_max / deltaF + 1);
XLALGPSAdd(&tC, -1 / deltaF); /* coalesce at t=0 */
/* Allocate hplus and hcross */
hplus = XLALCreateCOMPLEX16FrequencySeries("hplus: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, n);
if (!hplus) XLAL_ERROR(XLAL_EFUNC);
memset(hplus->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&hplus->sampleUnits, &hplus->sampleUnits, &lalSecondUnit);
hcross = XLALCreateCOMPLEX16FrequencySeries("hcross: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, n);
if (!hcross) XLAL_ERROR(XLAL_EFUNC);
memset(hcross->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&hcross->sampleUnits, &hcross->sampleUnits, &lalSecondUnit);
/* extrinsic parameters */
amp0 = -4. * m1 * m2 / r * LAL_MRSUN_SI * LAL_MTSUN_SI * sqrt(LAL_PI/12.L);
amp0 *= sqrt(-2. * XLALSimInspiralPNEnergy_0PNCoeff(eta)/XLALSimInspiralPNFlux_0PNCoeff(eta));
shft = LAL_TWOPI * (tC.gpsSeconds + 1e-9 * tC.gpsNanoSeconds);
/* Fill with non-zero vals from fStart to f_max */
iStart = (size_t) ceil(fStart / deltaF);
data_plus = hplus->data->data;
data_cross = hcross->data->data;
/* Compute the SPA phase at the reference point */
REAL8 ref_phasing = 0.;
if (f_ref > 0.)
{
const REAL8 logvref = log(v_ref);
const REAL8 v2ref = v_ref * v_ref;
const REAL8 v3ref = v_ref * v2ref;
const REAL8 v4ref = v_ref * v3ref;
const REAL8 v5ref = v_ref * v4ref;
ref_phasing = (pfaN + pfa1 * v_ref +pfa2 * v2ref + pfa3 * v3ref + pfa4 * v4ref) / v5ref + (pfa5 + pfl5 * logvref) + (pfa6 + pfl6 * logvref) * v_ref + pfa7 * v2ref + pfa8 * v3ref;
} /* end of if (f_ref > 0.) */
#pragma omp parallel for
for (i = iStart; i < n; i++) {
const REAL8 f = i * deltaF;
const REAL8 v = cbrt(piM*f);
const REAL8 logv = log(v);
const REAL8 v2 = v * v;
const REAL8 v3 = v * v2;
const REAL8 v4 = v * v3;
const REAL8 v5 = v * v4;
REAL8 phasing = (pfaN + pfa1*v + pfa2 * v2 + pfa3 * v3 + pfa4 * v4) / v5 + (pfa5 + pfl5 * logv) + (pfa6 + pfl6 * logv) * v + pfa7 * v2 + pfa8 * v3;
COMPLEX16 amp = amp0 / (v3 * sqrt(v));
alpha = enable_precession ? XLALSimInspiralSF2Alpha(v, coeffs) - alpha_ref : 0.;
COMPLEX16 u = cos(alpha) + 1.0j*sin(alpha);
XLALSimInspiralSF2Emission(emission, v, coeffs);
prec_plus = SBplus[0]*emission[0]*u*u
+ SBplus[1]*emission[1]*u
+ SBplus[2]*emission[2]
+ SBplus[3]*emission[3]/u
+ SBplus[4]*emission[4]/u/u;
prec_cross= SBcross[0]*emission[0]*u*u
+ SBcross[1]*emission[1]*u
+ SBcross[2]*emission[2]
+ SBcross[3]*emission[3]/u
+ SBcross[4]*emission[4]/u/u;
// Note the factor of 2 b/c phi_ref is orbital phase
phasing += shft * f - 2.*phi_ref - ref_phasing - LAL_PI_4;
phasing_fac = cos(phasing) - 1.0j*sin(phasing);
data_plus[i] = amp * prec_plus * phasing_fac;
data_cross[i] = amp * prec_cross * phasing_fac;
}
*hplus_out = hplus;
*hcross_out = hcross;
return XLAL_SUCCESS;
}
void
LALCOMPLEX8AverageSpectrum (
LALStatus *status,
COMPLEX8FrequencySeries *fSeries,
REAL4TimeSeries *tSeries0,
REAL4TimeSeries *tSeries1,
AverageSpectrumParams *params
)
{
UINT4 i, j, k, l; /* seg, ts and freq counters */
UINT4 numSeg; /* number of segments in average */
UINT4 fLength; /* length of requested power spec */
UINT4 tLength; /* length of time series segments */
REAL4Vector *tSegment[2] = {NULL,NULL};
COMPLEX8Vector *fSegment[2] = {NULL,NULL};
REAL4 *tSeriesPtr0,*tSeriesPtr1 ;
REAL4 psdNorm = 0; /* factor to multiply windows data */
REAL4 fftRe0, fftIm0, fftRe1, fftIm1;
LALUnit unit;
/* RAT4 negRootTwo = { -1, 1 }; */
INITSTATUS(status);
XLAL_PRINT_DEPRECATION_WARNING("XLALREAL8AverageSpectrumWelch");
ATTATCHSTATUSPTR (status);
/* check the input and output data pointers are non-null */
ASSERT( fSeries, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( fSeries->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( fSeries->data->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries0, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries0->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries0->data->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries1, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries1->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries1->data->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
/* check the contents of the parameter structure */
ASSERT( params, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( params->window, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( params->window->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( params->window->data->length > 0, status,
TIMEFREQFFTH_EZSEG, TIMEFREQFFTH_MSGEZSEG );
ASSERT( params->plan, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
if ( ! ( params->method == useUnity || params->method == useMean ||
params->method == useMedian ) )
{
ABORT( status, TIMEFREQFFTH_EUAVG, TIMEFREQFFTH_MSGEUAVG );
}
/* check that the window length and fft storage lengths agree */
fLength = fSeries->data->length;
tLength = params->window->data->length;
if ( fLength != tLength / 2 + 1 )
{
ABORT( status, TIMEFREQFFTH_EMISM, TIMEFREQFFTH_MSGEMISM );
}
/* compute the number of segs, check that the length and overlap are valid */
numSeg = (tSeries0->data->length - params->overlap) / (tLength - params->overlap);
if ( (tSeries0->data->length - params->overlap) % (tLength - params->overlap) )
{
ABORT( status, TIMEFREQFFTH_EMISM, TIMEFREQFFTH_MSGEMISM );
}
/* clear the output spectrum and the workspace frequency series */
memset( fSeries->data->data, 0, fLength * sizeof(COMPLEX8) );
/* compute the parameters of the output frequency series data */
fSeries->epoch = tSeries0->epoch;
fSeries->f0 = tSeries0->f0;
fSeries->deltaF = 1.0 / ( (REAL8) tLength * tSeries0->deltaT );
if ( XLALUnitMultiply( &unit, &(tSeries0->sampleUnits), &(tSeries0->sampleUnits) ) == NULL ) {
ABORTXLAL(status);
}
if ( XLALUnitMultiply( &(fSeries->sampleUnits), &unit, &lalSecondUnit ) == NULL ) {
ABORTXLAL(status);
}
/* create temporary storage for the dummy time domain segment */
for (l = 0; l < 2; l ++){
LALCreateVector( status->statusPtr, &tSegment[l], tLength );
CHECKSTATUSPTR( status );
/* create temporary storage for the individual ffts */
LALCCreateVector( status->statusPtr, &fSegment[l], fLength );
CHECKSTATUSPTR( status );}
/* compute each of the power spectra used in the average */
for ( i = 0, tSeriesPtr0 = tSeries0->data->data, tSeriesPtr1 = tSeries1->data->data; i < (UINT4) numSeg; ++i )
{
/* copy the time series data to the dummy segment */
memcpy( tSegment[0]->data, tSeriesPtr0, tLength * sizeof(REAL4) );
memcpy( tSegment[1]->data, tSeriesPtr1, tLength * sizeof(REAL4) );
/* window the time series segment */
for ( j = 0; j < tLength; ++j )
{
tSegment[0]->data[j] *= params->window->data->data[j];
tSegment[1]->data[j] *= params->window->data->data[j];
}
/* compute the fft of the data segment */
LALForwardRealFFT( status->statusPtr, fSegment[0], tSegment[0], params->plan );
CHECKSTATUSPTR (status);
LALForwardRealFFT( status->statusPtr, fSegment[1], tSegment[1], params->plan );
CHECKSTATUSPTR (status);
/* advance the segment data pointer to the start of the next segment */
tSeriesPtr0 += tLength - params->overlap;
tSeriesPtr1 += tLength - params->overlap;
/* compute the psd components */
/*use mean method here*/
/* we can get away with less storage */
for ( k = 0; k < fLength; ++k )
{
fftRe0 = crealf(fSegment[0]->data[k]);
fftIm0 = cimagf(fSegment[0]->data[k]);
fftRe1 = crealf(fSegment[1]->data[k]);
fftIm1 = cimagf(fSegment[1]->data[k]);
fSeries->data->data[k] += fftRe0 * fftRe1 + fftIm0 * fftIm1;
fSeries->data->data[k] += I * (- fftIm0 * fftRe1 + fftRe0 * fftIm1);
}
/* halve the DC and Nyquist components to be consistent with T010095 */
fSeries->data->data[0] /= 2;
fSeries->data->data[fLength - 1] /= 2;
}
/* destroy the dummy time series segment and the fft scratch space */
for (l = 0; l < 2; l ++){
LALDestroyVector( status->statusPtr, &tSegment[l] );
CHECKSTATUSPTR( status );
LALCDestroyVector( status->statusPtr, &fSegment[l] );
CHECKSTATUSPTR( status );}
/* compute the desired average of the spectra */
/* normalization constant for the arithmentic mean */
psdNorm = ( 2.0 * tSeries1->deltaT ) /
( (REAL4) numSeg * params->window->sumofsquares );
/* normalize the psd to it matches the conventions document */
for ( k = 0; k < fLength; ++k )
fSeries->data->data[k] *= psdNorm;
DETATCHSTATUSPTR( status );
RETURN( status );
}
/**
* Computes the stationary phase approximation to the Fourier transform of
* a chirp waveform. The amplitude is given by expanding \f$1/\sqrt{\dot{F}}\f$.
* If the PN order is set to -1, then the highest implemented order is used.
*
* @note f_ref is the GW frequency at which phi_ref is defined. The most common
* choice in the literature is to choose the reference point as "coalescence",
* when the frequency becomes infinite. This is the behavior of the code when
* f_ref==0. If f_ref > 0, phi_ref sets the orbital phase at that GW frequency.
*
* See arXiv:0810.5336 and arXiv:astro-ph/0504538 for spin corrections
* to the phasing.
* See arXiv:1303.7412 for spin-orbit phasing corrections at 3 and 3.5PN order
*
* The spin and tidal order enums are defined in LALSimInspiralWaveformFlags.h
*/
int XLALSimInspiralTaylorF2(
COMPLEX16FrequencySeries **htilde_out, /**< FD waveform */
const REAL8 phi_ref, /**< reference orbital phase (rad) */
const REAL8 deltaF, /**< frequency resolution */
const REAL8 m1_SI, /**< mass of companion 1 (kg) */
const REAL8 m2_SI, /**< mass of companion 2 (kg) */
const REAL8 S1z, /**< z component of the spin of companion 1 */
const REAL8 S2z, /**< z component of the spin of companion 2 */
const REAL8 fStart, /**< start GW frequency (Hz) */
const REAL8 fEnd, /**< highest GW frequency (Hz) of waveform generation - if 0, end at Schwarzschild ISCO */
const REAL8 f_ref, /**< Reference GW frequency (Hz) - if 0 reference point is coalescence */
const REAL8 r, /**< distance of source (m) */
const REAL8 quadparam1, /**< quadrupole deformation parameter of body 1 (dimensionless, 1 for BH) */
const REAL8 quadparam2, /**< quadrupole deformation parameter of body 2 (dimensionless, 1 for BH) */
const REAL8 lambda1, /**< (tidal deformation of body 1)/(mass of body 1)^5 */
const REAL8 lambda2, /**< (tidal deformation of body 2)/(mass of body 2)^5 */
const INT4 phaseO, /**< twice PN phase order */
const INT4 amplitudeO, /**< twice PN amplitude order */
LALDict *p /**< Linked list containing the extra testing GR parameters >**/
)
{
/* external: SI; internal: solar masses */
const REAL8 m1 = m1_SI / LAL_MSUN_SI;
const REAL8 m2 = m2_SI / LAL_MSUN_SI;
const REAL8 m = m1 + m2;
const REAL8 m_sec = m * LAL_MTSUN_SI; /* total mass in seconds */
// const REAL8 eta = m1 * m2 / (m * m);
const REAL8 piM = LAL_PI * m_sec;
const REAL8 vISCO = 1. / sqrt(6.);
const REAL8 fISCO = vISCO * vISCO * vISCO / piM;
//const REAL8 m1OverM = m1 / m;
// const REAL8 m2OverM = m2 / m;
REAL8 shft, f_max;
size_t i, n;
INT4 iStart;
REAL8Sequence *freqs = NULL;
LIGOTimeGPS tC = {0, 0};
int ret;
COMPLEX16FrequencySeries *htilde = NULL;
/* Perform some initial checks */
if (!htilde_out) XLAL_ERROR(XLAL_EFAULT);
if (*htilde_out) XLAL_ERROR(XLAL_EFAULT);
if (m1_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (m2_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (fStart <= 0) XLAL_ERROR(XLAL_EDOM);
if (f_ref < 0) XLAL_ERROR(XLAL_EDOM);
if (r <= 0) XLAL_ERROR(XLAL_EDOM);
/* allocate htilde */
if ( fEnd == 0. ) // End at ISCO
f_max = fISCO;
else // End at user-specified freq.
f_max = fEnd;
if (f_max <= fStart) XLAL_ERROR(XLAL_EDOM);
n = (size_t) (f_max / deltaF + 1);
XLALGPSAdd(&tC, -1 / deltaF); /* coalesce at t=0 */
htilde = XLALCreateCOMPLEX16FrequencySeries("htilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, n);
if (!htilde) XLAL_ERROR(XLAL_EFUNC);
memset(htilde->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&htilde->sampleUnits, &htilde->sampleUnits, &lalSecondUnit);
/* Fill with non-zero vals from fStart to f_max */
iStart = (INT4) ceil(fStart / deltaF);
/* Sequence of frequencies where waveform model is to be evaluated */
freqs = XLALCreateREAL8Sequence(n - iStart);
/* extrinsic parameters */
shft = LAL_TWOPI * (tC.gpsSeconds + 1e-9 * tC.gpsNanoSeconds);
#pragma omp parallel for
for (i = iStart; i < n; i++) {
freqs->data[i-iStart] = i * deltaF;
}
XLALSimInspiralWaveformParamsInsertTidalLambda1(p,lambda1);
XLALSimInspiralWaveformParamsInsertTidalLambda2(p,lambda2);
XLALSimInspiralWaveformParamsInsertdQuadMon1(p,quadparam1-1.);
XLALSimInspiralWaveformParamsInsertdQuadMon2(p,quadparam2-1.);
XLALSimInspiralWaveformParamsInsertPNPhaseOrder(p,phaseO);
XLALSimInspiralWaveformParamsInsertPNAmplitudeOrder(p,amplitudeO);
ret = XLALSimInspiralTaylorF2Core(&htilde, freqs, phi_ref, m1_SI, m2_SI,
S1z, S2z, f_ref, shft, r, p);
XLALDestroyREAL8Sequence(freqs);
*htilde_out = htilde;
return ret;
}
/**
* Core function for computing the ROM waveform.
* Interpolate projection coefficient data and evaluate coefficients at desired (q, chi).
* Construct 1D splines for amplitude and phase.
* Compute strain waveform from amplitude and phase.
*/
static int SEOBNRv1ROMEffectiveSpinCore(
COMPLEX16FrequencySeries **hptilde,
COMPLEX16FrequencySeries **hctilde,
double phiRef,
double fRef,
double distance,
double inclination,
double Mtot_sec,
double q,
double chi,
const REAL8Sequence *freqs_in, /* Frequency points at which to evaluate the waveform (Hz) */
double deltaF
/* If deltaF > 0, the frequency points given in freqs are uniformly spaced with
* spacing deltaF. Otherwise, the frequency points are spaced non-uniformly.
* Then we will use deltaF = 0 to create the frequency series we return. */
)
{
/* Check output arrays */
if(!hptilde || !hctilde)
XLAL_ERROR(XLAL_EFAULT);
SEOBNRROMdata *romdata=&__lalsim_SEOBNRv1ROMSS_data;
if(*hptilde || *hctilde) {
XLALPrintError("(*hptilde) and (*hctilde) are supposed to be NULL, but got %p and %p",(*hptilde),(*hctilde));
XLAL_ERROR(XLAL_EFAULT);
}
int retcode=0;
// 'Nudge' parameter values to allowed boundary values if close by
if (q < 1.0) nudge(&q, 1.0, 1e-6);
if (q > 100.0) nudge(&q, 100.0, 1e-6);
if (chi < -1.0) nudge(&chi, -1.0, 1e-6);
if (chi > 0.6) nudge(&chi, 0.6, 1e-6);
/* If either spin > 0.6, model not available, exit */
if ( chi < -1.0 || chi > 0.6 ) {
XLALPrintError( "XLAL Error - %s: chi smaller than -1 or larger than 0.6!\nSEOBNRv1ROMEffectiveSpin is only available for spins in the range -1 <= a/M <= 0.6.\n", __func__);
XLAL_ERROR( XLAL_EDOM );
}
if (q > 100) {
XLALPrintError( "XLAL Error - %s: q=%lf larger than 100!\nSEOBNRv1ROMEffectiveSpin is only available for q in the range 1 <= q <= 100.\n", __func__,q);
XLAL_ERROR( XLAL_EDOM );
}
if (q >= 20 && q <= 40 && chi < -0.75 && chi > -0.9) {
XLALPrintWarning( "XLAL Warning - %s: q in [20,40] and chi in [-0.8]. The SEOBNRv1 model is not trustworthy in this region!\nSee Fig 15 in CQG 31 195010, 2014 for details.", __func__);
XLAL_ERROR( XLAL_EDOM );
}
/* Find frequency bounds */
if (!freqs_in) XLAL_ERROR(XLAL_EFAULT);
double fLow = freqs_in->data[0];
double fHigh = freqs_in->data[freqs_in->length - 1];
if(fRef==0.0)
fRef=fLow;
/* Convert to geometric units for frequency */
double Mf_ROM_min = fmax(gA[0], gPhi[0]); // lowest allowed geometric frequency for ROM
double Mf_ROM_max = fmin(gA[nk_amp-1], gPhi[nk_phi-1]); // highest allowed geometric frequency for ROM
double fLow_geom = fLow * Mtot_sec;
double fHigh_geom = fHigh * Mtot_sec;
double fRef_geom = fRef * Mtot_sec;
double deltaF_geom = deltaF * Mtot_sec;
// Enforce allowed geometric frequency range
if (fLow_geom < Mf_ROM_min)
XLAL_ERROR(XLAL_EDOM, "Starting frequency Mflow=%g is smaller than lowest frequency in ROM Mf=%g. Starting at lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
if (fHigh_geom == 0)
fHigh_geom = Mf_ROM_max;
else if (fHigh_geom > Mf_ROM_max) {
XLALPrintWarning("Maximal frequency Mf_high=%g is greater than highest ROM frequency Mf_ROM_Max=%g. Using Mf_high=Mf_ROM_Max.", fHigh_geom, Mf_ROM_max);
fHigh_geom = Mf_ROM_max;
}
else if (fHigh_geom < Mf_ROM_min)
XLAL_ERROR(XLAL_EDOM, "End frequency %g is smaller than starting frequency %g!\n", fHigh_geom, fLow_geom);
if (fRef_geom > Mf_ROM_max) {
XLALPrintWarning("Reference frequency Mf_ref=%g is greater than maximal frequency in ROM Mf=%g. Starting at maximal frequency in ROM.\n", fRef_geom, Mf_ROM_max);
fRef_geom = Mf_ROM_max; // If fref > fhigh we reset fref to default value of cutoff frequency.
}
if (fRef_geom < Mf_ROM_min) {
XLALPrintWarning("Reference frequency Mf_ref=%g is smaller than lowest frequency in ROM Mf=%g. Starting at lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
fRef_geom = Mf_ROM_min;
}
/* Internal storage for w.f. coefficiencts */
SEOBNRROMdata_coeff *romdata_coeff=NULL;
SEOBNRROMdata_coeff_Init(&romdata_coeff);
REAL8 amp_pre;
/* Interpolate projection coefficients and evaluate them at (q,chi) */
retcode=TP_Spline_interpolation_2d(
q, // Input: q-value for which projection coefficients should be evaluated
chi, // Input: chi-value for which projection coefficients should be evaluated
romdata->cvec_amp, // Input: data for spline coefficients for amplitude
romdata->cvec_phi, // Input: data for spline coefficients for phase
romdata->cvec_amp_pre, // Input: data for spline coefficients for amplitude prefactor
romdata_coeff->c_amp, // Output: interpolated projection coefficients for amplitude
romdata_coeff->c_phi, // Output: interpolated projection coefficients for phase
&_pre // Output: interpolated amplitude prefactor
);
if(retcode!=0) {
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
XLAL_ERROR(retcode, "Parameter-space interpolation failed.");
}
// Compute function values of amplitude an phase on sparse frequency points by evaluating matrix vector products
// amp_pts = B_A^T . c_A
// phi_pts = B_phi^T . c_phi
gsl_vector* amp_f = gsl_vector_alloc(nk_amp);
gsl_vector* phi_f = gsl_vector_alloc(nk_phi);
gsl_blas_dgemv(CblasTrans, 1.0, romdata->Bamp, romdata_coeff->c_amp, 0.0, amp_f);
gsl_blas_dgemv(CblasTrans, 1.0, romdata->Bphi, romdata_coeff->c_phi, 0.0, phi_f);
// Setup 1d splines in frequency
gsl_interp_accel *acc_amp = gsl_interp_accel_alloc();
gsl_spline *spline_amp = gsl_spline_alloc(gsl_interp_cspline, nk_amp);
gsl_spline_init(spline_amp, gA, gsl_vector_const_ptr(amp_f,0), nk_amp);
gsl_interp_accel *acc_phi = gsl_interp_accel_alloc();
gsl_spline *spline_phi = gsl_spline_alloc(gsl_interp_cspline, nk_phi);
gsl_spline_init(spline_phi, gPhi, gsl_vector_const_ptr(phi_f,0), nk_phi);
size_t npts = 0;
LIGOTimeGPS tC = {0, 0};
UINT4 offset = 0; // Index shift between freqs and the frequency series
REAL8Sequence *freqs = NULL;
if (deltaF > 0) { // freqs contains uniform frequency grid with spacing deltaF; we start at frequency 0
/* Set up output array with size closest power of 2 */
npts = NextPow2(fHigh_geom / deltaF_geom) + 1;
if (fHigh_geom < fHigh * Mtot_sec) /* Resize waveform if user wants f_max larger than cutoff frequency */
npts = NextPow2(fHigh * Mtot_sec / deltaF_geom) + 1;
XLALGPSAdd(&tC, -1. / deltaF); /* coalesce at t=0 */
*hptilde = XLALCreateCOMPLEX16FrequencySeries("hptilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, npts);
*hctilde = XLALCreateCOMPLEX16FrequencySeries("hctilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, npts);
// Recreate freqs using only the lower and upper bounds
UINT4 iStart = (UINT4) ceil(fLow_geom / deltaF_geom);
UINT4 iStop = (UINT4) ceil(fHigh_geom / deltaF_geom);
freqs = XLALCreateREAL8Sequence(iStop - iStart);
if (!freqs) {
XLAL_ERROR(XLAL_EFUNC, "Frequency array allocation failed.");
}
for (UINT4 i=iStart; i<iStop; i++)
freqs->data[i-iStart] = i*deltaF_geom;
offset = iStart;
} else { // freqs contains frequencies with non-uniform spacing; we start at lowest given frequency
npts = freqs_in->length;
*hptilde = XLALCreateCOMPLEX16FrequencySeries("hptilde: FD waveform", &tC, fLow, 0, &lalStrainUnit, npts);
*hctilde = XLALCreateCOMPLEX16FrequencySeries("hctilde: FD waveform", &tC, fLow, 0, &lalStrainUnit, npts);
offset = 0;
freqs = XLALCreateREAL8Sequence(freqs_in->length);
if (!freqs) {
XLAL_ERROR(XLAL_EFUNC, "Frequency array allocation failed.");
}
for (UINT4 i=0; i<freqs_in->length; i++)
freqs->data[i] = freqs_in->data[i] * Mtot_sec;
}
if (!(*hptilde) || !(*hctilde))
{
XLALDestroyREAL8Sequence(freqs);
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(acc_amp);
gsl_interp_accel_free(acc_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
XLAL_ERROR(XLAL_EFUNC, "Waveform allocation failed.");
}
memset((*hptilde)->data->data, 0, npts * sizeof(COMPLEX16));
memset((*hctilde)->data->data, 0, npts * sizeof(COMPLEX16));
XLALUnitMultiply(&(*hptilde)->sampleUnits, &(*hptilde)->sampleUnits, &lalSecondUnit);
XLALUnitMultiply(&(*hctilde)->sampleUnits, &(*hctilde)->sampleUnits, &lalSecondUnit);
COMPLEX16 *pdata=(*hptilde)->data->data;
COMPLEX16 *cdata=(*hctilde)->data->data;
REAL8 cosi = cos(inclination);
REAL8 pcoef = 0.5*(1.0 + cosi*cosi);
REAL8 ccoef = cosi;
REAL8 s = 1.0/sqrt(2.0); // Scale polarization amplitude so that strain agrees with FFT of SEOBNRv1
double Mtot = Mtot_sec / LAL_MTSUN_SI;
double amp0 = Mtot * amp_pre * Mtot_sec * LAL_MRSUN_SI / (distance); // Correct overall amplitude to undo mass-dependent scaling used in single-spin ROM
// Evaluate reference phase for setting phiRef correctly
double phase_change = gsl_spline_eval(spline_phi, fRef_geom, acc_phi) - 2*phiRef;
// Assemble waveform from aplitude and phase
for (UINT4 i=0; i<freqs->length; i++) { // loop over frequency points in sequence
double f = freqs->data[i];
if (f > Mf_ROM_max) continue; // We're beyond the highest allowed frequency; since freqs may not be ordered, we'll just skip the current frequency and leave zero in the buffer
int j = i + offset; // shift index for frequency series if needed
double A = gsl_spline_eval(spline_amp, f, acc_amp);
double phase = gsl_spline_eval(spline_phi, f, acc_phi) - phase_change;
COMPLEX16 htilde = s*amp0*A * cexp(I*phase);
pdata[j] = pcoef * htilde;
cdata[j] = -I * ccoef * htilde;
}
/* Correct phasing so we coalesce at t=0 (with the definition of the epoch=-1/deltaF above) */
// Get SEOBNRv1 ringdown frequency for 22 mode
double Mf_final = SEOBNRROM_Ringdown_Mf_From_Mtot_q(Mtot_sec, q, chi, chi, SEOBNRv1);
UINT4 L = freqs->length;
// prevent gsl interpolation errors
if (Mf_final > freqs->data[L-1])
Mf_final = freqs->data[L-1];
if (Mf_final < freqs->data[0])
{
XLALDestroyREAL8Sequence(freqs);
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(acc_amp);
gsl_interp_accel_free(acc_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
XLAL_ERROR(XLAL_EDOM, "f_ringdown < f_min");
}
// Time correction is t(f_final) = 1/(2pi) dphi/df (f_final)
// We compute the dimensionless time correction t/M since we use geometric units.
REAL8 t_corr = gsl_spline_eval_deriv(spline_phi, Mf_final, acc_phi) / (2*LAL_PI);
// Now correct phase
for (UINT4 i=0; i<freqs->length; i++) { // loop over frequency points in sequence
double f = freqs->data[i] - fRef_geom;
int j = i + offset; // shift index for frequency series if needed
pdata[j] *= cexp(-2*LAL_PI * I * f * t_corr);
cdata[j] *= cexp(-2*LAL_PI * I * f * t_corr);
}
XLALDestroyREAL8Sequence(freqs);
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(acc_amp);
gsl_interp_accel_free(acc_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
SEOBNRROMdata_coeff_Cleanup(romdata_coeff);
return(XLAL_SUCCESS);
}
void
LALStochasticOptimalFilter(
LALStatus *status,
COMPLEX8FrequencySeries *optimalFilter,
const StochasticOptimalFilterInput *input,
const REAL4WithUnits *lambda)
{
REAL4 mygamma;
REAL4 omega;
COMPLEX8 p1HWInv;
COMPLEX8 p2HWInv;
COMPLEX8 *cPtrOptimalFilter;
REAL8 f;
REAL8 f0;
REAL8 f3;
REAL8 deltaF;
/* normalization factor */
UINT4 i;
REAL8 realFactor;
UINT4 length;
RAT4 power;
LALUnit tmpUnit1, tmpUnit2, checkUnit;
/* initialize status pointer */
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* ERROR CHECKING ----------------------------------------------------- */
/***** check for null pointers *****/
/* input structure */
ASSERT(input != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* output structure */
ASSERT(optimalFilter != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* overlap member of input */
ASSERT(input->overlapReductionFunction != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* omega member of input */
ASSERT(input->omegaGW != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* half-calibrated inverse noise 1 of input */
ASSERT(input->halfCalibratedInverseNoisePSD1 != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* half-calibrated inverse noise 2 of input */
ASSERT(input->halfCalibratedInverseNoisePSD2 != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of overlap */
ASSERT(input->overlapReductionFunction->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of omega */
ASSERT(input->omegaGW->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of half-calibrated inverse noise 1 */
ASSERT(input->halfCalibratedInverseNoisePSD1->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of half-calibrated inverse noise 2 */
ASSERT(input->halfCalibratedInverseNoisePSD2->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of output */
ASSERT(optimalFilter->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of overlap */
ASSERT(input->overlapReductionFunction->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of omega */
ASSERT(input->omegaGW->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of half calibrated inverse noise 1 */
ASSERT(input->halfCalibratedInverseNoisePSD1->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of half calibrated inverse noise 2 */
ASSERT(input->halfCalibratedInverseNoisePSD2->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of output structure */
ASSERT(optimalFilter->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/*** done with null pointers ***/
/* extract parameters from overlap */
length = input->overlapReductionFunction->data->length;
f0 = input->overlapReductionFunction->f0;
deltaF = input->overlapReductionFunction->deltaF;
/**** check for legality ****/
/* length must be positive */
ASSERT(length != 0, status, \
STOCHASTICCROSSCORRELATIONH_EZEROLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN);
/* start frequency must not be negative */
if (f0 < 0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_ENEGFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGENEGFMIN );
}
/* frequency spacing must be positive */
ASSERT(deltaF > 0, status, \
STOCHASTICCROSSCORRELATIONH_ENONPOSDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAF);
/** check for mismatches **/
/* length */
if (input->omegaGW->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
if (input->halfCalibratedInverseNoisePSD1->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
if (input->halfCalibratedInverseNoisePSD2->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
if (optimalFilter->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
/* initial frequency */
if (input->omegaGW->f0 != f0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMFMIN);
}
if (input->halfCalibratedInverseNoisePSD1->f0 != f0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMFMIN);
}
if (input->halfCalibratedInverseNoisePSD2->f0 != f0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMFMIN);
}
/* frequency spacing */
if (input->omegaGW->deltaF != deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGEMMDELTAF);
}
if (input->halfCalibratedInverseNoisePSD1->deltaF != deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGEMMDELTAF);
}
if (input->halfCalibratedInverseNoisePSD2->deltaF != deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGEMMDELTAF);
}
/* EVERYHTING OKAY HERE! ---------------------------------------------- */
/* assign parameters to optimalFilter */
optimalFilter->f0 = f0;
optimalFilter->deltaF = deltaF;
optimalFilter->epoch.gpsSeconds = 0;
optimalFilter->epoch.gpsNanoSeconds = 0;
strncpy(optimalFilter->name, "Optimal filter for stochastic search", \
LALNameLength);
/* All the powers we use are integers, so we can do this once here */
power.denominatorMinusOne = 0;
/* Set tmpUnit1 to dims of Omega/H0^2 ******/
/* First, set it to dims of H0 */
tmpUnit1 = lalHertzUnit;
/* Account for scaled units of Hubble constant */
tmpUnit1.powerOfTen -= 18;
/* Now set tmpUnit2 to dims of H0^-2 */
power.numerator = -2;
if (XLALUnitRaiseRAT4(&tmpUnit2, &tmpUnit1, &power) == NULL) {
ABORTXLAL(status);
}
if (XLALUnitMultiply(&tmpUnit1, &(input->omegaGW->sampleUnits), &tmpUnit2) == NULL) {
ABORTXLAL(status);
}
/* Now tmpUnit1 has units of Omega/H0^2 */
/* Now we need to set the Optimal Filter Units equal to the units of */
/* lambda*mygamma*Omega*f^-3*P1HW^-1*P2HW^-1) */
if (XLALUnitMultiply(&tmpUnit1, &(input->halfCalibratedInverseNoisePSD1->sampleUnits), &(input->halfCalibratedInverseNoisePSD2->sampleUnits)) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit1 now holds the units of P1HW^-1*P2HW^-1 */
power.numerator = -3;
if (XLALUnitRaiseRAT4(&tmpUnit2, &lalHertzUnit, &power) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit2 now holds the units of f^-3 */
if (XLALUnitMultiply(&checkUnit, &tmpUnit1, &tmpUnit2) == NULL) {
ABORTXLAL(status);
}
/* checkUnit now holds the units of f^-3*P1HW^-1*P2HW^-1) */
if (XLALUnitMultiply(&tmpUnit1, &checkUnit, &(input->omegaGW->sampleUnits)) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit1 now holds units of Omega*f^-3*P1HW^-1*P2HW^-1) */
if (XLALUnitMultiply(&tmpUnit2, &tmpUnit1, &(input->overlapReductionFunction->sampleUnits)) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit2 now holds units of mygamma*Omega*f^-3*P1HW^-1*P2HW^-1) */
if (XLALUnitMultiply(&(optimalFilter->sampleUnits), &(lambda->units), &tmpUnit2) == NULL) {
ABORTXLAL(status);
}
/* Done with unit manipulation */
optimalFilter->data->data[0] = 0.0;
/* calculate optimal filter values */
for (i = (f0 == 0 ? 1 : 0) ; i < length; ++i)
{
f = f0 + deltaF * (REAL8)i;
f3 = f * f * f;
omega = input->omegaGW->data->data[i];
mygamma = input->overlapReductionFunction->data->data[i];
p1HWInv = input->halfCalibratedInverseNoisePSD1->data->data[i];
p2HWInv = input->halfCalibratedInverseNoisePSD2->data->data[i];
cPtrOptimalFilter = &(optimalFilter->data->data[i]);
realFactor = (mygamma * omega * lambda->value) / f3;
*(cPtrOptimalFilter) = crectf( realFactor * ((crealf(p1HWInv) * crealf(p2HWInv)) + (cimagf(p1HWInv) * cimagf(p2HWInv))), realFactor * ((crealf(p1HWInv) * cimagf(p2HWInv)) - (cimagf(p1HWInv) * crealf(p2HWInv))) );
}
DETATCHSTATUSPTR(status);
RETURN(status);
} /* LALStochasticOptimalFilter() */
/**
* \author Creighton, T. D.
*
* \brief Computes the response of a detector to a coherent gravitational wave.
*
* This function takes a quasiperiodic gravitational waveform given in
* <tt>*signal</tt>, and estimates the corresponding response of the
* detector whose position, orientation, and transfer function are
* specified in <tt>*detector</tt>. The result is stored in
* <tt>*output</tt>.
*
* The fields <tt>output-\>epoch</tt>, <tt>output->deltaT</tt>, and
* <tt>output-\>data</tt> must already be set, in order to specify the time
* period and sampling rate for which the response is required. If
* <tt>output-\>f0</tt> is nonzero, idealized heterodyning is performed (an
* amount \f$2\pi f_0(t-t_0)\f$ is subtracted from the phase before computing
* the sinusoid, where \f$t_0\f$ is the heterodyning epoch defined in
* \c detector). For the input signal, <tt>signal-\>h</tt> is ignored,
* and the signal is treated as zero at any time for which either
* <tt>signal-\>a</tt> or <tt>signal-\>phi</tt> is not defined.
*
* This routine will convert <tt>signal-\>position</tt> to equatorial
* coordinates, if necessary.
*
* ### Algorithm ###
*
* The routine first accounts for the time delay between the detector and
* the solar system barycentre, based on the detector position
* information stored in <tt>*detector</tt> and the propagation direction
* specified in <tt>*signal</tt>. Values of the propagation delay are
* precomuted at fixed intervals and stored in a table, with the
* intervals \f$\Delta T_\mathrm{delay}\f$ chosen such that the value
* interpolated from adjacent table entries will never differ from the
* true value by more than some timing error \f$\sigma_T\f$. This implies
* that:
* \f[
* \Delta T_\mathrm{delay} \leq \sqrt{
* \frac{8\sigma_T}{\max\{a/c\}} } \; ,
* \f]
* where \f$\max\{a/c\}=1.32\times10^{-10}\mathrm{s}^{-1}\f$ is the maximum
* acceleration of an Earth-based detector in the barycentric frame. The
* total propagation delay also includes Einstein and Shapiro delay, but
* these are more slowly varying and thus do not constrain the table
* spacing. At present, a 400s table spacing is hardwired into the code,
* implying \f$\sigma_T\approx3\mu\f$s, comparable to the stated accuracy of
* <tt>LALBarycenter()</tt>.
*
* Next, the polarization response functions of the detector
* \f$F_{+,\times}(\alpha,\delta)\f$ are computed for every 10 minutes of the
* signal's duration, using the position of the source in <tt>*signal</tt>,
* the detector information in <tt>*detector</tt>, and the function
* <tt>LALComputeDetAMResponseSeries()</tt>. Subsequently, the
* polarization functions are estimated for each output sample by
* interpolating these precomputed values. This guarantees that the
* interpolated value is accurate to \f$\sim0.1\%\f$.
*
* Next, the frequency response of the detector is estimated in the
* quasiperiodic limit as follows:
* <ul>
* <li> At each sample point in <tt>*output</tt>, the propagation delay is
* computed and added to the sample time, and the instantaneous
* amplitudes \f$A_1\f$, \f$A_2\f$, frequency \f$f\f$, phase \f$\phi\f$, and polarization
* shift \f$\Phi\f$ are found by interpolating the nearest values in
* <tt>signal-\>a</tt>, <tt>signal-\>f</tt>, <tt>signal-\>phi</tt>, and
* <tt>signal-\>shift</tt>, respectively. If <tt>signal-\>f</tt> is not
* defined at that point in time, then \f$f\f$ is estimated by differencing
* the two nearest values of \f$\phi\f$, as \f$f\approx\Delta\phi/2\pi\Delta
* t\f$. If <tt>signal-\>shift</tt> is not defined, then \f$\Phi\f$ is treated as
* zero.</li>
* <li> The complex transfer function of the detector the frequency \f$f\f$
* is found by interpolating <tt>detector-\>transfer</tt>. The amplitude of
* the transfer function is multiplied with \f$A_1\f$ and \f$A_2\f$, and the
* phase of the transfer function is added to \f$\phi\f$,</li>
* <li> The plus and cross contributions \f$o_+\f$, \f$o_\times\f$ to the
* detector output are computed as in \eqref{eq_quasiperiodic_hpluscross}
* of \ref PulsarSimulateCoherentGW_h, but
* using the response-adjusted amplitudes and phase.</li>
* <li> The final detector response \f$o\f$ is computed as
* \f$o=(o_+F_+)+(o_\times F_\times)\f$.</li>
* </ul>
*
* ### A note on interpolation: ###
*
* Much of the computational work in this routine involves interpolating
* various time series to find their values at specific output times.
* The algorithm is summarized below.
*
* Let \f$A_j = A( t_A + j\Delta t_A )\f$ be a sampled time series, which we
* want to resample at new (output) time intervals \f$t_k = t_0 + k\Delta
* t\f$. We first precompute the following quantities:
* \f{eqnarray}{
* t_\mathrm{off} & = & \frac{t_0-t_A}{\Delta t_A} \; , \\
* dt & = & \frac{\Delta t}{\Delta t_A} \; .
* \f}
* Then, for each output sample time \f$t_k\f$, we compute:
* \f{eqnarray}{
* t & = & t_\mathrm{off} + k \times dt \; , \\
* j & = & \lfloor t \rfloor \; , \\
* f & = & t - j \; ,
* \f}
* where \f$\lfloor x\rfloor\f$ is the "floor" function; i.e.\ the largest
* integer \f$\leq x\f$. The time series sampled at the new time is then:
* \f[
* A(t_k) = f \times A_{j+1} + (1-f) \times A_j \; .
* \f]
*
* ### Notes ###
*
* The major computational hit in this routine comes from computing the
* sine and cosine of the phase angle in
* \eqref{eq_quasiperiodic_hpluscross} of
* \ref PulsarSimulateCoherentGW_h. For better online performance, these can
* be replaced by other (approximate) trig functions. Presently the code
* uses the native \c libm functions by default, or the function
* <tt>sincosp()</tt> in \c libsunmath \e if this function is
* available \e and the constant \c ONLINE is defined.
* Differences at the level of 0.01 begin to appear only for phase
* arguments greater than \f$10^{14}\f$ or so (corresponding to over 500
* years between phase epoch and observation time for frequencies of
* around 1kHz).
*
* To activate this feature, be sure that <tt>sunmath.h</tt> and
* \c libsunmath are on your system, and add <tt>-DONLINE</tt> to the
* <tt>--with-extra-cppflags</tt> configuration argument. In future this
* flag may be used to turn on other efficient trig algorithms on other
* (non-Solaris) platforms.
*
*/
void
LALPulsarSimulateCoherentGW( LALStatus *stat,
REAL4TimeSeries *output,
PulsarCoherentGW *CWsignal,
PulsarDetectorResponse *detector )
{
INT4 i, n; /* index over output->data, and its final value */
INT4 nMax; /* used to store limits on index ranges */
INT4 fInit, fFinal; /* index range for which CWsignal->f is defined */
INT4 shiftInit, shiftFinal; /* ditto for CWsignal->shift */
UINT4 dtDelayBy2; /* delay table half-interval (s) */
UINT4 dtPolBy2; /* polarization table half-interval (s) */
REAL4 *outData; /* pointer to output data */
REAL8 delayMin, delayMax; /* min and max values of time delay */
SkyPosition source; /* source sky position */
BOOLEAN transfer; /* 1 if transfer function is specified */
BOOLEAN fFlag = 0; /* 1 if frequency left detector->transfer range */
BOOLEAN pFlag = 0; /* 1 if frequency was estimated from phase */
/* get delay table and polaristion tables half intervals if defined (>0) in
the PulsarCoherentGW structure otherwise default to 400s for dtDelatBy2 and 300s
for dtPolBy2 */
dtDelayBy2 = CWsignal->dtDelayBy2 > 0 ? CWsignal->dtDelayBy2 : 400;
dtPolBy2 = CWsignal->dtPolBy2 > 0 ? CWsignal->dtPolBy2 : 300;
/* The amplitude, frequency, phase, polarization shift, polarization
response, and propagation delay are stored in arrays that must be
interpolated. For a quantity x, we define a pointer xData to the
data array. At some time t measured in units of output->deltaT,
the interpolation point in xData is given by ( xOff + t*xDt ),
where xOff is an offset and xDt is a relative sampling rate. */
LALDetAMResponseSeries polResponse;
REAL8Vector *delay = NULL;
REAL4 *aData, *fData, *shiftData, *plusData, *crossData;
REAL8 *phiData, *delayData;
REAL8 aOff, fOff, phiOff, shiftOff, polOff, delayOff;
REAL8 aDt, fDt, phiDt, shiftDt, polDt, delayDt;
/* Frequencies in the detector transfer function are interpolated
similarly, except everything is normalized with respect to
detector->transfer->deltaF. */
REAL4Vector *aTransfer = NULL;
REAL4Vector *phiTransfer = NULL;
REAL4Vector *phiTemp = NULL;
REAL4 *aTransData = NULL, *phiTransData = NULL;
REAL8 f0 = 1.0;
REAL8 phiFac = 1.0, fFac = 1.0;
/* Heterodyning phase factor LAL_TWOPI*output->f0*output->deltaT,
and phase offset at the start of the series
LAL_TWOPI*output->f0*(time offset). */
REAL8 heteroFac, phi0;
/* Variables required by the TCENTRE() macro, above. */
REAL8 realIndex;
INT4 intIndex;
REAL8 indexFrac;
INITSTATUS(stat);
ATTATCHSTATUSPTR( stat );
/* Make sure parameter structures and their fields exist. */
ASSERT( CWsignal, stat, SIMULATECOHERENTGWH_ENUL,
SIMULATECOHERENTGWH_MSGENUL );
if ( !( CWsignal->a ) ) {
ABORT( stat, SIMULATECOHERENTGWH_ESIG,
SIMULATECOHERENTGWH_MSGESIG );
}
ASSERT( CWsignal->a->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( CWsignal->a->data->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
if ( !( CWsignal->phi ) ) {
ABORT( stat, SIMULATECOHERENTGWH_ESIG,
SIMULATECOHERENTGWH_MSGESIG );
}
ASSERT( CWsignal->phi->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( CWsignal->phi->data->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
if ( CWsignal->f ) {
ASSERT( CWsignal->f->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( CWsignal->f->data->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
}
if ( CWsignal->shift ) {
ASSERT( CWsignal->shift->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( CWsignal->shift->data->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
}
ASSERT( detector, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
if ( ( transfer = ( detector->transfer != NULL ) ) ) {
ASSERT( detector->transfer->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( detector->transfer->data->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
}
ASSERT( output, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( output->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
ASSERT( output->data->data, stat,
SIMULATECOHERENTGWH_ENUL, SIMULATECOHERENTGWH_MSGENUL );
/* Check dimensions of amplitude array. */
ASSERT( CWsignal->a->data->vectorLength == 2, stat,
SIMULATECOHERENTGWH_EDIM, SIMULATECOHERENTGWH_MSGEDIM );
/* Make sure we never divide by zero. */
ASSERT( CWsignal->a->deltaT != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
ASSERT( CWsignal->phi->deltaT != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
aDt = output->deltaT / CWsignal->a->deltaT;
phiDt = output->deltaT / CWsignal->phi->deltaT;
ASSERT( aDt != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
ASSERT( phiDt != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
if ( CWsignal->f ) {
ASSERT( CWsignal->f->deltaT != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
fDt = output->deltaT / CWsignal->f->deltaT;
ASSERT( fDt != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
} else
fDt = 0.0;
if ( CWsignal->shift ) {
ASSERT( CWsignal->shift->deltaT != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
shiftDt = output->deltaT / CWsignal->shift->deltaT;
ASSERT( shiftDt != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
} else
shiftDt = 0.0;
if ( transfer ) {
ASSERT( detector->transfer->deltaF != 0.0, stat,
SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
fFac = 1.0 / detector->transfer->deltaF;
phiFac = fFac / ( LAL_TWOPI*CWsignal->phi->deltaT );
f0 = detector->transfer->f0/detector->transfer->deltaF;
}
heteroFac = LAL_TWOPI*output->f0*output->deltaT;
phi0 = (REAL8)( output->epoch.gpsSeconds -
detector->heterodyneEpoch.gpsSeconds );
phi0 += 0.000000001*(REAL8)( output->epoch.gpsNanoSeconds -
detector->heterodyneEpoch.gpsNanoSeconds );
phi0 *= LAL_TWOPI*output->f0;
if ( phi0 > 1.0/LAL_REAL8_EPS ) {
LALWarning( stat, "REAL8 arithmetic is not sufficient to maintain"
" heterodyne phase to within a radian." );
}
/* Check units on input, and set units on output. */
{
ASSERT( XLALUnitCompare( &(CWsignal->f->sampleUnits), &lalHertzUnit ) == 0, stat, SIMULATECOHERENTGWH_EUNIT, SIMULATECOHERENTGWH_MSGEUNIT );
ASSERT( XLALUnitCompare( &(CWsignal->phi->sampleUnits), &lalDimensionlessUnit ) == 0, stat, SIMULATECOHERENTGWH_EUNIT, SIMULATECOHERENTGWH_MSGEUNIT );
if( CWsignal->shift ) {
ASSERT( XLALUnitCompare( &(CWsignal->shift->sampleUnits), &lalDimensionlessUnit ) == 0, stat, SIMULATECOHERENTGWH_EUNIT, SIMULATECOHERENTGWH_MSGEUNIT );
}
if ( transfer ) {
if ( XLALUnitMultiply( &(output->sampleUnits), &(CWsignal->a->sampleUnits), &(detector->transfer->sampleUnits) ) == NULL ) {
ABORT( stat, SIMULATECOHERENTGWH_EUNIT, SIMULATECOHERENTGWH_MSGEUNIT );
}
} else {
output->sampleUnits = CWsignal->a->sampleUnits;
}
snprintf( output->name, LALNameLength, "response to %s", CWsignal->a->name );
}
/* Define temporary variables to access the data of CWsignal->a,
CWsignal->f, and CWsignal->phi. */
aData = CWsignal->a->data->data;
INT4 aLen = CWsignal->a->data->length * CWsignal->a->data->vectorLength;
phiData = CWsignal->phi->data->data;
INT4 phiLen = CWsignal->phi->data->length;
outData = output->data->data;
INT4 fLen=0, shiftLen=0;
if ( CWsignal->f )
{
fData = CWsignal->f->data->data;
fLen = CWsignal->f->data->length;
}
else
{
fData = NULL;
}
if ( CWsignal->shift )
{
shiftData = CWsignal->shift->data->data;
shiftLen = CWsignal->shift->data->length;
}
else
{
shiftData = NULL;
}
/* Convert source position to equatorial coordinates, if
required. */
if ( detector->site ) {
source = CWsignal->position;
if ( source.system != COORDINATESYSTEM_EQUATORIAL ) {
ConvertSkyParams params; /* parameters for conversion */
EarthPosition location; /* location of detector */
params.gpsTime = &( output->epoch );
params.system = COORDINATESYSTEM_EQUATORIAL;
if ( source.system == COORDINATESYSTEM_HORIZON ) {
params.zenith = &( location.geodetic );
location.x = detector->site->location[0];
location.y = detector->site->location[1];
location.z = detector->site->location[2];
TRY( LALGeocentricToGeodetic( stat->statusPtr, &location ),
stat );
}
TRY( LALConvertSkyCoordinates( stat->statusPtr, &source,
&source, ¶ms ), stat );
}
}
/* Generate the table of propagation delays.
dtDelayBy2 = (UINT4)( 38924.9/sqrt( output->f0 +
1.0/output->deltaT ) ); */
delayDt = output->deltaT/( 2.0*dtDelayBy2 );
nMax = (UINT4)( output->data->length*delayDt ) + 3;
TRY( LALDCreateVector( stat->statusPtr, &delay, nMax ), stat );
delayData = delay->data;
/* Compute delay from solar system barycentre. */
if ( detector->site && detector->ephemerides ) {
LIGOTimeGPS gpsTime; /* detector time when we compute delay */
EarthState state; /* Earth position info at that time */
BarycenterInput input; /* input structure to LALBarycenter() */
EmissionTime emit; /* output structure from LALBarycenter() */
/* Arrange nested pointers, and set initial values. */
gpsTime = input.tgps = output->epoch;
gpsTime.gpsSeconds -= dtDelayBy2;
input.tgps.gpsSeconds -= dtDelayBy2;
input.site = *(detector->site);
for ( i = 0; i < 3; i++ )
input.site.location[i] /= LAL_C_SI;
input.alpha = source.longitude;
input.delta = source.latitude;
input.dInv = 0.0;
delayMin = delayMax = 1.1*LAL_AU_SI/( LAL_C_SI*output->deltaT );
delayMax *= -1;
/* Compute table. */
for ( i = 0; i < nMax; i++ ) {
REAL8 tDelay; /* propagation time */
LALBarycenterEarth( stat->statusPtr, &state, &gpsTime,
detector->ephemerides );
BEGINFAIL( stat )
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
ENDFAIL( stat );
LALBarycenter( stat->statusPtr, &emit, &input, &state );
BEGINFAIL( stat )
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
ENDFAIL( stat );
delayData[i] = tDelay = emit.deltaT/output->deltaT;
if ( tDelay < delayMin )
delayMin = tDelay;
if ( tDelay > delayMax )
delayMax = tDelay;
gpsTime.gpsSeconds += 2*dtDelayBy2;
input.tgps.gpsSeconds += 2*dtDelayBy2;
}
}
/* No information from which to compute delays. */
else {
LALInfo( stat, "Detector site and ephemerides absent; simulating hplus with no"
" propagation delays" );
memset( delayData, 0, nMax*sizeof(REAL8) );
delayMin = delayMax = 0.0;
}
/* Generate the table of polarization response functions. */
polDt = output->deltaT/( 2.0*dtPolBy2 );
nMax = (UINT4)( output->data->length*polDt ) + 3;
memset( &polResponse, 0, sizeof( LALDetAMResponseSeries ) );
polResponse.pPlus = (REAL4TimeSeries *)
LALMalloc( sizeof(REAL4TimeSeries) );
polResponse.pCross = (REAL4TimeSeries *)
LALMalloc( sizeof(REAL4TimeSeries) );
polResponse.pScalar = (REAL4TimeSeries *)
LALMalloc( sizeof(REAL4TimeSeries) );
if ( !polResponse.pPlus || !polResponse.pCross ||
!polResponse.pScalar ) {
if ( polResponse.pPlus )
LALFree( polResponse.pPlus );
if ( polResponse.pCross )
LALFree( polResponse.pCross );
if ( polResponse.pScalar )
LALFree( polResponse.pScalar );
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
ABORT( stat, SIMULATECOHERENTGWH_EMEM,
SIMULATECOHERENTGWH_MSGEMEM );
}
memset( polResponse.pPlus, 0, sizeof(REAL4TimeSeries) );
memset( polResponse.pCross, 0, sizeof(REAL4TimeSeries) );
memset( polResponse.pScalar, 0, sizeof(REAL4TimeSeries) );
LALSCreateVector( stat->statusPtr, &( polResponse.pPlus->data ),
nMax );
BEGINFAIL( stat ) {
LALFree( polResponse.pPlus );
LALFree( polResponse.pCross );
LALFree( polResponse.pScalar );
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
} ENDFAIL( stat );
LALSCreateVector( stat->statusPtr, &( polResponse.pCross->data ),
nMax );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr,
&( polResponse.pPlus->data ) ), stat );
LALFree( polResponse.pPlus );
LALFree( polResponse.pCross );
LALFree( polResponse.pScalar );
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
} ENDFAIL( stat );
LALSCreateVector( stat->statusPtr, &( polResponse.pScalar->data ),
nMax );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr,
&( polResponse.pPlus->data ) ), stat );
TRY( LALSDestroyVector( stat->statusPtr,
&( polResponse.pCross->data ) ), stat );
LALFree( polResponse.pPlus );
LALFree( polResponse.pCross );
LALFree( polResponse.pScalar );
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
} ENDFAIL( stat );
plusData = polResponse.pPlus->data->data;
crossData = polResponse.pCross->data->data;
INT4 plusLen = polResponse.pPlus->data->length;
INT4 crossLen = polResponse.pCross->data->length;
if ( plusLen != crossLen ) {
XLALPrintError ("plusLen = %d != crossLen = %d\n", plusLen, crossLen );
ABORT ( stat, SIMULATECOHERENTGWH_EBAD, SIMULATECOHERENTGWH_MSGEBAD );
}
if ( detector->site ) {
LALSource polSource; /* position and polarization angle */
LALDetAndSource input; /* response input structure */
LALTimeIntervalAndNSample params; /* response parameter structure */
/* Arrange nested pointers, and set initial values. */
polSource.equatorialCoords = source;
polSource.orientation = (REAL8)( CWsignal->psi );
input.pSource = &polSource;
input.pDetector = detector->site;
params.epoch = output->epoch;
params.epoch.gpsSeconds -= dtPolBy2;
params.deltaT = 2.0*dtPolBy2;
params.nSample = nMax;
/* Compute table of responses. */
LALComputeDetAMResponseSeries( stat->statusPtr, &polResponse,
&input, ¶ms );
BEGINFAIL( stat ) {
TRY( LALSDestroyVector( stat->statusPtr,
&( polResponse.pPlus->data ) ), stat );
TRY( LALSDestroyVector( stat->statusPtr,
&( polResponse.pCross->data ) ), stat );
TRY( LALSDestroyVector( stat->statusPtr,
&( polResponse.pScalar->data ) ), stat );
LALFree( polResponse.pPlus );
LALFree( polResponse.pCross );
LALFree( polResponse.pScalar );
TRY( LALDDestroyVector( stat->statusPtr, &delay ), stat );
} ENDFAIL( stat );
} else {
void
LALStochasticOptimalFilterNormalization(
LALStatus *status,
StochasticOptimalFilterNormalizationOutput *output,
const StochasticOptimalFilterNormalizationInput *input,
const StochasticOptimalFilterNormalizationParameters *parameters)
{
REAL4 omegaTimesGamma;
REAL4 p1Inv;
REAL4 p2Inv;
REAL8 f;
REAL8 f0;
REAL8 f3;
REAL8 deltaF;
/* normalization factor */
UINT4 i;
UINT4 xRef;
REAL4 omega1;
REAL4 omega2;
REAL8 freq1;
REAL8 freq2;
REAL4 exponent;
REAL4 omegaRef;
REAL8 lambdaInv;
REAL8 f6;
/* windowing */
REAL4 w2, meanW2, meanW4;
REAL4 *sPtrW1, *sPtrW2, *sStopPtr;
UINT4 winLength = 0;
UINT4 length;
LALUnit tmpUnit1, tmpUnit2, checkUnit;
REAL4WithUnits *lamPtr;
/* initialize status pointer */
INITSTATUS(status);
ATTATCHSTATUSPTR(status);
/* ERROR CHECKING ----------------------------------------------------- */
/* check for null pointers *****/
/* input structure */
ASSERT(input != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* output structure */
ASSERT(output != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* parameter structure */
ASSERT(parameters != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* overlap member of input */
ASSERT(input->overlapReductionFunction != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* omega member of input */
ASSERT(input->omegaGW != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* inverse noise 1 of input */
ASSERT(input->inverseNoisePSD1 != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* inverse noise 2 of input */
ASSERT(input->inverseNoisePSD2 != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of overlap */
ASSERT(input->overlapReductionFunction->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of omega */
ASSERT(input->omegaGW->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of inverse noise 1 */
ASSERT(input->inverseNoisePSD1->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of inverse noise 2 */
ASSERT(input->inverseNoisePSD2->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of overlap */
ASSERT(input->overlapReductionFunction->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of omega */
ASSERT(input->omegaGW->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of inverse noise 1 */
ASSERT(input->inverseNoisePSD1->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data-data member of inverse noise 2 */
ASSERT(input->inverseNoisePSD2->data->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* Checks that only apply if windowing is specified */
if (parameters->window1 || parameters->window2)
{
/* window 1 parameter */
ASSERT(parameters->window1 != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* window 2 parameter */
ASSERT(parameters->window2 != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of window 1 */
ASSERT(parameters->window1->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
/* data member of window 2 */
ASSERT(parameters->window2->data != NULL, status, \
STOCHASTICCROSSCORRELATIONH_ENULLPTR, \
STOCHASTICCROSSCORRELATIONH_MSGENULLPTR);
winLength = parameters->window1->length;
ASSERT(winLength != 0, status, \
STOCHASTICCROSSCORRELATIONH_EZEROLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN);
/* Check that windows are the same length */
if (parameters->window2->length != winLength)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
}
/* done with null pointers ***/
/* extract parameters from overlap */
length = input->overlapReductionFunction->data->length;
f0 = input->overlapReductionFunction->f0;
deltaF = input->overlapReductionFunction->deltaF;
/* check for legality ****/
/* length must be positive */
ASSERT(length != 0, status, \
STOCHASTICCROSSCORRELATIONH_EZEROLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEZEROLEN);
/* start frequency must not be negative */
if (f0 < 0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_ENEGFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGENEGFMIN);
}
/* frequency spacing must be positive */
ASSERT(deltaF > 0, status, \
STOCHASTICCROSSCORRELATIONH_ENONPOSDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGENONPOSDELTAF);
/* check for mismatches **/
/* length */
if (input->omegaGW->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
if (input->inverseNoisePSD1->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
if (input->inverseNoisePSD2->data->length != length)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMLEN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMLEN);
}
/* initial frequency */
if (input->omegaGW->f0 != f0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMFMIN);
}
if (input->inverseNoisePSD1->f0 != f0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMFMIN);
}
if (input->inverseNoisePSD2->f0 != f0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMFMIN, \
STOCHASTICCROSSCORRELATIONH_MSGEMMFMIN);
}
/* frequency spacing */
if (input->omegaGW->deltaF != deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGEMMDELTAF);
}
if (input->inverseNoisePSD1->deltaF != deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGEMMDELTAF);
}
if (input->inverseNoisePSD2->deltaF != deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EMMDELTAF, \
STOCHASTICCROSSCORRELATIONH_MSGEMMDELTAF);
}
/* check for reference frequency lower and upper limits **/
if (parameters->fRef < f0 + deltaF)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EOORFREF, \
STOCHASTICCROSSCORRELATIONH_MSGEOORFREF);
}
if (parameters->fRef > f0 + ((REAL8)(length-1)*deltaF))
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EOORFREF, \
STOCHASTICCROSSCORRELATIONH_MSGEOORFREF);
}
/* EVERYHTING OKAY HERE! ---------------------------------------------- */
/* check that units of gamma, Omega, P1 and P2 are consistent
* we must have (gamma*Omega)^2 with the same units as f^2*P1*P2
* up to a power of ten. We check this by constructing
* checkUnit = f^2*P1*P2*(gamma*Omega)^-2 */
if (XLALUnitMultiply(&tmpUnit1, &(input->inverseNoisePSD1->sampleUnits), &(input->inverseNoisePSD2->sampleUnits)) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit1 holds units of 1/(P1*P2) */
if (XLALUnitRaiseINT2(&tmpUnit2, &tmpUnit1, -1) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit2 holds units of P1*P2 */
if (XLALUnitMultiply(&tmpUnit1, &(input->overlapReductionFunction->sampleUnits), &(input->omegaGW->sampleUnits)) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit1 holds units of Omega*Gamma */
if (XLALUnitMultiply(&checkUnit, &tmpUnit1, &lalSecondUnit) == NULL) {
ABORTXLAL(status);
}
/* checkUnit holds units of f^-1*Omega*Gamma */
if (XLALUnitRaiseINT2(&tmpUnit1, &checkUnit, -2) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit1 holds units of f^2*(Omega*Gamma)^-2 */
if (XLALUnitMultiply(&checkUnit, &tmpUnit1, &tmpUnit2) == NULL) {
ABORTXLAL(status);
}
/* checkUnit holds units of f^2*P1*P2(Omega*Gamma)^-2 */
/* Check that checkUnit is dimensionless up to a power of ten ***/
for (i=0; i<LALNumUnits; ++i)
{
if (checkUnit.unitNumerator[i] || checkUnit.unitDenominatorMinusOne[i])
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_EWRONGUNITS, \
STOCHASTICCROSSCORRELATIONH_MSGEWRONGUNITS);
}
}
/* Set tmpUnit1 to dims of Omega/H0^2 ******/
/* First, set it to dims of H0 */
tmpUnit1 = lalHertzUnit;
/* Account for scaled units of Hubble constant */
tmpUnit1.powerOfTen -= 18;
/* Now set tmpUnit2 to dims of H0^-2 */
if (XLALUnitRaiseINT2(&tmpUnit2, &tmpUnit1, -2) == NULL) {
ABORTXLAL(status);
}
if (XLALUnitMultiply(&tmpUnit1, &(input->omegaGW->sampleUnits), &tmpUnit2) == NULL) {
ABORTXLAL(status);
}
/* Now tmpUnit1 has units of Omega/H0^2 */
/* assign correct units to normalization constant ********/
/* These are Omega/H0^2*f^5*P1*P2*(gamma*Omega)^-2
* which is the same as tmpUnit1*f^3*checkUnit */
if (XLALUnitMultiply(&tmpUnit2, &tmpUnit1, &checkUnit) == NULL) {
ABORTXLAL(status);
}
/* tmpUnit2 has units of Omega/H0^2*f^2*P1*P2*(gamma*Omega)^-2 */
/* Now that we've used checkUnit, we don't need it any more and */
/* can use it for temp storage (of f^3) */
if (XLALUnitRaiseINT2(&checkUnit, &lalHertzUnit, 3) == NULL) {
ABORTXLAL(status);
}
/* In case the normalization output was NULL, we need to allocate it
* since we still use it as an intermediate; we do so here to
* minimize the BEGINFAIL/ENDFAIL pairs needed */
if (output->normalization != NULL)
{
lamPtr = output->normalization;
}
else
{
lamPtr = (REAL4WithUnits*)LALMalloc(sizeof(REAL4WithUnits));
}
if (XLALUnitMultiply(&(lamPtr->units), &tmpUnit2, &checkUnit) == NULL) {
if (output->normalization == NULL) LALFree(lamPtr);
ABORTXLAL(status);
}
if (output->variance != NULL)
{
/* assign correct units to variance per time of CC stat ********/
if (XLALUnitMultiply(&(output->variance->units), &(lamPtr->units), &tmpUnit1) == NULL) {
if (output->normalization == NULL) LALFree(lamPtr);
ABORTXLAL(status);
}
}
/* Calculate properties of windows */
if (parameters->window1 == NULL)
{
meanW2 = meanW4 = 1.0;
}
else
{
meanW2 = meanW4 = 0.0;
for (sPtrW1 = parameters->window1->data, \
sPtrW2 = parameters->window2->data, sStopPtr = sPtrW1 + winLength; \
sPtrW1 < sStopPtr; ++sPtrW1, ++sPtrW2)
{
w2 = *sPtrW1 * *sPtrW2;
meanW2 += w2;
meanW4 += w2 * w2;
}
meanW2 /= winLength;
meanW4 /= winLength;
if (meanW2 <= 0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_ENONPOSWIN, \
STOCHASTICCROSSCORRELATIONH_MSGENONPOSWIN);
}
}
/* ************* calculate lambda ***********************/
/* find omegaRef */
xRef = (UINT4)((parameters->fRef - f0)/deltaF);
if (((parameters->fRef - f0)/deltaF) == (REAL8)(xRef))
{
omegaRef = input->omegaGW->data->data[xRef];
}
else
{
omega1 = input->omegaGW->data->data[xRef];
omega2 = input->omegaGW->data->data[xRef+1];
freq1 = f0 + xRef * deltaF;
freq2 = f0 + (xRef + 1) * deltaF;
if (omega1 <= 0)
{
ABORT(status, STOCHASTICCROSSCORRELATIONH_ENONPOSOMEGA, \
STOCHASTICCROSSCORRELATIONH_MSGENONPOSOMEGA);
}
else
{
exponent = ((log((parameters->fRef)/freq1))/(log(freq2/freq1)));
}
omegaRef = omega1*(pow((omega2/omega1),exponent));
}
/* calculate inverse lambda value */
lambdaInv = 0.0;
for (i = (f0 == 0 ? 1 : 0) ; i < length; ++i)
{
f = f0 + deltaF * (REAL8) i;
f3 = f * f * f;
f6 = f3 * f3;
omegaTimesGamma = input->omegaGW->data->data[i] * \
input->overlapReductionFunction->data->data[i];
p1Inv = input->inverseNoisePSD1->data->data[i];
p2Inv = input->inverseNoisePSD2->data->data[i];
lambdaInv += (omegaTimesGamma * omegaTimesGamma * p1Inv * p2Inv) / f6;
}
lambdaInv /= (omegaRef / deltaF) * ((20.0L * LAL_PI * LAL_PI) / \
(3.0L * (LAL_H0FAC_SI*1e+18) * (LAL_H0FAC_SI*1e+18) * meanW2));
if (!parameters->heterodyned)
lambdaInv *= 2.0;
lamPtr->value = 1 / lambdaInv;
if (output->variance != NULL)
{
output->variance->value = (meanW4/meanW2) * ((5.0L * LAL_PI * LAL_PI) / \
(3.0L * (LAL_H0FAC_SI*1e+18) * (LAL_H0FAC_SI*1e+18))) * \
omegaRef / lambdaInv;
}
if (output->normalization == NULL)
LALFree(lamPtr);
DETATCHSTATUSPTR(status);
RETURN(status);
}
void
LALREAL4AverageSpectrum (
LALStatus *status,
REAL4FrequencySeries *fSeries,
REAL4TimeSeries *tSeries,
AverageSpectrumParams *params
)
{
UINT4 i, j, k; /* seg, ts and freq counters */
UINT4 numSeg; /* number of segments in average */
UINT4 fLength; /* length of requested power spec */
UINT4 tLength; /* length of time series segments */
REAL4Vector *tSegment = NULL; /* dummy time series segment */
COMPLEX8Vector *fSegment = NULL; /* dummy freq series segment */
REAL4 *tSeriesPtr; /* pointer to the segment data */
REAL4 psdNorm = 0; /* factor to multiply windows data */
REAL4 fftRe, fftIm; /* real and imag parts of fft */
REAL4 *s; /* work space for computing mean */
REAL4 *psdSeg = NULL; /* storage for individual specta */
LALUnit unit;
/* RAT4 negRootTwo = { -1, 1 }; */
INITSTATUS(status);
XLAL_PRINT_DEPRECATION_WARNING("XLALREAL4AverageSpectrumWelch");
ATTATCHSTATUSPTR (status);
/* check the input and output data pointers are non-null */
ASSERT( fSeries, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( fSeries->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( fSeries->data->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( tSeries->data->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
/* check the contents of the parameter structure */
ASSERT( params, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( params->window, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( params->window->data, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
ASSERT( params->window->data->length > 0, status,
TIMEFREQFFTH_EZSEG, TIMEFREQFFTH_MSGEZSEG );
ASSERT( params->plan, status,
TIMEFREQFFTH_ENULL, TIMEFREQFFTH_MSGENULL );
if ( ! ( params->method == useUnity || params->method == useMean ||
params->method == useMedian ) )
{
ABORT( status, TIMEFREQFFTH_EUAVG, TIMEFREQFFTH_MSGEUAVG );
}
/* check that the window length and fft storage lengths agree */
fLength = fSeries->data->length;
tLength = params->window->data->length;
if ( fLength != tLength / 2 + 1 )
{
ABORT( status, TIMEFREQFFTH_EMISM, TIMEFREQFFTH_MSGEMISM );
}
/* compute the number of segs, check that the length and overlap are valid */
numSeg = (tSeries->data->length - params->overlap) / (tLength - params->overlap);
if ( (tSeries->data->length - params->overlap) % (tLength - params->overlap) )
{
ABORT( status, TIMEFREQFFTH_EMISM, TIMEFREQFFTH_MSGEMISM );
}
/* clear the output spectrum and the workspace frequency series */
memset( fSeries->data->data, 0, fLength * sizeof(REAL4) );
/* compute the parameters of the output frequency series data */
fSeries->epoch = tSeries->epoch;
fSeries->f0 = tSeries->f0;
fSeries->deltaF = 1.0 / ( (REAL8) tLength * tSeries->deltaT );
if ( XLALUnitMultiply( &unit, &(tSeries->sampleUnits), &(tSeries->sampleUnits) ) == NULL ) {
ABORTXLAL(status);
}
if ( XLALUnitMultiply( &(fSeries->sampleUnits), &unit, &lalSecondUnit ) == NULL ) {
ABORTXLAL(status);
}
/* if this is a unit spectrum, just set the conents to unity and return */
if ( params->method == useUnity )
{
for ( k = 0; k < fLength; ++k )
{
fSeries->data->data[k] = 1.0;
}
DETATCHSTATUSPTR( status );
RETURN( status );
}
/* create temporary storage for the dummy time domain segment */
LALCreateVector( status->statusPtr, &tSegment, tLength );
CHECKSTATUSPTR( status );
/* create temporary storage for the individual ffts */
LALCCreateVector( status->statusPtr, &fSegment, fLength );
CHECKSTATUSPTR( status );
if ( params->method == useMedian )
{
/* create enough storage for the indivdiual power spectra */
psdSeg = XLALCalloc( numSeg, fLength * sizeof(REAL4) );
}
/* compute each of the power spectra used in the average */
for ( i = 0, tSeriesPtr = tSeries->data->data; i < (UINT4) numSeg; ++i )
{
/* copy the time series data to the dummy segment */
memcpy( tSegment->data, tSeriesPtr, tLength * sizeof(REAL4) );
/* window the time series segment */
for ( j = 0; j < tLength; ++j )
{
tSegment->data[j] *= params->window->data->data[j];
}
/* compute the fft of the data segment */
LALForwardRealFFT( status->statusPtr, fSegment, tSegment, params->plan );
CHECKSTATUSPTR (status);
/* advance the segment data pointer to the start of the next segment */
tSeriesPtr += tLength - params->overlap;
/* compute the psd components */
if ( params->method == useMean )
{
/* we can get away with less storage */
for ( k = 0; k < fLength; ++k )
{
fftRe = crealf(fSegment->data[k]);
fftIm = cimagf(fSegment->data[k]);
fSeries->data->data[k] += fftRe * fftRe + fftIm * fftIm;
}
/* halve the DC and Nyquist components to be consistent with T010095 */
fSeries->data->data[0] /= 2;
fSeries->data->data[fLength - 1] /= 2;
}
else if ( params->method == useMedian )
{
/* we must store all the spectra */
for ( k = 0; k < fLength; ++k )
{
fftRe = crealf(fSegment->data[k]);
fftIm = cimagf(fSegment->data[k]);
psdSeg[i * fLength + k] = fftRe * fftRe + fftIm * fftIm;
}
/* halve the DC and Nyquist components to be consistent with T010095 */
psdSeg[i * fLength] /= 2;
psdSeg[i * fLength + fLength - 1] /= 2;
}
}
/* destroy the dummy time series segment and the fft scratch space */
LALDestroyVector( status->statusPtr, &tSegment );
CHECKSTATUSPTR( status );
LALCDestroyVector( status->statusPtr, &fSegment );
CHECKSTATUSPTR( status );
/* compute the desired average of the spectra */
if ( params->method == useMean )
{
/* normalization constant for the arithmentic mean */
psdNorm = ( 2.0 * tSeries->deltaT ) /
( (REAL4) numSeg * params->window->sumofsquares );
/* normalize the psd to it matches the conventions document */
for ( k = 0; k < fLength; ++k )
{
fSeries->data->data[k] *= psdNorm;
}
}
else if ( params->method == useMedian )
{
REAL8 bias;
/* determine the running median bias */
/* note: this is not the correct bias if the segments are overlapped */
if ( params->overlap )
{
LALWarning( status, "Overlapping segments with median method causes a biased spectrum." );
}
TRY( LALRngMedBias( status->statusPtr, &bias, numSeg ), status );
/* normalization constant for the median */
psdNorm = ( 2.0 * tSeries->deltaT ) /
( bias * params->window->sumofsquares );
/* allocate memory array for insert sort */
s = XLALMalloc( numSeg * sizeof(REAL4) );
if ( ! s )
{
ABORT( status, TIMEFREQFFTH_EMALLOC, TIMEFREQFFTH_MSGEMALLOC );
}
/* compute the median spectra and normalize to the conventions doc */
for ( k = 0; k < fLength; ++k )
{
fSeries->data->data[k] = psdNorm *
MedianSpec( psdSeg, s, k, fLength, numSeg );
}
/* free memory used for sort array */
XLALFree( s );
/* destroy the storage for the individual spectra */
XLALFree( psdSeg );
}
DETATCHSTATUSPTR( status );
RETURN( status );
}
int XLALSimInspiralTaylorF2Core(
COMPLEX16FrequencySeries **htilde_out, /**< FD waveform */
const REAL8Sequence *freqs, /**< frequency points at which to evaluate the waveform (Hz) */
const REAL8 phi_ref, /**< reference orbital phase (rad) */
const REAL8 m1_SI, /**< mass of companion 1 (kg) */
const REAL8 m2_SI, /**< mass of companion 2 (kg) */
const REAL8 S1z, /**< z component of the spin of companion 1 */
const REAL8 S2z, /**< z component of the spin of companion 2 */
const REAL8 f_ref, /**< Reference GW frequency (Hz) - if 0 reference point is coalescence */
const REAL8 shft, /**< time shift to be applied to frequency-domain phase (sec)*/
const REAL8 r, /**< distance of source (m) */
LALDict *p /**< Linked list containing the extra testing GR parameters >**/
)
{
if (!htilde_out) XLAL_ERROR(XLAL_EFAULT);
if (!freqs) XLAL_ERROR(XLAL_EFAULT);
/* external: SI; internal: solar masses */
const REAL8 m1 = m1_SI / LAL_MSUN_SI;
const REAL8 m2 = m2_SI / LAL_MSUN_SI;
const REAL8 m = m1 + m2;
const REAL8 m_sec = m * LAL_MTSUN_SI; /* total mass in seconds */
const REAL8 eta = m1 * m2 / (m * m);
const REAL8 piM = LAL_PI * m_sec;
const REAL8 m1OverM = m1 / m;
const REAL8 m2OverM = m2 / m;
REAL8 amp0;
size_t i;
COMPLEX16 *data = NULL;
LIGOTimeGPS tC = {0, 0};
INT4 iStart = 0;
COMPLEX16FrequencySeries *htilde = NULL;
if (*htilde_out) { //case when htilde_out has been allocated in XLALSimInspiralTaylorF2
htilde = *htilde_out;
iStart = htilde->data->length - freqs->length; //index shift to fill pre-allocated data
if(iStart < 0) XLAL_ERROR(XLAL_EFAULT);
}
else { //otherwise allocate memory here
htilde = XLALCreateCOMPLEX16FrequencySeries("htilde: FD waveform", &tC, freqs->data[0], 0., &lalStrainUnit, freqs->length);
if (!htilde) XLAL_ERROR(XLAL_EFUNC);
XLALUnitMultiply(&htilde->sampleUnits, &htilde->sampleUnits, &lalSecondUnit);
}
/* phasing coefficients */
PNPhasingSeries pfa;
XLALSimInspiralPNPhasing_F2(&pfa, m1, m2, S1z, S2z, S1z*S1z, S2z*S2z, S1z*S2z, p);
REAL8 pfaN = 0.; REAL8 pfa1 = 0.;
REAL8 pfa2 = 0.; REAL8 pfa3 = 0.; REAL8 pfa4 = 0.;
REAL8 pfa5 = 0.; REAL8 pfl5 = 0.;
REAL8 pfa6 = 0.; REAL8 pfl6 = 0.;
REAL8 pfa7 = 0.;
INT4 phaseO=XLALSimInspiralWaveformParamsLookupPNPhaseOrder(p);
switch (phaseO)
{
case -1:
case 7:
pfa7 = pfa.v[7];
case 6:
pfa6 = pfa.v[6];
pfl6 = pfa.vlogv[6];
case 5:
pfa5 = pfa.v[5];
pfl5 = pfa.vlogv[5];
case 4:
pfa4 = pfa.v[4];
case 3:
pfa3 = pfa.v[3];
case 2:
pfa2 = pfa.v[2];
case 1:
pfa1 = pfa.v[1];
case 0:
pfaN = pfa.v[0];
break;
default:
XLAL_ERROR(XLAL_ETYPE, "Invalid phase PN order %d", phaseO);
}
/* Validate expansion order arguments.
* This must be done here instead of in the OpenMP parallel loop
* because when OpenMP parallelization is turned on, early exits
* from loops (via return or break statements) are not permitted.
*/
/* Validate amplitude PN order. */
INT4 amplitudeO=XLALSimInspiralWaveformParamsLookupPNAmplitudeOrder(p);
switch (amplitudeO)
{
case -1:
case 7:
case 6:
case 5:
case 4:
case 3:
case 2:
case 0:
break;
default:
XLAL_ERROR(XLAL_ETYPE, "Invalid amplitude PN order %d", amplitudeO);
}
/* Generate tidal terms separately.
* Enums specifying tidal order are in LALSimInspiralWaveformFlags.h
*/
REAL8 pft10 = 0.;
REAL8 pft12 = 0.;
REAL8 lambda1=XLALSimInspiralWaveformParamsLookupTidalLambda1(p);
REAL8 lambda2=XLALSimInspiralWaveformParamsLookupTidalLambda2(p);
switch( XLALSimInspiralWaveformParamsLookupPNTidalOrder(p) )
{
case LAL_SIM_INSPIRAL_TIDAL_ORDER_ALL:
case LAL_SIM_INSPIRAL_TIDAL_ORDER_6PN:
pft12 = pfaN * (lambda1*XLALSimInspiralTaylorF2Phasing_12PNTidalCoeff(m1OverM) + lambda2*XLALSimInspiralTaylorF2Phasing_12PNTidalCoeff(m2OverM) );
case LAL_SIM_INSPIRAL_TIDAL_ORDER_5PN:
pft10 = pfaN * ( lambda1*XLALSimInspiralTaylorF2Phasing_10PNTidalCoeff(m1OverM) + lambda2*XLALSimInspiralTaylorF2Phasing_10PNTidalCoeff(m2OverM) );
case LAL_SIM_INSPIRAL_TIDAL_ORDER_0PN:
break;
default:
XLAL_ERROR(XLAL_EINVAL, "Invalid tidal PN order %d", XLALSimInspiralWaveformParamsLookupPNTidalOrder(p) );
}
/* The flux and energy coefficients below are used to compute SPA amplitude corrections */
/* flux coefficients */
const REAL8 FTaN = XLALSimInspiralPNFlux_0PNCoeff(eta);
const REAL8 FTa2 = XLALSimInspiralPNFlux_2PNCoeff(eta);
const REAL8 FTa3 = XLALSimInspiralPNFlux_3PNCoeff(eta);
const REAL8 FTa4 = XLALSimInspiralPNFlux_4PNCoeff(eta);
const REAL8 FTa5 = XLALSimInspiralPNFlux_5PNCoeff(eta);
const REAL8 FTl6 = XLALSimInspiralPNFlux_6PNLogCoeff(eta);
const REAL8 FTa6 = XLALSimInspiralPNFlux_6PNCoeff(eta);
const REAL8 FTa7 = XLALSimInspiralPNFlux_7PNCoeff(eta);
/* energy coefficients */
const REAL8 dETaN = 2. * XLALSimInspiralPNEnergy_0PNCoeff(eta);
const REAL8 dETa1 = 2. * XLALSimInspiralPNEnergy_2PNCoeff(eta);
const REAL8 dETa2 = 3. * XLALSimInspiralPNEnergy_4PNCoeff(eta);
const REAL8 dETa3 = 4. * XLALSimInspiralPNEnergy_6PNCoeff(eta);
/* Perform some initial checks */
if (m1_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (m2_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (f_ref < 0) XLAL_ERROR(XLAL_EDOM);
if (r <= 0) XLAL_ERROR(XLAL_EDOM);
/* extrinsic parameters */
amp0 = -4. * m1 * m2 / r * LAL_MRSUN_SI * LAL_MTSUN_SI * sqrt(LAL_PI/12.L);
data = htilde->data->data;
/* Compute the SPA phase at the reference point
* N.B. f_ref == 0 means we define the reference time/phase at "coalescence"
* when the frequency approaches infinity. In that case,
* the integrals Eq. 3.15 of arXiv:0907.0700 vanish when evaluated at
* f_ref == infinity. If f_ref is finite, we must compute the SPA phase
* evaluated at f_ref, store it as ref_phasing and subtract it off.
*/
REAL8 ref_phasing = 0.;
if( f_ref != 0. ) {
const REAL8 vref = cbrt(piM*f_ref);
const REAL8 logvref = log(vref);
const REAL8 v2ref = vref * vref;
const REAL8 v3ref = vref * v2ref;
const REAL8 v4ref = vref * v3ref;
const REAL8 v5ref = vref * v4ref;
const REAL8 v6ref = vref * v5ref;
const REAL8 v7ref = vref * v6ref;
const REAL8 v8ref = vref * v7ref;
const REAL8 v9ref = vref * v8ref;
const REAL8 v10ref = vref * v9ref;
const REAL8 v12ref = v2ref * v10ref;
ref_phasing += pfa7 * v7ref;
ref_phasing += (pfa6 + pfl6 * logvref) * v6ref;
ref_phasing += (pfa5 + pfl5 * logvref) * v5ref;
ref_phasing += pfa4 * v4ref;
ref_phasing += pfa3 * v3ref;
ref_phasing += pfa2 * v2ref;
ref_phasing += pfa1 * vref;
ref_phasing += pfaN;
/* Tidal terms in reference phasing */
ref_phasing += pft12 * v12ref;
ref_phasing += pft10 * v10ref;
ref_phasing /= v5ref;
} /* End of if(f_ref != 0) block */
#pragma omp parallel for
for (i = 0; i < freqs->length; i++) {
const REAL8 f = freqs->data[i];
const REAL8 v = cbrt(piM*f);
const REAL8 logv = log(v);
const REAL8 v2 = v * v;
const REAL8 v3 = v * v2;
const REAL8 v4 = v * v3;
const REAL8 v5 = v * v4;
const REAL8 v6 = v * v5;
const REAL8 v7 = v * v6;
const REAL8 v8 = v * v7;
const REAL8 v9 = v * v8;
const REAL8 v10 = v * v9;
const REAL8 v12 = v2 * v10;
REAL8 phasing = 0.;
REAL8 dEnergy = 0.;
REAL8 flux = 0.;
REAL8 amp;
phasing += pfa7 * v7;
phasing += (pfa6 + pfl6 * logv) * v6;
phasing += (pfa5 + pfl5 * logv) * v5;
phasing += pfa4 * v4;
phasing += pfa3 * v3;
phasing += pfa2 * v2;
phasing += pfa1 * v;
phasing += pfaN;
/* Tidal terms in phasing */
phasing += pft12 * v12;
phasing += pft10 * v10;
/* WARNING! Amplitude orders beyond 0 have NOT been reviewed!
* Use at your own risk. The default is to turn them off.
* These do not currently include spin corrections.
* Note that these are not higher PN corrections to the amplitude.
* They are the corrections to the leading-order amplitude arising
* from the stationary phase approximation. See for instance
* Eq 6.9 of arXiv:0810.5336
*/
switch (amplitudeO)
{
case 7:
flux += FTa7 * v7;
case 6:
flux += (FTa6 + FTl6*logv) * v6;
dEnergy += dETa3 * v6;
case 5:
flux += FTa5 * v5;
case 4:
flux += FTa4 * v4;
dEnergy += dETa2 * v4;
case 3:
flux += FTa3 * v3;
case 2:
flux += FTa2 * v2;
dEnergy += dETa1 * v2;
case -1: /* Default to no SPA amplitude corrections */
case 0:
flux += 1.;
dEnergy += 1.;
}
phasing /= v5;
flux *= FTaN * v10;
dEnergy *= dETaN * v;
// Note the factor of 2 b/c phi_ref is orbital phase
phasing += shft * f - 2.*phi_ref - ref_phasing;
amp = amp0 * sqrt(-dEnergy/flux) * v;
data[i+iStart] = amp * cos(phasing - LAL_PI_4)
- amp * sin(phasing - LAL_PI_4) * 1.0j;
}
*htilde_out = htilde;
return XLAL_SUCCESS;
}
/**
* Generate the "reduced-spin templates" proposed in http://arxiv.org/abs/1107.1267
* Add the tidal phase terms from http://arxiv.org/abs/1101.1673 (Eqs. 3.9, 3.10)
* The chi parameter should be determined from XLALSimInspiralTaylorF2ReducedSpinComputeChi.
*/
int XLALSimInspiralTaylorF2ReducedSpinTidal(
COMPLEX16FrequencySeries **htilde, /**< FD waveform */
const REAL8 phic, /**< orbital coalescence phase (rad) */
const REAL8 deltaF, /**< frequency resolution (Hz) */
const REAL8 m1_SI, /**< mass of companion 1 (kg) */
const REAL8 m2_SI, /**< mass of companion 2 (kg) */
const REAL8 chi, /**< dimensionless aligned-spin param */
const REAL8 lam1, /**< (tidal deformability of mass 1) / (mass of body 1)^5 (dimensionless) */
const REAL8 lam2, /**< (tidal deformability of mass 2) / (mass of body 2)^5 (dimensionless) */
const REAL8 fStart, /**< start GW frequency (Hz) */
const REAL8 fEnd, /**< highest GW frequency (Hz) of waveform generation - if 0, end at Schwarzschild ISCO */
const REAL8 r, /**< distance of source (m) */
const INT4 phaseO, /**< twice PN phase order */
const INT4 ampO /**< twice PN amplitude order */
) {
/* external: SI; internal: solar masses */
const REAL8 m1 = m1_SI / LAL_MSUN_SI;
const REAL8 m2 = m2_SI / LAL_MSUN_SI;
const REAL8 m = m1 + m2;
const REAL8 m_sec = m * LAL_MTSUN_SI; /* total mass in seconds */
const REAL8 eta = m1 * m2 / (m * m);
const REAL8 xi1 = m1 / m;
const REAL8 xi2 = m2 / m;
const REAL8 piM = LAL_PI * m_sec;
const REAL8 mSevenBySix = -7./6.;
const REAL8 vISCO = 1. / sqrt(6.);
const REAL8 fISCO = vISCO * vISCO * vISCO / piM;
REAL8 v0 = 1.0; /* v0=c */
REAL8 shft, amp0, f_max;
REAL8 psiNewt, psi2, psi3, psi4, psi5, psi6, psi6L, psi7, psi3S, psi4S, psi5S, psi10T1, psi10T2, psi10, psi12T1, psi12T2, psi12;
REAL8 alpha2, alpha3, alpha4, alpha5, alpha6, alpha6L, alpha7, alpha3S, alpha4S, alpha5S;
size_t i, n, iStart;
COMPLEX16 *data = NULL;
LIGOTimeGPS tStart = {0, 0};
/* check inputs for sanity */
if (*htilde) XLAL_ERROR(XLAL_EFAULT);
if (m1_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (m2_SI <= 0) XLAL_ERROR(XLAL_EDOM);
if (fabs(chi) > 1) XLAL_ERROR(XLAL_EDOM);
if (fStart <= 0) XLAL_ERROR(XLAL_EDOM);
if (r <= 0) XLAL_ERROR(XLAL_EDOM);
if (ampO > 7) XLAL_ERROR(XLAL_EDOM); /* only implemented to pN 3.5 */
if (phaseO > 7) XLAL_ERROR(XLAL_EDOM); /* only implemented to pN 3.5 */
/* allocate htilde */
if ( fEnd == 0. ) // End at ISCO
f_max = fISCO;
else // End at user-specified freq.
f_max = fEnd;
n = (size_t) (f_max / deltaF + 1);
XLALGPSAdd(&tStart, -1 / deltaF); /* coalesce at t=0 */
*htilde = XLALCreateCOMPLEX16FrequencySeries("htilde: FD waveform", &tStart, 0.0, deltaF, &lalStrainUnit, n);
if (!(*htilde)) XLAL_ERROR(XLAL_EFUNC);
memset((*htilde)->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&((*htilde)->sampleUnits), &((*htilde)->sampleUnits), &lalSecondUnit);
/* extrinsic parameters */
amp0 = -pow(m_sec, 5./6.) * sqrt(5. * eta / 24.) / (cbrt(LAL_PI * LAL_PI) * r / LAL_C_SI);
shft = LAL_TWOPI * (tStart.gpsSeconds + 1e-9 * tStart.gpsNanoSeconds);
/* spin terms in the amplitude and phase (in terms of the reduced
* spin parameter */
psi3S = 113.*chi/3.;
psi4S = 63845.*(-81. + 4.*eta)*chi*chi/(8.*pow(-113. + 76.*eta, 2.));
psi5S = -565.*(-146597. + 135856.*eta + 17136.*eta*eta)*chi/(2268.*(-113. + 76.*eta));
alpha3S = (113.*chi)/24.;
alpha4S = (12769.*chi*chi*(-81. + 4.*eta))/(32.*pow(-113. + 76.*eta,2));
alpha5S = (-113.*chi*(502429. - 591368.*eta + 1680*eta*eta))/(16128.*(-113 + 76*eta));
/* tidal terms in the phase */
psi10T2 = -24./xi2 * (1. + 11. * xi1) * lam2 * xi2*xi2*xi2*xi2*xi2;
psi10T1 = -24./xi1 * (1. + 11. * xi2) * lam1 * xi1*xi1*xi1*xi1*xi1;
psi12T2 = -5./28./xi2 * (3179. - 919.* xi2 - 2286.* xi2*xi2 + 260.* xi2*xi2*xi2)* lam2 * xi2*xi2*xi2*xi2*xi2;
psi12T1 = -5./28./xi1 * (3179. - 919.* xi1 - 2286.* xi1*xi1 + 260.* xi1*xi1*xi1)* lam1 * xi1*xi1*xi1*xi1*xi1;
/* coefficients of the phase at PN orders from 0 to 3.5PN */
psiNewt = 3./(128.*eta);
psi2 = 3715./756. + 55.*eta/9.;
psi3 = psi3S - 16.*LAL_PI;
psi4 = 15293365./508032. + 27145.*eta/504. + 3085.*eta*eta/72. + psi4S;
psi5 = (38645.*LAL_PI/756. - 65.*LAL_PI*eta/9. + psi5S);
psi6 = 11583231236531./4694215680. - (640.*LAL_PI*LAL_PI)/3. - (6848.*LAL_GAMMA)/21.
+ (-5162.983708047263 + 2255.*LAL_PI*LAL_PI/12.)*eta
+ (76055.*eta*eta)/1728. - (127825.*eta*eta*eta)/1296.;
psi6L = -6848./21.;
psi7 = (77096675.*LAL_PI)/254016. + (378515.*LAL_PI*eta)/1512.
- (74045.*LAL_PI*eta*eta)/756.;
psi10 = psi10T1+psi10T2;
psi12 = psi12T1+psi12T2;
/* amplitude coefficients */
alpha2 = 1.1056547619047619 + (11*eta)/8.;
alpha3 = -LAL_TWOPI + alpha3S;
alpha4 = 0.8939214212884228 + (18913*eta)/16128. + (1379*eta*eta)/1152. + alpha4S;
alpha5 = (-4757*LAL_PI)/1344. + (57*eta*LAL_PI)/16. + alpha5S;
alpha6 = -58.601030974347324 + (3526813753*eta)/2.7869184e7 -
(1041557*eta*eta)/258048. + (67999*eta*eta*eta)/82944. +
(10*LAL_PI*LAL_PI)/3. - (451*eta*LAL_PI*LAL_PI)/96.;
alpha6L = 856/105.;
alpha7 = (-5111593*LAL_PI)/2.709504e6 - (72221*eta*LAL_PI)/24192. -
(1349*eta*eta*LAL_PI)/24192.;
/* select the terms according to the PN order chosen */
switch (ampO) {
case 0:
case 1:
alpha2 = 0.;
case 2:
alpha3 = 0.;
case 3:
alpha4 = 0.;
case 4:
alpha5 = 0.;
case 5:
alpha6 = 0.;
alpha6L = 0.;
case 6:
alpha7 = 0.;
default:
break;
}
switch (phaseO) {
case 0:
case 1:
psi2 = 0.;
case 2:
psi3 = 0.;
case 3:
psi4 = 0.;
case 4:
psi5 = 0.;
case 5:
psi6 = 0.;
psi6L = 0.;
case 6:
psi7 = 0.;
default:
break;
}
/* Fill with non-zero vals from fStart to lesser of fEnd, fISCO */
iStart = (size_t) ceil(fStart / deltaF);
data = (*htilde)->data->data;
const REAL8 logv0=log(v0);
const REAL8 log4=log(4.0);
for (i = iStart; i < n; i++) {
/* fourier frequency corresponding to this bin */
const REAL8 f = i * deltaF;
const REAL8 v3 = piM*f;
/* PN expansion parameter */
REAL8 Psi, amp;
const REAL8 v = cbrt(v3);
const REAL8 logv=log(v);
const REAL8 v2 = v*v;
const REAL8 v4 = v3*v;
const REAL8 v5 = v4*v;
const REAL8 v6 = v3*v3;
const REAL8 v7 = v6*v;
const REAL8 v10 = v5*v5;
const REAL8 v12 = v6*v6;
/* compute the phase and amplitude */
Psi = psiNewt / v5 * (1.
+ psi2 * v2 + psi3 * v3 + psi4 * v4
+ psi5 * v5 * (1. + 3. * (logv - logv0))
+ (psi6 + psi6L * (log4 + logv)) * v6 + psi7 * v7)
+ psi10 * v10 + psi12 * v12;
amp = amp0 * pow(f, mSevenBySix) * (1.
+ alpha2 * v2 + alpha3 * v3 + alpha4 * v4 + alpha5 * v5
+ (alpha6 + alpha6L * (LAL_GAMMA + (log4 + logv))) * v6
+ alpha7 * v7);
data[i] = amp * cos(Psi + shft * f - 2.*phic - LAL_PI_4) - I * (amp * sin(Psi + shft * f - 2.*phic - LAL_PI_4));
}
return XLAL_SUCCESS;
}
int main( void )
{
static LALStatus status;
REAL4Sequence *sSequenceIn;
REAL4Sequence *sSequenceOut;
REAL8Sequence *dSequenceIn;
REAL8Sequence *dSequenceOut;
COMPLEX8Sequence *cSequenceIn;
COMPLEX8Sequence *cSequenceOut;
COMPLEX16Sequence *zSequenceIn;
COMPLEX16Sequence *zSequenceOut;
REAL4FrequencySeries sFrequencySeries;
REAL8FrequencySeries dFrequencySeries;
COMPLEX8FrequencySeries cFrequencySeries;
COMPLEX16FrequencySeries zFrequencySeries;
REAL4FrequencySeries sFrequencySeries2;
REAL8FrequencySeries dFrequencySeries2;
COMPLEX8FrequencySeries cFrequencySeries2;
COMPLEX16FrequencySeries zFrequencySeries2;
REAL4TimeSeries sTimeSeries;
REAL8TimeSeries dTimeSeries;
COMPLEX8TimeSeries cTimeSeries;
COMPLEX16TimeSeries zTimeSeries;
REAL4TimeSeries sTimeSeries2;
REAL8TimeSeries dTimeSeries2;
COMPLEX8TimeSeries cTimeSeries2;
COMPLEX16TimeSeries zTimeSeries2;
REAL4 *sData;
REAL8 *dData;
COMPLEX8 *cData;
COMPLEX16 *zData;
/* Boolean Vars */
BOOLEAN unitComp;
/* variables for units */
RAT4 raise;
LALUnit strainToMinus2;
LALUnit adcToMinus2;
LALUnit adcStrain;
/* This routine should generate a file with data */
/* to be read by ReadFTSeries.c*/
LIGOTimeGPS t;
UINT4 i;
/* Data Test Variable */
UINT4 j;
fprintf(stderr,"Testing value of LALUnitTextSize ... ");
if ( (int)LALSupportUnitTextSize != (int)LALUnitTextSize )
{
fprintf(stderr,"UnitTextSize mismatch: [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
fprintf(stderr,"PASS\n");
t.gpsSeconds = 0;
t.gpsNanoSeconds = 0;
fprintf(stderr,"Testing Print/Read COMPLEX8FrequencySeries ... ");
cSequenceIn = NULL;
LALCCreateVector(&status, &cSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
{
*(cData) = crectf( i, i+1 );
}
strncpy(cFrequencySeries.name,"Complex frequency series",LALNameLength);
cFrequencySeries.sampleUnits = lalHertzUnit;
cFrequencySeries.deltaF = 1;
cFrequencySeries.epoch = t;
cFrequencySeries.f0 = 5;
cFrequencySeries.data = cSequenceIn;
LALCPrintFrequencySeries(&cFrequencySeries, "cFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cSequenceOut = NULL;
LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cFrequencySeries2.data = cSequenceOut;
LALCReadFrequencySeries(&status, &cFrequencySeries2, "./cFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(cFrequencySeries.deltaF - cFrequencySeries.deltaF)/
cFrequencySeries.deltaF > READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaF MisMatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(cFrequencySeries.name,cFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.epoch.gpsSeconds) !=
(cFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.epoch.gpsNanoSeconds) !=
(cFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanosecondMismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cFrequencySeries.f0) ?
(fabs(cFrequencySeries.f0 - cFrequencySeries2.f0)/cFrequencySeries.f0) :
(fabs(cFrequencySeries.f0 - cFrequencySeries2.f0) >
READFTSERIESTEST_TOL))
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&cFrequencySeries.sampleUnits,&cFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < cSequenceIn->length;j++)
{
if ((crealf(cSequenceIn->data[j]) ?
fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
/crealf(cSequenceIn->data[j]))
:fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimagf(cSequenceIn->data[j]) ?
fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
/cimagf(cSequenceIn->data[j]))
:fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX16FrequencySeries ... ");
/* Test case 2 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
zSequenceIn = NULL;
LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
{
*(zData) = crect( i/4.0, (i+1)/5.0 );
}
zFrequencySeries.sampleUnits = lalDimensionlessUnit;
strncpy(zFrequencySeries.name,"Complex frequency series",LALNameLength);
zFrequencySeries.deltaF = 1.3;
zFrequencySeries.epoch = t;
zFrequencySeries.f0 = 0;
zFrequencySeries.data = zSequenceIn;
LALZPrintFrequencySeries(&zFrequencySeries, "zFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zSequenceOut = NULL;
LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zFrequencySeries2.data = zSequenceOut;
LALZReadFrequencySeries(&status, &zFrequencySeries2, "./zFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if ((zFrequencySeries.deltaF) != (zFrequencySeries2.deltaF))
{
fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(zFrequencySeries.name,zFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zFrequencySeries.epoch.gpsSeconds) !=
(zFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zFrequencySeries.epoch.gpsNanoSeconds) !=
(zFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (zFrequencySeries.f0 ?
(fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)/zFrequencySeries.f0)
: (fabs(zFrequencySeries.f0 - zFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&zFrequencySeries.sampleUnits,&zFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < zSequenceIn->length;j++)
{
if ((creal(zSequenceIn->data[j]) ?
fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
/creal(zSequenceIn->data[j])) :
fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimag(zSequenceIn->data[j]) ?
fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
/cimag(zSequenceIn->data[j])) :
fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL8FrequencySeries ... ");
/* Test case 3 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
dSequenceIn = NULL;
LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
{
*(dData) = 0.005;
}
strncpy(dFrequencySeries.name,"Complex frequency series",LALNameLength);
/* set units */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&dFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dFrequencySeries.deltaF = 1.3;
dFrequencySeries.epoch = t;
dFrequencySeries.f0 = 0;
dFrequencySeries.data = dSequenceIn;
LALDPrintFrequencySeries(&dFrequencySeries, "dFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dSequenceOut = NULL;
LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dFrequencySeries2.data = dSequenceOut;
LALDReadFrequencySeries(&status, &dFrequencySeries2, "./dFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if ((dFrequencySeries.deltaF) != (dFrequencySeries.deltaF))
{
fprintf(stderr,"DeltaF Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(dFrequencySeries.name,dFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dFrequencySeries.epoch.gpsSeconds)
!= (dFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dFrequencySeries.epoch.gpsSeconds)
!= (dFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (dFrequencySeries.f0 ?
(fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)/dFrequencySeries.f0)
: (fabs(dFrequencySeries.f0 - dFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&dFrequencySeries.sampleUnits,&dFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < dSequenceIn->length;j++)
{
if ((dSequenceIn->data[j] ?
fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
/dSequenceIn->data[j])
:fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL4FrequencySeries ... ");
/* Test case 4 */
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
sSequenceIn = NULL;
LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
{
*(sData) = 0.005;
}
strncpy(sFrequencySeries.name,"Complex frequency series",LALNameLength);
/* set units */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sFrequencySeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sFrequencySeries.deltaF = 1.3;
sFrequencySeries.epoch = t;
sFrequencySeries.f0 = 5;
sFrequencySeries.data = sSequenceIn;
sSequenceOut = NULL;
LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sFrequencySeries2.data = sSequenceOut;
LALSPrintFrequencySeries(&sFrequencySeries, "sFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSReadFrequencySeries(&status, &sFrequencySeries2, "./sFSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(sFrequencySeries.deltaF - sFrequencySeries2.deltaF)
/sFrequencySeries.deltaF > READFTSERIESTEST_TOL)
{
fprintf(stderr,"Deltaf Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(sFrequencySeries.name,sFrequencySeries2.name)!=0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sFrequencySeries.epoch.gpsSeconds) !=
(sFrequencySeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sFrequencySeries.epoch.gpsNanoSeconds) !=
(sFrequencySeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (sFrequencySeries.f0 ?
(fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)/sFrequencySeries.f0)
: (fabs(sFrequencySeries.f0 - sFrequencySeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&sFrequencySeries.sampleUnits,&sFrequencySeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < sSequenceIn->length;j++)
{
if ((sSequenceIn->data[j] ?
fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
/sSequenceIn->data[j])
:fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
LALCDestroyVector(&status, &cSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCDestroyVector(&status, &cSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL4TimeSeries ... ");
/* Here is where testing for ReadTimeSeries is done */
/* S Case ReadTimeSeries */
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
sSequenceIn = NULL;
LALSCreateVector( &status, &sSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, sData=sSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, sData++ )
{
*(sData) = 0.005;
}
strncpy(sTimeSeries.name,"Real4 Time series",LALNameLength);
sTimeSeries.deltaT = 1.3;
sTimeSeries.epoch = t;
sTimeSeries.data = sSequenceIn;
sTimeSeries.f0 = 5;
LALSPrintTimeSeries(&sTimeSeries, "sTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sSequenceOut = NULL;
LALSCreateVector( &status, &sSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
sTimeSeries2.data = sSequenceOut;
LALSReadTimeSeries(&status, &sTimeSeries2, "./sTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(sTimeSeries.deltaT-sTimeSeries2.deltaT) /
sTimeSeries.deltaT > READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(sFrequencySeries.name,sFrequencySeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sTimeSeries.epoch.gpsSeconds) != (sTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((sTimeSeries.epoch.gpsNanoSeconds) != (sTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch NanoSeconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
/* printf("%f ... %f f0 value\n",sTimeSeries.f0,sTimeSeries2.f0);*/
if (sTimeSeries.f0 ?
(fabs(sTimeSeries.f0 - sTimeSeries2.f0)/sTimeSeries.f0)
: (fabs(sTimeSeries.f0 - sTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&sTimeSeries.sampleUnits,&sTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < sSequenceIn->length;j++)
{
if ((sSequenceIn->data[j] ?
fabs((sSequenceIn->data[j] - sSequenceOut->data[j])
/sSequenceIn->data[j])
:fabs(sSequenceIn->data[j] - sSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX16TimeSeries ... ");
/* Z case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&zTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
zSequenceIn = NULL;
LALZCreateVector( &status, &zSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, zData=zSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, zData++ )
{
*(zData) = crect( 0.005, 1 );
}
strncpy(zTimeSeries.name,"Complex16 Time series",LALNameLength);
zTimeSeries.deltaT = 1.3;
zTimeSeries.epoch = t;
zTimeSeries.data = zSequenceIn;
zTimeSeries.f0 = 0;
LALZPrintTimeSeries(&zTimeSeries, "zTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zSequenceOut = NULL;
LALZCreateVector( &status, &zSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
zTimeSeries2.data = zSequenceOut;
LALZReadTimeSeries(&status, &zTimeSeries2, "./zTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(zTimeSeries.deltaT) - (zTimeSeries2.deltaT)/zTimeSeries.deltaT >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Mismatch DeltaT [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(zTimeSeries.name,zTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((zTimeSeries.epoch.gpsSeconds) != (zTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Second Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ( (zTimeSeries.epoch.gpsNanoSeconds)
!= (zTimeSeries2.epoch.gpsNanoSeconds) )
{
fprintf(stderr,"Epoch Nanosecond Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (zTimeSeries.f0 ?
(fabs(zTimeSeries.f0 - zTimeSeries2.f0)/zTimeSeries.f0)
: (fabs(zTimeSeries.f0 - zTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&zTimeSeries.sampleUnits,&zTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFUN;
}
for (j = 0; j < zSequenceIn->length;j++)
{
if ((creal(zSequenceIn->data[j]) ?
fabs((creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))
/creal(zSequenceIn->data[j]))
:fabs(creal(zSequenceIn->data[j]) - creal(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimag(zSequenceIn->data[j]) ?
fabs((cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))
/cimag(zSequenceIn->data[j]))
:fabs(cimag(zSequenceIn->data[j]) - cimag(zSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read REAL8TimeSeries ... ");
/* D case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&sTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
strncpy(dTimeSeries.name,"REAL8 Time series",LALNameLength);
dTimeSeries.sampleUnits = lalHertzUnit;
t.gpsSeconds = 4578;
t.gpsNanoSeconds = 890634;
dSequenceIn = NULL;
LALDCreateVector( &status, &dSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, dData=dSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, dData++ )
{
*(dData) = 0.005;
}
dTimeSeries.deltaT = 1.3;
dTimeSeries.epoch = t;
dTimeSeries.data = dSequenceIn;
dTimeSeries.f0 = 0;
LALDPrintTimeSeries(&dTimeSeries, "dTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dSequenceOut = NULL;
LALDCreateVector( &status, &dSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
dTimeSeries2.data = dSequenceOut;
LALDReadTimeSeries(&status, &dTimeSeries2, "./dTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(dTimeSeries.deltaT) - (dTimeSeries2.deltaT)/dTimeSeries.deltaT
> READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
status.statusDescription );
return READFTSERIESTESTC_EFLS;
}
if (strcmp(dTimeSeries.name,dTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%d,%s]\n",status.statusCode,
status.statusDescription );
return READFTSERIESTESTC_EFLS;
}
if ((dTimeSeries.epoch.gpsSeconds) != (dTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((dTimeSeries.epoch.gpsNanoSeconds)
!= (dTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (dTimeSeries.f0 ?
(fabs(dTimeSeries.f0 - dTimeSeries2.f0)/dTimeSeries.f0)
: (fabs(dTimeSeries.f0 - dTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&dTimeSeries.sampleUnits,&dTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Unit Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < dSequenceIn->length;j++)
{
if ((dSequenceIn->data[j] ?
fabs((dSequenceIn->data[j] - dSequenceOut->data[j])
/dSequenceIn->data[j])
:fabs(dSequenceIn->data[j] - dSequenceOut->data[j])) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
fprintf(stderr,"Testing Print/Read COMPLEX8TimeSeries ... ");
/* C case ReadTimeSeries*/
raise.numerator = -2;
raise.denominatorMinusOne = 0;
if (XLALUnitRaiseRAT4(&strainToMinus2, &lalStrainUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitRaiseRAT4(&adcToMinus2, &lalADCCountUnit, &raise) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&(adcStrain), &strainToMinus2, &adcToMinus2) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (XLALUnitMultiply(&cTimeSeries.sampleUnits, &adcStrain, &lalHertzUnit) == NULL)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
t.gpsSeconds = 45678;
t.gpsNanoSeconds = 89065834;
cSequenceIn = NULL;
LALCCreateVector( &status, &cSequenceIn, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
for ( i=1, cData=cSequenceIn->data; i<=READFTSERIESTEST_LEN ; i++, cData++ )
{
*(cData) = crectf( 0.005, 1 );
}
strncpy(cTimeSeries.name,"Complex8 Time series",LALNameLength);
cTimeSeries.deltaT = 1.3;
cTimeSeries.epoch = t;
cTimeSeries.data = cSequenceIn;
cTimeSeries.f0 = 0;
cSequenceOut = NULL;
LALCPrintTimeSeries(&cTimeSeries, "cTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCCreateVector( &status, &cSequenceOut, READFTSERIESTEST_LEN);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
cTimeSeries2.data = cSequenceOut;
LALCReadTimeSeries(&status, &cTimeSeries2, "./cTSInput.dat");
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
if (fabs(cTimeSeries.deltaT - cTimeSeries2.deltaT)/cTimeSeries.deltaT
> READFTSERIESTEST_TOL)
{
fprintf(stderr,"DeltaT Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (strcmp(cTimeSeries.name,cTimeSeries2.name) != 0)
{
fprintf(stderr,"Name Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cTimeSeries.epoch.gpsSeconds) != (cTimeSeries2.epoch.gpsSeconds))
{
fprintf(stderr,"Epoch Seconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cTimeSeries.epoch.gpsNanoSeconds)!=(cTimeSeries2.epoch.gpsNanoSeconds))
{
fprintf(stderr,"Epoch Nanoseconds Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if (cTimeSeries.f0 ?
(fabs(cTimeSeries.f0 - cTimeSeries2.f0)/cTimeSeries.f0)
: (fabs(cTimeSeries.f0 - cTimeSeries2.f0)) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"f0 Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
unitComp = XLALUnitCompare(&cTimeSeries.sampleUnits,&cTimeSeries2.sampleUnits);
if (unitComp != 0)
{
fprintf(stderr,"Units Mismatch [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
for (j = 0; j < cSequenceIn->length;j++)
{
if ((crealf(cSequenceIn->data[j]) ?
fabs((crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))
/crealf(cSequenceIn->data[j]))
:fabs(crealf(cSequenceIn->data[j]) - crealf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
if ((cimagf(cSequenceIn->data[j]) ?
fabs((cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))
/cimagf(cSequenceIn->data[j]))
:fabs(cimagf(cSequenceIn->data[j]) - cimagf(cSequenceOut->data[j]))) >
READFTSERIESTEST_TOL)
{
fprintf(stderr,"Data Tolerance Exceeded [ReadFTSeriesTest:%s]\n",
READFTSERIESTESTC_MSGEFLS);
return READFTSERIESTESTC_EFLS;
}
}
fprintf(stderr,"PASS\n");
/* *******************Deallocate all memory****************** */
LALCDestroyVector(&status, &cSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCDestroyVector(&status, &cSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALZDestroyVector(&status, &zSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALDDestroyVector(&status, &dSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceIn);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALSDestroyVector(&status, &sSequenceOut);
if (status.statusCode != 0)
{
fprintf(stderr,"[%i]: %s [ReadFTSeriesTest:%s]\n",status.statusCode,
status.statusDescription, READFTSERIESTESTC_MSGEFUN);
return READFTSERIESTESTC_EFUN;
}
LALCheckMemoryLeaks();
fprintf(stderr,"ReadFTSeries passed all tests.\n");
return READFTSERIESTESTC_ENOM;
}
static int IMRPhenomDGenerateFD(
COMPLEX16FrequencySeries **htilde, /**< FD waveform */
const REAL8 phi0, /**< phase at peak */
const REAL8 deltaF, /**< frequency resolution */
const REAL8 m1, /**< mass of companion 1 [solar masses] */
const REAL8 m2, /**< mass of companion 2 [solar masses] */
const REAL8 chi1_in, /**< aligned-spin of companion 1 */
const REAL8 chi2_in, /**< aligned-spin of companion 2 */
const REAL8 f_min, /**< start frequency */
const REAL8 f_max, /**< end frequency */
const REAL8 distance /**< distance to source (m) */
) {
LIGOTimeGPS ligotimegps_zero = LIGOTIMEGPSZERO; // = {0, 0}
const REAL8 M = m1 + m2;
REAL8 eta = m1 * m2 / (M * M);
const REAL8 M_sec = M * LAL_MTSUN_SI;
REAL8 chi1, chi2;
if (m1>m2) { // swap spins
chi1 = chi1_in;
chi2 = chi2_in;
} else {
chi1 = chi2_in;
chi2 = chi1_in;
}
/* Compute the amplitude pre-factor */
REAL8 amp0 = 2. * sqrt(5. / (64.*LAL_PI)) * M * LAL_MRSUN_SI * M * LAL_MTSUN_SI / distance;
/* Allocate htilde */
size_t n = NextPow2(f_max / deltaF) + 1;
/* Coalesce at t=0 */
XLALGPSAdd(&ligotimegps_zero, -1. / deltaF); // shift by overall length in time
*htilde = XLALCreateCOMPLEX16FrequencySeries("htilde: FD waveform", &ligotimegps_zero, 0.0,
deltaF, &lalStrainUnit, n);
memset((*htilde)->data->data, 0, n * sizeof(COMPLEX16));
XLALUnitMultiply(&((*htilde)->sampleUnits), &((*htilde)->sampleUnits), &lalSecondUnit);
if (!(*htilde)) XLAL_ERROR(XLAL_EFUNC);
size_t ind_min = (size_t) (f_min / deltaF);
size_t ind_max = (size_t) (f_max / deltaF);
// Calculate phenomenological parameters
IMRPhenomDAmplitudeCoefficients *pAmp = ComputeIMRPhenomDAmplitudeCoefficients(eta, chi1, chi2);
IMRPhenomDPhaseCoefficients *pPhi = ComputeIMRPhenomDPhaseCoefficients(eta, chi1, chi2);
if (!pAmp || !pPhi) XLAL_ERROR(XLAL_EFUNC);
// Compute coefficients to make phase C^1
ComputeIMRPhenDPhaseConnectionCoefficients(pPhi);
/* Now generate the waveform */
#pragma omp parallel for
for (size_t i = ind_min; i < ind_max; i++) {
REAL8 Mf = M_sec * i * deltaF; // geometric frequency
REAL8 amp = IMRPhenDAmplitude(Mf, pAmp);
REAL8 phi = IMRPhenDPhase(Mf, pPhi);
phi -= 2.*phi0; // factor of 2 b/c phi0 is orbital phase
((*htilde)->data->data)[i] = amp0 * amp * cexp(-I * phi);
}
LALFree(pAmp);
LALFree(pPhi);
return XLAL_SUCCESS;
}
