int tester(const std::string & input_file)
{
//temperature
std::vector<Scalar> T0,Tz;
read_temperature<Scalar>(T0,Tz,input_file);
gsl_interp_accel * acc = gsl_interp_accel_alloc();
gsl_spline * spline = gsl_spline_alloc(gsl_interp_cspline, T0.size());
// GLS takes only double, raaaaahhhh
std::vector<double> gsl_x_point(T0.size(),0);
std::vector<double> gsl_y_point(T0.size(),0);
for(unsigned int i = 0; i < T0.size(); i++)
{
gsl_x_point[i] = (const double)Tz[i];
gsl_y_point[i] = (const double)T0[i];
}
const double * x = &gsl_x_point[0];
const double * y = &gsl_y_point[0];
gsl_spline_init(spline, x, y, T0.size());
Planet::AtmosphericTemperature<Scalar,std::vector<Scalar> > temperature(Tz,T0); //neutral, ionic, altitude
int return_flag(0);
const Scalar tol = (std::numeric_limits<Scalar>::epsilon() * 100. < 6e-17)?6e-17:
std::numeric_limits<Scalar>::epsilon() * 100.;
for(Scalar z = 600.; z < 1401.; z += 10)
{
Scalar neu_temp = gsl_spline_eval(spline,z,acc);
Scalar neu_dtemp = gsl_spline_eval_deriv(spline,z,acc);
Scalar ion_temp = gsl_spline_eval(spline,z,acc);
Scalar ion_dtemp = gsl_spline_eval_deriv(spline,z,acc);
Scalar e_temp = electron_temperature(z);
Scalar de_dtemp = delectron_temperature(z);
return_flag = check(temperature.neutral_temperature(z), neu_temp, tol, "neutral temperature") ||
check(temperature.dneutral_temperature_dz(z), neu_dtemp, tol, "neutral temperature differentiate") ||
check(temperature.ionic_temperature(z), ion_temp, tol, "ionic temperature") ||
check(temperature.dionic_temperature_dz(z), ion_dtemp, tol, "ionic temperature differentiate") ||
check(temperature.electronic_temperature(z), e_temp, tol, "electron temperature") ||
check(temperature.delectronic_temperature_dz(z), de_dtemp, tol, "electron temperature differentiate") ||
return_flag;
}
gsl_spline_free(spline);
gsl_interp_accel_free(acc);
return return_flag;
}
/// Calculate dlog\sigma/dlogM for a mass M in h^{-1} Msun
/// numerically using the spline
double cosmology::varM_TH_num_deriv(double M, double z)
{
//
if(!bool_init_varM_TH_spline)
{
//std::cout<<"# I called it: varM_TH_num_deriv"<<std::endl;
init_varM_TH_spline();
}
double logm=log(M)/log(10.);
double result;
if(logm>5&&logm<18.0)
{
result=gsl_spline_eval_deriv (varM_TH_num_spline,logm, varM_TH_num_acc);
} else
{
std::cout<<"# "<<"varM_TH_num_spline: Interpolation for derivative not possible, M not within range "<<M<<std::endl;
exit(0);
result=varM_TH(M,z);
}
result = pow(10.,result);
if(z!=z_glob){
result=result*pow(growthfactor_num(z),2.);
}else{
result=result*pow(gf_glob,2.);
}
return result;
}
/**
* Computes RHS of ODE for gamma. Eq. 10 of PRD 89, 084006 (2014)
*/
static double f_alphadotcosi( double x, void * inparams )
{
PrecEulerAnglesIntegration* params = (PrecEulerAnglesIntegration*) inparams;
REAL8 alphadot = gsl_spline_eval_deriv( params->alpha_spline, x, params->alpha_acc );
REAL8 beta = gsl_spline_eval( params->beta_spline, x, params->beta_acc );
return -1. * alphadot * cos(beta);
}
/** Calculate the derivatives of each of the supplied points
*
* @param out :: The array to store the calculated derivatives
* @param xValues :: The array of x values we wish to calculate derivatives at
* @param nData :: The size of the arrays
* @param order :: The order of derivatives to calculate too
*/
void CubicSpline::calculateDerivative(double* out, const double* xValues,
const size_t nData, const size_t order) const
{
double xDeriv = 0;
int errorCode = 0;
bool outOfRange(false);
//throw error if the order is not the 1st or 2nd derivative
if(order < 1) throw std::invalid_argument(
"CubicSpline: order of derivative must be 1 or greater");
for(size_t i = 0; i < nData; ++i)
{
if(checkXInRange(xValues[i]))
{
//choose the order of the derivative
if(order == 1)
{
xDeriv = gsl_spline_eval_deriv(m_spline.get(),xValues[i],m_acc.get());
errorCode = gsl_spline_eval_deriv_e (m_spline.get(),xValues[i],m_acc.get(),&xDeriv);
}
else if (order == 2)
{
xDeriv = gsl_spline_eval_deriv2(m_spline.get(),xValues[i],m_acc.get());
errorCode = gsl_spline_eval_deriv2_e (m_spline.get(),xValues[i],m_acc.get(),&xDeriv);
}
}
else
{
//if out of range, just set it to zero
outOfRange = true;
xDeriv = 0;
}
//check GSL functions didn't return an error
checkGSLError(errorCode, GSL_EDOM);
//record the value
out[i] = xDeriv;
}
//warn user that some values weren't calculated
if(outOfRange)
{
g_log.warning() << "Some x values where out of range and will not be calculated." << std::endl;
}
}
static int
bicubic_init(void * vstate, const double xa[], const double ya[],
const double za[], size_t xsize, size_t ysize)
{
bicubic_state_t *state = (bicubic_state_t *) vstate;
gsl_interp_accel *acc = gsl_interp_accel_alloc();
gsl_spline *spline;
gsl_vector *x;
gsl_vector *y;
size_t i, j;
x = gsl_vector_alloc(xsize);
y = gsl_vector_alloc(xsize);
spline = gsl_spline_alloc(gsl_interp_cspline, xsize);
for (j = 0; j <= ysize - 1; j++)
{
for (i = 0; i <= xsize - 1; i++)
{
gsl_vector_set(x, i, xa[i]);
gsl_vector_set(y, i, za[IDX2D(i, j, state)]);
}
gsl_spline_init(spline, x->data, y->data, xsize);
for (i = 0; i <= xsize - 1; i++)
{
state->zx[IDX2D(i, j, state)] = gsl_spline_eval_deriv(spline, xa[i], acc);
}
}
gsl_vector_free(x);
gsl_vector_free(y);
gsl_spline_free(spline);
gsl_interp_accel_reset(acc);
x = gsl_vector_alloc(ysize);
y = gsl_vector_alloc(ysize);
spline = gsl_spline_alloc(gsl_interp_cspline, ysize);
for (i = 0; i <= xsize - 1; i++)
{
for (j = 0; j <= ysize - 1; j++)
{
gsl_vector_set(x, j, ya[j]);
gsl_vector_set(y, j, za[IDX2D(i, j, state)]);
}
gsl_spline_init(spline, x->data, y->data, ysize);
for (j = 0; j <= ysize - 1; j++)
{
state->zy[IDX2D(i, j, state)] = gsl_spline_eval_deriv(spline, ya[j], acc);
}
}
gsl_vector_free(x);
gsl_vector_free(y);
gsl_spline_free(spline);
gsl_interp_accel_reset(acc);
x = gsl_vector_alloc(xsize);
y = gsl_vector_alloc(xsize);
spline = gsl_spline_alloc(gsl_interp_cspline, xsize);
for (j = 0; j <= ysize - 1; j++)
{
for (i = 0; i <= xsize - 1; i++)
{
gsl_vector_set(x, i, xa[i]);
gsl_vector_set(y, i, state->zy[IDX2D(i, j, state)]);
}
gsl_spline_init(spline, x->data, y->data, xsize);
for (i = 0; i <= xsize - 1; i++)
{
state->zxy[IDX2D(i, j, state)] = gsl_spline_eval_deriv(spline, xa[i], acc);
}
}
gsl_vector_free(x);
gsl_vector_free(y);
gsl_spline_free(spline);
gsl_interp_accel_free(acc);
return GSL_SUCCESS;
} /* bicubic_init() */
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;
}
/**
* 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);
}
int main(int argc, char **argv){
FILE *fid;
DIR* dir;
char fname[300];
long int i,j,nz,elem;
double aver[1000],fcollv[1000],sfrv[1000],zv[1000];
float *halo_mass;
double zmin,zmax,dz,redshift;
if(argc==1 || argc > 5) {
printf("Generates SFRD using nonlinear halo boxes\n");
printf("usage: get_SFR base_dir [zmin] [zmax] [dz]\n");
printf("base_dir contains simfast21.ini\n");
exit(1);
}
get_Simfast21_params(argv[1]);
if(global_use_Lya_xrays==0) {printf("Lya and xray use set to false - no need to calculate SFR\n");exit(0);}
if(argc > 2) {
zmin=atof(argv[2]);
if (zmin < global_Zminsfr) zmin=global_Zminsfr;
if(argc > 3) {
zmax=atof(argv[3]);
if(zmax>global_Zmaxsim) zmax=global_Zmaxsim;
if(argc==5) dz=atof(argv[4]); else dz=global_Dzsim;
}else {
zmax=global_Zmaxsim;
dz=global_Dzsim;
}
zmin=zmax-dz*ceil((zmax-zmin)/dz); /* make sure (zmax-zmin)/dz is an integer so that we get same redshifts starting from zmin or zmax...*/
}else {
zmin=global_Zminsfr;
zmax=global_Zmaxsim;
dz=global_Dzsim;
}
printf("\nCalculating SFRD between z=%f and z=%f with step %f\n",zmin,zmax,dz);
#ifdef _OMPTHREAD_
omp_set_num_threads(global_nthreads);
printf("Using %d threads\n",global_nthreads);
#endif
/* Create directory SFR */
sprintf(fname,"%s/SFR",argv[1]);
if((dir=opendir(fname))==NULL) {
printf("Creating SFR directory\n");
if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) {
printf("Error creating directory!\n");
exit(1);
}
}
if(!(halo_mass=(float *) malloc(global_N3_smooth*sizeof(float)))) {
printf("Problem...\n");
exit(1);
}
nz=0;
printf("Calculating halo mass average...\n");
for(redshift=zmin;redshift<(zmax+dz/10);redshift+=dz){
zv[nz]=redshift;
sprintf(fname, "%s/Halos/halonl_z%.3f_N%ld_L%.0f.dat",argv[1],redshift,global_N_smooth,global_L);
if((fid=fopen(fname,"rb"))==NULL){
printf("\nError opening %s\n",fname);
exit(1);
}
elem=fread(halo_mass,sizeof(float),global_N3_smooth,fid);
fclose(fid);
aver[nz]=0.;
for(i=0;i<global_N3_smooth;i++) aver[nz]+=halo_mass[i];
fcollv[nz]=aver[nz]/(global_rho_m*global_L3); /* Msun/(Mpc/h)^3 */
aver[nz]/=global_N3_smooth;
nz++;
}
printf("Interpolation for SFRD...\n");
gsl_interp_accel *acc = gsl_interp_accel_alloc ();
gsl_spline *spline = gsl_spline_alloc (gsl_interp_cspline, nz);
gsl_spline_init (spline, zv, fcollv, nz);
sprintf(fname,"%s/Output_text_files",argv[1]);
if((dir=opendir(fname))==NULL) {
printf("Creating Output_text_files directory\n");
if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) {
printf("Error creating directory!\n");
exit(1);
}
}
sprintf(fname,"%s/Output_text_files/sfrd_av_N%ld_L%.0f.dat",argv[1],global_N_smooth,global_L);
if((fid=fopen(fname,"a"))==NULL){
printf("\nError opening output %s file...\n",fname);
exit(1);
}
for(i=nz-1;i>=0;i--) {
sfrv[i]=gsl_spline_eval_deriv(spline, zv[i], acc)*dzdt(zv[i])/3.171E-8*global_rho_b*global_fstar; /* SFRD in Msun/(Mpc/h)^3/year */
if(sfrv[i]<0.) sfrv[i]=0.;
fprintf(fid,"%f %.8E\n",zv[i],sfrv[i]);
}
fclose(fid);
gsl_spline_free (spline);
gsl_interp_accel_free (acc);
printf("Writing SFRD files...\n");
for(i=0;i<nz;i++) {
sprintf(fname, "%s/Halos/halonl_z%.3f_N%ld_L%.0f.dat",argv[1],zv[i],global_N_smooth,global_L);
if((fid=fopen(fname,"rb"))==NULL){
printf("\nError opening %s\n",fname);
exit(1);
}
elem=fread(halo_mass,sizeof(float),global_N3_smooth,fid);
fclose(fid);
if(aver[i]>0.)
for(j=0;j<global_N3_smooth;j++) halo_mass[j]*=sfrv[i]/aver[i];
else for(j=0;j<global_N3_smooth;j++) halo_mass[j]=0.;
sprintf(fname, "%s/SFR/sfrd_z%.3f_N%ld_L%.0f.dat",argv[1],zv[i],global_N_smooth,global_L);
if((fid=fopen(fname,"wb"))==NULL){
printf("\nError opening output sfrd file... Chech if path is correct...\n");
}
elem=fwrite(halo_mass,sizeof(float),global_N3_smooth,fid);
fclose(fid);
}
exit(0);
}
/* Performs the derivative of a spline */
double FC_FUNC_(oct_spline_eval_der, OCT_SPLINE_EVAL_DER)
(const double *x, const void **spl, void **acc)
{
/* the GSL headers specify double x */
return gsl_spline_eval_deriv((gsl_spline *)(*spl), *x, (gsl_interp_accel *)(*acc));
}
void TrajectoryControl::DamelioFontanile_controller(double x, double y,
double phi, double* s_path_act, spline_param x_path, spline_param y_path,
spline_param ds_path, double dt, double lungh, double* v_ref,
double* psi_ref) {
phi = fmod(phi, 2 * M_PI);
// calcolo configurazione riferimento nella ascissa corrente
double xr = gsl_spline_eval(x_path.spline_coeff, *s_path_act,
x_path.accumulator);
double yr = gsl_spline_eval(y_path.spline_coeff, *s_path_act,
y_path.accumulator);
double phir = atan2(
gsl_spline_eval_deriv(y_path.spline_coeff, *s_path_act,
y_path.accumulator),
gsl_spline_eval_deriv(x_path.spline_coeff, *s_path_act,
x_path.accumulator));
/* calcolo e, alpha,theta*/
double e = sqrt(pow(xr - x, 2) + pow(yr - y, 2));
double theta = atan2(yr - y, xr - x) - phir;
double alpha = theta + phir - phi;
theta = angle_wrap(theta);
alpha = angle_wrap(alpha);
/* calcolo delle variabili di controllo*/
// calcola velocita'
*v_ref = fmin(_GAMMA * e,
gsl_spline_eval(ds_path.spline_coeff, *s_path_act, ds_path.accumulator)); // e' gia' compresa la saturazione
double b;
if (abs(alpha) < _SOGLIA_ALPHA)
b = 1;
else
b = sin(alpha) / alpha;
double c = fmax(
fmin(sin(alpha) / e + theta / e * b + _BETA * alpha / e, _MAX_CURVATURE),
-_MAX_CURVATURE); // curvatura gia' saturata
// calcola angolo di sterzo
*psi_ref = atan(c * _L); // angolo di sterzo della ruota anteriore nel modello bicicletta
/* calcolo della funzione V*/
double V = _LAMBDA * (pow(e, 2)) + pow(alpha, 2) + _H * (pow(theta, 2));
double S_punto;
if (V > _EPSILON)
S_punto = 0;
else
S_punto = (gsl_spline_eval(ds_path.spline_coeff, *s_path_act,
ds_path.accumulator)) * (1 - V / _EPSILON);
// Aggiorno la posizione sul path
*s_path_act += (S_punto * dt) / lungh;
/* debug, publish the following frame xr, yr, phir */
geometry_msgs::PoseStamped ff;
// TODO: put the timestamp of the incoming pose
ff.header.stamp = ros::Time(0.0);
ff.header.frame_id = "/world";
// TODO: put the same z as the robot pose
ff.pose.position.x = xr;
ff.pose.position.y = yr;
ff.pose.position.z = 0.0;
ff.pose.orientation.w = cos(phir / 2.0);
ff.pose.orientation.x = 0.0;
ff.pose.orientation.y = 0.0;
ff.pose.orientation.z = sin(phir / 2.0);
_followingFrame.publish(ff);
quadrivio_msgs::ControllerInternal msg;
msg.header.stamp = ros::Time::now();
msg.V = V;
msg.S_punto = S_punto;
msg.e = e;
msg.theta = theta;
msg.alpha = alpha;
_internalValues.publish(msg);
/* end of debug */
}
/*
* Core function for computing the ROM waveform.
* Evaluates projection coefficients and shifts in time and phase at desired q.
* Construct 1D splines for amplitude and phase.
* Compute strain waveform from amplitude and phase.
*/
static INT4 EOBNRv2HMROMCore(
COMPLEX16FrequencySeries **hptilde,
COMPLEX16FrequencySeries **hctilde,
REAL8 phiRef,
REAL8 deltaF,
REAL8 fLow,
REAL8 fHigh,
REAL8 fRef,
REAL8 distance,
REAL8 inclination,
REAL8 Mtot_sec,
REAL8 q)
{
INT4 ret = XLAL_SUCCESS;
INT4 i;
INT4 j;
double tpeak22estimate = 0.;
/* Check output arrays */
if(!hptilde || !hctilde) XLAL_ERROR(XLAL_EFAULT);
if(*hptilde || *hctilde)
{
XLALPrintError("(*hptilde) and (*hctilde) are supposed to be NULL, but got %p and %p\n",(*hptilde),(*hctilde));
XLAL_ERROR(XLAL_EFAULT);
}
/* Check if the data has been set up */
if(__lalsim_EOBNRv2HMROM_setup) {
XLALPrintError("Error: the ROM data has not been set up\n");
XLAL_ERROR(XLAL_EFAULT);
}
/* Set the global pointers to data */
ListmodesEOBNRHMROMdata* listdata = *__lalsim_EOBNRv2HMROM_data;
ListmodesEOBNRHMROMdata_interp* listdata_interp = *__lalsim_EOBNRv2HMROM_interp;
/* Global amplitude prefactor - includes total mass scaling, Fourier scaling, distance scaling, and undoing an additional arbitrary scaling */
REAL8 Mtot_msol = Mtot_sec / LAL_MTSUN_SI; /* Mtot_msol and M_ROM in units of solar mass */
REAL8 amp0 = (Mtot_msol/M_ROM) * Mtot_sec * 1.E-16 * 1.E6 * LAL_PC_SI / distance;
/* Highest allowed geometric frequency for the first mode of listmode in the ROM - used for fRef
* by convention, we use the first mode of listmode (presumably the 22) for phiref */
ListmodesEOBNRHMROMdata* listdata_ref = ListmodesEOBNRHMROMdata_GetMode(listdata, listmode[0][0], listmode[0][1]);
EOBNRHMROMdata* data_ref = listdata_ref->data;
REAL8 Mf_ROM_max_ref = gsl_vector_get(data_ref->freq, nbfreq-1);
/* Convert to geometric units for frequency */
REAL8 fLow_geom = fLow * Mtot_sec;
REAL8 fHigh_geom = fHigh * Mtot_sec;
REAL8 fRef_geom = fRef * Mtot_sec;
REAL8 deltaF_geom = deltaF * Mtot_sec;
/* Enforce allowed geometric frequency range */
if (fLow_geom < Mf_ROM_min) { /* Enforce minimal frequency */
XLALPrintWarning("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);
fLow_geom = Mf_ROM_min;
}
/* Default highest frequency */
if (fHigh == 0)
fHigh_geom = Mf_ROM_max;
/* In case the user asks for a frequency higher than covered by the ROM, we keep it that way as we will just 0-pad the waveform (and do it anyway for some modes) */
if (fRef_geom > Mf_ROM_max_ref || fRef_geom == 0)
fRef_geom = Mf_ROM_max_ref; /* If fRef > fhigh or 0 we reset fRef to default value of cutoff frequency for the first mode of the list (presumably the 22 mode) */
if (0 < fRef_geom && fRef_geom < Mf_ROM_min) {
XLALPrintWarning("Reference frequency Mf_ref=%g is smaller than lowest frequency in ROM Mf=%g. Setting it to the lowest frequency in ROM.\n", fLow_geom, Mf_ROM_min);
fRef_geom = Mf_ROM_min;
}
/* Set up output array with size closest power of 2 - fHigh is the upper frequency specified by the user */
size_t nbpt = NextPow2(fHigh_geom / deltaF_geom) + 1;
/* Internal storage for the projection coefficients and shifts in time and phase */
/* Initialized only once, and reused for the different modes */
EOBNRHMROMdata_coeff *data_coeff = NULL;
EOBNRHMROMdata_coeff_Init(&data_coeff);
/* Create spherical harmonic frequency series that will contain the hlm's */
SphHarmFrequencySeries** hlmsphharmfreqseries = XLALMalloc(sizeof(SphHarmFrequencySeries));
*hlmsphharmfreqseries = NULL;
/* GPS time definition - common to all modes */
LIGOTimeGPS tC;
XLALGPSAdd(&tC, -1. / deltaF); /* coalesce at t=0 */
/* The phase change imposed by phiref, from the phase of the first mode in the list - to be set in the first step of the loop on the modes */
REAL8 phase_change_ref = 0;
/* Main loop over the modes */
for( i=0; i<nbmode; i++ ){
UINT4 l = listmode[i][0];
INT4 m = listmode[i][1];
/* Getting the relevant modes in the lists of data */
ListmodesEOBNRHMROMdata* listdata_mode = ListmodesEOBNRHMROMdata_GetMode(listdata, l, m);
ListmodesEOBNRHMROMdata_interp* listdata_interp_mode = ListmodesEOBNRHMROMdata_interp_GetMode(listdata_interp, l, m);
/* Evaluating the projection coefficients and shift in time and phase */
ret |= Evaluate_Spline_Data(q, listdata_interp_mode->data_interp, data_coeff);
/* Evaluating the unnormalized amplitude and unshifted phase vectors for the mode */
/* Notice a change in convention: B matrices are transposed with respect to the B matrices in SEOBNRROM */
/* amp_pts = Bamp . Camp_coeff */
/* phi_pts = Bphi . Cphi_coeff */
gsl_vector* amp_f = gsl_vector_alloc(nbfreq);
gsl_vector* phi_f = gsl_vector_alloc(nbfreq);
gsl_blas_dgemv(CblasNoTrans, 1.0, listdata_mode->data->Bamp, data_coeff->Camp_coeff, 0.0, amp_f);
gsl_blas_dgemv(CblasNoTrans, 1.0, listdata_mode->data->Bphi, data_coeff->Cphi_coeff, 0.0, phi_f);
/* The downsampled frequencies for the mode - we undo the rescaling of the frequency for the 44 and 55 modes */
gsl_vector* freq_ds = gsl_vector_alloc(nbfreq);
gsl_vector_memcpy(freq_ds, listdata_mode->data->freq);
if ( l==4 && m==4) gsl_vector_scale( freq_ds, 1./Scaling44(q));
if ( l==5 && m==5) gsl_vector_scale( freq_ds, 1./Scaling55(q));
/* Evaluating the shifts in time and phase - conditional scaling for the 44 and 55 modes */
/* Note: the stored values of 'shifttime' correspond actually to 2pi*Deltat */
SplineList* shifttime_splinelist = listdata_interp_mode->data_interp->shifttime_interp;
SplineList* shiftphase_splinelist = listdata_interp_mode->data_interp->shiftphase_interp;
REAL8 twopishifttime;
if( l==4 && m==4) {
twopishifttime = gsl_spline_eval(shifttime_splinelist->spline, q, shifttime_splinelist->accel) * Scaling44(q);
}
else if( l==5 && m==5) {
twopishifttime = gsl_spline_eval(shifttime_splinelist->spline, q, shifttime_splinelist->accel) * Scaling55(q);
}
else {
twopishifttime = gsl_spline_eval(shifttime_splinelist->spline, q, shifttime_splinelist->accel);
}
REAL8 shiftphase = gsl_spline_eval(shiftphase_splinelist->spline, q, shiftphase_splinelist->accel);
/* If first mode in the list, assumed to be the 22 mode, set totalshifttime and phase_change_ref */
if( i==0 ) {
if(l==2 && m==2) {
/* Setup 1d cubic spline for the phase of the 22 mode */
gsl_interp_accel* accel_phi22 = gsl_interp_accel_alloc();
gsl_spline* spline_phi22 = gsl_spline_alloc(gsl_interp_cspline, nbfreq);
gsl_spline_init(spline_phi22, gsl_vector_const_ptr(freq_ds,0), gsl_vector_const_ptr(phi_f,0), nbfreq);
/* Compute the shift in time needed to set the peak of the 22 mode roughly at t=0 */
/* We use the SPA formula tf = -(1/2pi)*dPsi/df to estimate the correspondence between frequency and time */
/* The frequency corresponding to the 22 peak is omega22peak/2pi, with omega22peak taken from the fit to NR in Pan&al 1106 EOBNRv2HM paper */
double f22peak = fmin(omega22peakOfq(q)/(2*LAL_PI), Mf_ROM_max_ref); /* We ensure we evaluate the spline within its range */
tpeak22estimate = -1./(2*LAL_PI) * gsl_spline_eval_deriv(spline_phi22, f22peak, accel_phi22);
/* Determine the change in phase (to be propagated to all modes) required to have phi22(fRef) = 2*phiRef */
phase_change_ref = 2*phiRef + (gsl_spline_eval(spline_phi22, fRef_geom, accel_phi22) - (twopishifttime - 2*LAL_PI*tpeak22estimate) * fRef_geom - shiftphase);
gsl_spline_free(spline_phi22);
gsl_interp_accel_free(accel_phi22);
}
else {
XLALPrintError("Error: the first mode in listmode must be the 22 mode to set the changes in phase and time \n");
XLAL_ERROR(XLAL_EFAILED);
}
}
/* Total shift in time, and total change in phase for this mode */
double totaltwopishifttime = twopishifttime - 2*LAL_PI*tpeak22estimate;
double constphaseshift = (double) m/listmode[0][1] * phase_change_ref + shiftphase;
/* Initialize the complex series for the mode - notice that metadata used here is useless, only the one for the final output will matter */
COMPLEX16FrequencySeries* mode = XLALCreateCOMPLEX16FrequencySeries("mode hlm", &tC, 0.0, deltaF, &lalStrainUnit, nbpt);
memset(mode->data->data, 0, nbpt * sizeof(COMPLEX16));
/* Setup 1d cubic spline for the phase and amplitude of the mode */
gsl_interp_accel* accel_phi = gsl_interp_accel_alloc();
gsl_interp_accel* accel_amp = gsl_interp_accel_alloc();
gsl_spline* spline_phi = gsl_spline_alloc(gsl_interp_cspline, nbfreq);
gsl_spline* spline_amp = gsl_spline_alloc(gsl_interp_cspline, nbfreq);
gsl_spline_init(spline_phi, gsl_vector_const_ptr(freq_ds,0), gsl_vector_const_ptr(phi_f,0), nbfreq);
gsl_spline_init(spline_amp, gsl_vector_const_ptr(freq_ds,0), gsl_vector_const_ptr(amp_f,0), nbfreq);
/* Interval in frequency covered by the ROM */
REAL8 fLow_geom_mode = gsl_vector_get(freq_ds, 0);
REAL8 fHigh_geom_mode = fmin(gsl_vector_get(freq_ds, nbfreq-1), fHigh_geom);
/* Initialize the loop - values outside this range in j are 0 by default */
INT4 jStart = (UINT4) ceil(fLow_geom_mode / deltaF_geom);
INT4 jStop = (UINT4) ceil(fHigh_geom_mode / deltaF_geom);
COMPLEX16 *modedata = mode->data->data;
/* Mode-dependent complete amplitude prefactor */
REAL8 amp_pre = amp0 * ModeAmpFactor( l, m, q);
/* Loop on the frequency samples chosen to evaluate the waveform */
/* We set apart the first and last step to avoid falling outside of the range of the splines by numerical errors */
REAL8 f, A, phase;
f = fmax(fLow_geom_mode, jStart*deltaF_geom);
A = gsl_spline_eval(spline_amp, f, accel_amp);
phase = -gsl_spline_eval(spline_phi, f, accel_phi) + totaltwopishifttime * f + constphaseshift; /* Minus sign put here, in the internals of the ROM model \Psi = -phase */
modedata[jStart] = amp_pre * A * cexp(I*phase);
for (j=jStart+1; j<jStop-1; j++) {
f = j*deltaF_geom;
A = gsl_spline_eval(spline_amp, f, accel_amp);
phase = -gsl_spline_eval(spline_phi, f, accel_phi) + totaltwopishifttime * f + constphaseshift; /* Minus sign put here, in the internals of the ROM model \Psi = -phase */
modedata[j] = amp_pre * A * cexp(I*phase);
}
f = fmin(fHigh_geom_mode, (jStop-1)*deltaF_geom);
A = gsl_spline_eval(spline_amp, f, accel_amp);
phase = -gsl_spline_eval(spline_phi, f, accel_phi) + totaltwopishifttime * f + constphaseshift; /* Minus sign put here, in the internals of the ROM model \Psi = -phase */
modedata[jStop-1] = amp_pre * A * cexp(I*phase);
/* Add the computed mode to the SphHarmFrequencySeries structure */
*hlmsphharmfreqseries = XLALSphHarmFrequencySeriesAddMode(*hlmsphharmfreqseries, mode, l, m);
/* Cleanup for the mode */
gsl_spline_free(spline_amp);
gsl_spline_free(spline_phi);
gsl_interp_accel_free(accel_amp);
gsl_interp_accel_free(accel_phi);
gsl_vector_free(amp_f);
gsl_vector_free(phi_f);
gsl_vector_free(freq_ds);
XLALDestroyCOMPLEX16FrequencySeries(mode);
}
/* Cleanup of the coefficients data structure */
EOBNRHMROMdata_coeff_Cleanup(data_coeff);
/* Combining the modes for a hplus, hcross output */
/* Initialize the complex series hplus, hcross */
*hptilde = XLALCreateCOMPLEX16FrequencySeries("hptilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, nbpt);
*hctilde = XLALCreateCOMPLEX16FrequencySeries("hctilde: FD waveform", &tC, 0.0, deltaF, &lalStrainUnit, nbpt);
if (!(hptilde) || !(*hctilde)) XLAL_ERROR(XLAL_EFUNC);
memset((*hptilde)->data->data, 0, nbpt * sizeof(COMPLEX16));
memset((*hctilde)->data->data, 0, nbpt * sizeof(COMPLEX16));
XLALUnitDivide(&(*hptilde)->sampleUnits, &(*hptilde)->sampleUnits, &lalSecondUnit);
XLALUnitDivide(&(*hctilde)->sampleUnits, &(*hctilde)->sampleUnits, &lalSecondUnit);
/* Adding the modes to form hplus, hcross
* - use of a function that copies XLALSimAddMode but for Fourier domain structures */
INT4 sym; /* sym will decide whether to add the -m mode (when equatorial symmetry is present) */
for( i=0; i<nbmode; i++){
INT4 l = listmode[i][0];
INT4 m = listmode[i][1];
COMPLEX16FrequencySeries* mode = XLALSphHarmFrequencySeriesGetMode(*hlmsphharmfreqseries, l, m);
if ( m==0 ) sym = 0; /* We test for hypothetical m=0 modes */
else sym = 1;
FDAddMode( *hptilde, *hctilde, mode, inclination, 0., l, m, sym); /* The phase \Phi is set to 0 - assumes phiRef is defined as half the phase of the 22 mode h22 (or the first mode in the list), not for h = hplus-I hcross */
}
/* Destroying the list of frequency series for the modes, including the COMPLEX16FrequencySeries that it contains */
XLALDestroySphHarmFrequencySeries(*hlmsphharmfreqseries);
XLALFree(hlmsphharmfreqseries);
/* Additional complex conjugation of hptilde, hctilde - due to the difference in convention for the Fourier transform between LAL and the ROM internals */
COMPLEX16* datap = (*hptilde)->data->data;
COMPLEX16* datac = (*hctilde)->data->data;
for ( j = 0; j < (INT4) (*hptilde)->data->length; ++j ) {
datap[j] = conj(datap[j]);
}
for ( j = 0; j < (INT4) (*hctilde)->data->length; ++j ) {
datac[j] = conj(datac[j]);
}
return(XLAL_SUCCESS);
}
/**
* Given the trajectory in an inertial frame, this computes Euler angles
* of the roation from the inertial frame to the minimal-rotation frame
* that co-precesses with LN(t) = rvec(t) x rdotvec(t)
*/
static int EulerAnglesI2P(REAL8Vector *Alpha, /**<< output: alpha Euler angle */
REAL8Vector *Beta, /**<< output: beta Euler angle */
REAL8Vector *Gamma, /**<< output: gamma Euler angle */
INT4 *phaseCounterA, /**<< output: counter for unwrapping of alpha */
INT4 *phaseCounterB, /**<< output: counter for unwrapping of beta */
const REAL8Vector tVec, /**<< time series */
const REAL8Vector posVecx, /**<< x time series */
const REAL8Vector posVecy, /**<< y time series */
const REAL8Vector posVecz, /**<< z time series */
const UINT4 retLenLow, /**<< Array length of the trajectory */
const REAL8 InitialAlpha, /**<< Initial alpha (used only if flag_highSR=1) */
const REAL8 InitialGamma, /**<< Initial gamma */
UINT4 flag_highSR /**<< Flag to indicate whether one is analyzing the high SR trajectory */) {
UINT4 i = 0;
REAL8Vector *LN_x = NULL, *LN_y = NULL, *LN_z = NULL;
REAL8 tmpR[3], tmpRdot[3], magLN;
REAL8 precEulerresult = 0, precEulererror = 0;
gsl_integration_workspace * precEulerw = gsl_integration_workspace_alloc (1000);
gsl_function precEulerF;
PrecEulerAnglesIntegration precEulerparams;
REAL8 inGamma = InitialGamma;
LN_x = XLALCreateREAL8Vector( retLenLow );
LN_y = XLALCreateREAL8Vector( retLenLow );
LN_z = XLALCreateREAL8Vector( retLenLow );
gsl_spline *x_spline = gsl_spline_alloc( gsl_interp_cspline, retLenLow );
gsl_spline *y_spline = gsl_spline_alloc( gsl_interp_cspline, retLenLow );
gsl_spline *z_spline = gsl_spline_alloc( gsl_interp_cspline, retLenLow );
gsl_interp_accel *x_acc = gsl_interp_accel_alloc();
gsl_interp_accel *y_acc = gsl_interp_accel_alloc();
gsl_interp_accel *z_acc = gsl_interp_accel_alloc();
gsl_spline_init( x_spline, tVec.data, posVecx.data, retLenLow );
gsl_spline_init( y_spline, tVec.data, posVecy.data, retLenLow );
gsl_spline_init( z_spline, tVec.data, posVecz.data, retLenLow );
for( i=0; i < retLenLow; i++ )
{
tmpR[0] = posVecx.data[i]; tmpR[1] = posVecy.data[i]; tmpR[2] = posVecz.data[i];
tmpRdot[0] = gsl_spline_eval_deriv( x_spline, tVec.data[i], x_acc );
tmpRdot[1] = gsl_spline_eval_deriv( y_spline, tVec.data[i], y_acc );
tmpRdot[2] = gsl_spline_eval_deriv( z_spline, tVec.data[i], z_acc );
LN_x->data[i] = tmpR[1] * tmpRdot[2] - tmpR[2] * tmpRdot[1];
LN_y->data[i] = tmpR[2] * tmpRdot[0] - tmpR[0] * tmpRdot[2];
LN_z->data[i] = tmpR[0] * tmpRdot[1] - tmpR[1] * tmpRdot[0];
magLN = sqrt(LN_x->data[i] * LN_x->data[i] + LN_y->data[i] * LN_y->data[i]
+ LN_z->data[i] * LN_z->data[i]);
LN_x->data[i] /= magLN; LN_y->data[i] /= magLN; LN_z->data[i] /= magLN;
/* Eq. 19 of PRD 89, 084006 (2014) */
/* Also unwrap the two angles */
if (fabs(LN_x->data[i]) <= 1.e-10 && fabs(LN_y->data[i]) <=1.e-10){
Alpha->data[i] = 0.0;
inGamma = 0.0;
} else {
Alpha->data[i] = atan2( LN_y->data[i], LN_x->data[i] )
+ *phaseCounterA * LAL_TWOPI;
if (i==0 && flag_highSR != 1){
inGamma = -Alpha->data[i];
}
}
if( i>0 && Alpha->data[i] - Alpha->data[i-1] > 5. ) {
*phaseCounterA = *phaseCounterA - 1;
Alpha->data[i] -= LAL_TWOPI;
}
else if ( i && Alpha->data[i] - Alpha->data[i-1] < -5. ) {
*phaseCounterA = *phaseCounterA + 1;
Alpha->data[i] += LAL_TWOPI;
}
if (LN_z->data[i] >1.) {
LN_z->data[i] = 1.;
}
if (LN_z->data[i] <-1.) {
LN_z->data[i] = -1.;
}
if ( flag_highSR == 1) {
Alpha->data[i] -= (Alpha->data[0] - InitialAlpha);
}
if (fabs(1.0 - LN_z->data[i]) < 1.e-12){
REAL8 LN_xy;
LN_xy = sqrt(LN_x->data[i]*LN_x->data[i] +
LN_y->data[i]*LN_y->data[i]);
//LN_z->data[i] = sqrt(1.0 - LN_xy*LN_xy);
Beta->data[i] = atan2(LN_xy, LN_z->data[i]);
//printf("here ");
}else{
Beta->data[i] = acos( LN_z->data[i] );
}
if( i>0 && Beta->data[i] > Beta->data[i-1] ) {
*phaseCounterB = *phaseCounterB - 1;
}
}
/* Integrate \dot{\alpha} \cos{\beta} to get the final Euler angle
Eq. 20 of PRD 89, 084006 (2014) */
gsl_spline_init( x_spline, tVec.data, Alpha->data, retLenLow );
gsl_spline_init( y_spline, tVec.data, Beta->data, retLenLow );
precEulerparams.alpha_spline = x_spline;
precEulerparams.alpha_acc = x_acc;
precEulerparams.beta_spline = y_spline;
precEulerparams.beta_acc = y_acc;
precEulerF.function = &f_alphadotcosi;
precEulerF.params = &precEulerparams;
for( i = 0; i < retLenLow; i++ )
{
//if( i==0 ) { Gamma->data[i] = InitialGamma; }
if( i==0 ) { Gamma->data[i] = inGamma; }
else
{
gsl_integration_qags (&precEulerF, tVec.data[i-1], tVec.data[i], 1e-9, 1e-9, 1000, precEulerw, &precEulerresult, &precEulererror);
Gamma->data[i] = Gamma->data[i-1] + precEulerresult;
}
}
gsl_integration_workspace_free( precEulerw );
gsl_spline_free( x_spline );
gsl_spline_free( y_spline );
gsl_spline_free( z_spline );
gsl_interp_accel_free( x_acc );
gsl_interp_accel_free( y_acc );
gsl_interp_accel_free( z_acc );
XLALDestroyREAL8Vector( LN_x );
XLALDestroyREAL8Vector( LN_y );
XLALDestroyREAL8Vector( LN_z );
return XLAL_SUCCESS;
}
double XLALSimLocateOmegaTime(
REAL8Array *dynamicsHi,
unsigned int numdynvars,
unsigned int retLenHi,
SpinEOBParams seobParams,
SpinEOBHCoeffs seobCoeffs,
REAL8 m1,
REAL8 m2,
REAL8Vector *radiusVec,
int *found,
REAL8* tMaxOmega,
INT4 use_optimized
)
{
*tMaxOmega = 0; //Zach E: Fixes Heisenbug with ICC 16 and 17 compilers (5181); removing this line will result in segfaults with both compilers.
/*
* Locate merger point (max omega),
* WaveStep 1.1: locate merger point */
int debugPK = 0;
int debugRD = 0;
FILE *out = NULL;
gsl_spline *spline = NULL;
gsl_interp_accel *acc = NULL;
if (debugPK) {debugRD = 0;}
unsigned int peakIdx, i, j;
REAL8Vector *values = NULL;
REAL8Vector *dvalues = NULL;
REAL8Vector *omegaHi = NULL;
if ( !(values = XLALCreateREAL8Vector( numdynvars )) )
{
XLAL_ERROR( XLAL_ENOMEM );
}
if ( !(dvalues = XLALCreateREAL8Vector( numdynvars )) )
{
XLAL_ERROR( XLAL_ENOMEM );
}
if ( !(omegaHi = XLALCreateREAL8Vector( retLenHi )) )
{
XLAL_ERROR( XLAL_ENOMEM );
}
REAL8 rdotvec[3] = {0,0,0};
REAL8 rvec[3] = {0,0,0};
REAL8 rcrossrdot[3] = {0,0,0};
REAL8Vector timeHi;
timeHi.length = retLenHi;
timeHi.data = dynamicsHi->data;
double dt = timeHi.data[1] - timeHi.data[0];
double ddradiusVec[timeHi.length - 2];
unsigned int k;
for (k = 1; k < timeHi.length-1; k++) {
ddradiusVec[k] = (radiusVec->data[k+1] - 2.*radiusVec->data[k] + radiusVec->data[k-1])/dt/dt;
// XLAL_PRINT_INFO("%3.10f %3.10f\n", timeHi->data[k], ddradiusVec[k]);
}
// for (k = timeHi->length-3; k>=1; k--) {
// XLAL_PRINT_INFO("%3.10f %3.10f\n", timeHi->data[k], ddradiusVec[k]);
// if (ddradiusVec[k] < 0) {
// break;
// }
// }
for (k = 0; k < timeHi.length-2; k++) {
// XLAL_PRINT_INFO("%3.10f %3.10f\n", timeHi->data[k], ddradiusVec[k]);
if (dt*k > dt*( timeHi.length-2)-20 && ddradiusVec[k] > 0) {
break;
}
}
double minoff = dt*( timeHi.length-2 - k) > 0.2 ? dt*( timeHi.length-2 - k) : 0.2;
if (debugPK) {
XLAL_PRINT_INFO("Change of sign in ddr %3.10f M before the end\n", minoff );
}
// First we search for the maximum (extremum) of amplitude
double maxoff = 20.0;
unsigned int Nps = timeHi.length;
// this definesthe search interval for maximum (we might use min0ff= 0.051 instead)
double tMin = timeHi.data[Nps-1] - maxoff;
// FIXME
// minoff = 0.0;
double tMax = timeHi.data[Nps-1] - minoff;
*tMaxOmega = tMax;
tMin = tMax - 20.;
if ( debugPK ) {
XLAL_PRINT_INFO("tMin, tMax = %3.10f %3.10f\n", tMin, tMax);
}
double omega = 0.0;
double magR;
double time1, time2, omegaDeriv, omegaDerivMid, tPeakOmega;
if(debugPK) {
out = fopen( "omegaHi.dat", "w" );
XLAL_PRINT_INFO("length of values = %d, retLenHi = %d\n", values->length, retLenHi);
fflush(NULL);
}
if(debugRD) {
out = fopen( "omegaHi.dat", "w" );
}
for ( i = 0; i < retLenHi; i++ )
{
for ( j = 0; j < values->length; j++ )
{ values->data[j] = *(dynamicsHi->data+(j+1)*retLenHi+i); }
/* Calculate dr/dt */
memset( dvalues->data, 0, numdynvars*sizeof(dvalues->data[0]));
if(use_optimized){
if( XLALSpinPrecHcapRvecDerivative_exact( 0, values->data, dvalues->data,
&seobParams) != XLAL_SUCCESS )
{
XLAL_PRINT_INFO(
" Calculation of dr/dt failed while computing omegaHi time series\n");
XLAL_ERROR( XLAL_EFUNC );
}
} else {
if( XLALSpinPrecHcapRvecDerivative( 0, values->data, dvalues->data,
&seobParams) != XLAL_SUCCESS )
{
XLAL_PRINT_INFO(
" Calculation of dr/dt failed while computing omegaHi time series\n");
XLAL_ERROR( XLAL_EFUNC );
}
}
/* Calculare r x dr/dt */
for (j=0; j<3; j++){
rvec[j] = values->data[j];
rdotvec[j] = dvalues->data[j];
}
//memcpy(rdotvec, dvalues->data, 3*sizeof(REAL8));
//rvec[0] = posVecxHi.data[i]; rvec[1] = posVecyHi.data[i];
//rvec[2] = posVeczHi.data[i];
cross_product( rvec, rdotvec, rcrossrdot );
/* Calculate omega = |r x dr/dt| / r*r */
magR = sqrt(inner_product(rvec, rvec));
omegaHi->data[i] = sqrt(inner_product(rcrossrdot, rcrossrdot)) / (magR*magR);
if(debugPK || debugRD){
fprintf( out, "%.16e\t%.16e\n", timeHi.data[i], omegaHi->data[i]);
}
}
// Searching for crude omega_max (extremum)
peakIdx = 0;
*found = 0;
for ( i = 1, peakIdx = 0; i < retLenHi-1; i++ ){
omega = omegaHi->data[i];
if (omega >= omegaHi->data[i-1] && omega > omegaHi->data[i+1] && tMax>=timeHi.data[i] && timeHi.data[i]>=tMin){
peakIdx = i;
*found = 1;
if (debugPK){
XLAL_PRINT_INFO("PK: Crude peak of Omega is at idx = %d. t = %f, OmegaPeak = %.16e\n",
peakIdx, timeHi.data[peakIdx], omega);
fflush(NULL);
}
}
}
if(debugPK) {
fclose(out);
if (peakIdx ==0){
XLAL_PRINT_INFO("Stas: peak of orbital frequency was not found. peakIdx = %d, retLenHi = %d, i at exit = %d\n", peakIdx, retLenHi, i);
fflush(NULL);
}
}
if(debugRD) {
fclose(out);
}
// refining the omega_max search (if it is found)
tPeakOmega = 0.0;
if(peakIdx != 0){
spline = gsl_spline_alloc( gsl_interp_cspline, retLenHi );
acc = gsl_interp_accel_alloc();
time1 = timeHi.data[peakIdx-2];
gsl_spline_init( spline, timeHi.data, omegaHi->data, retLenHi );
omegaDeriv = gsl_spline_eval_deriv( spline, time1, acc );
if ( omegaDeriv > 0. ) { time2 = timeHi.data[peakIdx+2]; }
else{
time2 = time1;
peakIdx = peakIdx-2;
time1 = timeHi.data[peakIdx-2];
omegaDeriv = gsl_spline_eval_deriv( spline, time1, acc );
}
do
{
tPeakOmega = ( time1 + time2 ) / 2.;
omegaDerivMid = gsl_spline_eval_deriv( spline, tPeakOmega, acc );
if ( omegaDerivMid * omegaDeriv < 0.0 ) { time2 = tPeakOmega; }
else
{
omegaDeriv = omegaDerivMid;
time1 = tPeakOmega;
}
if (debugPK){
XLAL_PRINT_INFO("Stas: searching for orbital max: %f, %f, %f, %f \n", time1, time2, omegaDeriv, omegaDerivMid);
}
} while ( time2 - time1 > 1.0e-5 );
if(debugPK) {
XLAL_PRINT_INFO( "Estimation of the orbital peak is now at time %.16e \n", tPeakOmega);
fflush(NULL);
}
}
if(*found == 0 || debugRD || debugPK){
if(debugPK){
XLAL_PRINT_INFO("Stas: We couldn't find the maximum of orbital frequency, search for maximum of A(r)/r^2 \n");
}
REAL8 rad, rad2, m1PlusetaKK, bulk, logTerms, deltaU, u, u2, u3, u4, u5;
REAL8 listAOverr2[retLenHi];
REAL8 Aoverr2;
REAL8Vector *sigmaStar = NULL;
REAL8Vector *sigmaKerr = NULL;
if ( !(sigmaStar = XLALCreateREAL8Vector( 3 )) )
{
XLALDestroyREAL8Vector( sigmaStar );
XLAL_ERROR( XLAL_ENOMEM );
}
if ( !(sigmaKerr = XLALCreateREAL8Vector( 3 )) )
{
XLALDestroyREAL8Vector( sigmaStar );
XLAL_ERROR( XLAL_ENOMEM );
}
REAL8Vector s1Vec, s2Vec;
s1Vec.length = s2Vec.length = 3;
REAL8 s1Data[3], s2Data[3];
REAL8 mTotal = m1 + m2;
REAL8 a;
REAL8 eta = m1*m2/(mTotal*mTotal);
if(debugPK || debugRD){
out = fopen( "OutAofR.dat", "w" );
}
for ( i = 0; i < retLenHi; i++ )
{
for ( j = 0; j < values->length; j++ )
{
values->data[j] = *(dynamicsHi->data+(j+1)*retLenHi+i);
}
for( j = 0; j < 3; j++ )
{
//s1DataNorm[k] = values->data[k+6];
//s2DataNorm[k] = values->data[k+9];
s1Data[j] = values->data[j+6] * mTotal * mTotal;
s2Data[j] = values->data[j+9] * mTotal * mTotal;
}
s1Vec.data = s1Data;
s2Vec.data = s2Data;
XLALSimIMRSpinEOBCalculateSigmaStar( sigmaStar, m1, m2, &s1Vec, &s2Vec );
XLALSimIMRSpinEOBCalculateSigmaKerr( sigmaKerr, m1, m2, &s1Vec, &s2Vec );
seobParams.a = a = sqrt(inner_product(sigmaKerr->data, sigmaKerr->data));
m1PlusetaKK = -1. + eta * seobCoeffs.KK;
rad2 = values->data[0]*values->data[0] + values->data[1]*values->data[1] + values->data[2]*values->data[2];
rad = sqrt(rad2);
u = 1./rad;
u2 = u*u;
u3 = u2*u;
u4 = u2*u2;
u5 = u4*u;
bulk = 1./(m1PlusetaKK*m1PlusetaKK) + (2.*u)/m1PlusetaKK + a*a*u2;
logTerms = 1. + eta*seobCoeffs.k0 + eta*log(1. + seobCoeffs.k1*u + seobCoeffs.k2*u2 + seobCoeffs.k3*u3 + seobCoeffs.k4*u4 + seobCoeffs.k5*u5 + seobCoeffs.k5l*u5*log(u));
deltaU = bulk*logTerms;
listAOverr2[i] = deltaU / rad2;
if(debugPK || debugRD){
fprintf(out, "%3.10f %3.10f\n", timeHi.data[i], listAOverr2[i]);
}
}
if(debugPK || debugRD ) fclose(out);
if (*found == 0){
// searching formaximum of A(r)/r^2
peakIdx = 0;
//*found = 0;
for ( i = 1, peakIdx = 0; i < retLenHi-1; i++ ){
Aoverr2 = listAOverr2[i];
if (Aoverr2 >= listAOverr2[i-1] && Aoverr2 > listAOverr2[i+1]){
if (timeHi.data[i] > tMin){
peakIdx = i;
tPeakOmega = timeHi.data[i];
*found = 1;
if (debugPK){
XLAL_PRINT_INFO("PK: Peak of A(r)/r^2 is at idx = %d. t = %f, Peak ampl. = %.16e\n",
peakIdx, timeHi.data[peakIdx], Aoverr2);
fflush(NULL);
}
break;
}
}
}
}
if(debugPK) {
if (peakIdx ==0){
XLAL_PRINT_INFO("Stas: peak of A(r)/r^2 was not found. \
peakIdx = %d, retLenHi = %d, i at exit = %d\n", peakIdx, retLenHi, i);
fflush(NULL);
}
}
XLALDestroyREAL8Vector(sigmaStar);
XLALDestroyREAL8Vector(sigmaKerr);
}
double Interpolate::deriv(double x) {
return gsl_spline_eval_deriv (_spline, x, _acc);
}
