/** Setup SEOBNRv1ROMEffectiveSpin model using data files installed in $LAL_DATA_PATH
*/
static void SEOBNRv1ROMEffectiveSpin_Init_LALDATA(void)
{
if (SEOBNRv1ROMEffectiveSpin_IsSetup()) return;
// If we find one ROM datafile in a directory listed in LAL_DATA_PATH,
// then we expect the remaining datafiles to also be there.
char datafile[] = "SEOBNRv1ROM_SS_Phase_ciall.dat";
char *path = XLALFileResolvePathLong(datafile, PKG_DATA_DIR);
if (path==NULL)
XLAL_ERROR_VOID(XLAL_EIO, "Unable to resolve data file %s in $LAL_DATA_PATH\n", datafile);
char *dir = dirname(path);
int ret = SEOBNRv1ROMEffectiveSpin_Init(dir);
XLALFree(path);
if(ret!=XLAL_SUCCESS)
XLAL_ERROR_VOID(XLAL_FAILURE, "Unable to find SEOBNRv1ROMEffectiveSpin data files in $LAL_DATA_PATH\n");
}
/**
* Free a candidateVector
* \param [in] vector Pointer of candidateVector to be freed
*/
void free_candidateVector(candidateVector *vector)
{
if (vector==NULL) return;
if ((!vector->length || !vector->data) && (vector->length || vector->data)) XLAL_ERROR_VOID(XLAL_EINVAL);
if (vector->data) XLALFree((candidate*)vector->data);
vector->data = NULL;
XLALFree((candidateVector*)vector);
return;
} /* free_candidateVector() */
/**
* Free an UpperLimitVector
* \param [in] vector Pointer to an UpperLimitVector
*/
void free_UpperLimitVector(UpperLimitVector *vector)
{
if (vector==NULL) return;
if ((!vector->length || !vector->data) && (vector->length || vector->data)) XLAL_ERROR_VOID(XLAL_EINVAL);
if (vector->data) {
for (UINT4 ii=0; ii<vector->length; ii++) free_UpperLimitStruct(&(vector->data[ii]));
XLALFree((UpperLimit*)vector->data);
}
vector->data = NULL;
XLALFree((UpperLimitVector*)vector);
return;
} /* free_UpperLimitVector() */
/*
-------------------------------------------------------------------------
* This function frees the memory allocated using XLALInitFContactWorkSpace.
* ------------------------------------------------------------------------*/
void XLALFreeFContactWorkSpace( fContactWorkSpace *workSpace )
{
if ( !workSpace )
XLAL_ERROR_VOID( XLAL_EFAULT );
/* Free all the allocated memory */
if (workSpace->tmpA) XLAL_CALLGSL( gsl_matrix_free( workSpace->tmpA ));
if (workSpace->tmpB) XLAL_CALLGSL( gsl_matrix_free( workSpace->tmpB ));
if (workSpace->C) XLAL_CALLGSL( gsl_matrix_free( workSpace->C ));
if (workSpace->p1) XLAL_CALLGSL( gsl_permutation_free( workSpace->p1 ));
if (workSpace->tmpV) XLAL_CALLGSL( gsl_vector_free( workSpace->tmpV ));
if (workSpace->r_AB) XLAL_CALLGSL( gsl_vector_free( workSpace->r_AB ));
if (workSpace->s) XLAL_CALLGSL( gsl_min_fminimizer_free( workSpace->s ));
LALFree( workSpace );
return;
}
void LALInferenceTemplateNullTimedomain(LALInferenceModel *model)
/*********************************************/
/* returns a time-domain 'null' template */
/* (all zeroes, implying no signal present). */
/*********************************************/
{
UINT4 i;
if ((model->timehPlus==NULL) || (model->timehCross==NULL)) {
XLALPrintError(" ERROR in templateNullTimedomain(): encountered unallocated 'timeModelhPlus/-Cross'.\n");
XLAL_ERROR_VOID(XLAL_EFAULT);
}
for (i=0; i<model->timehPlus->data->length; ++i){
model->timehPlus->data->data[i] = 0.0;
model->timehCross->data->data[i] = 0.0;
}
model->domain = LAL_SIM_DOMAIN_TIME;
return;
}
void LALInferenceTemplateXLALSimInspiralChooseWaveform(LALInferenceModel *model)
/*************************************************************************************************************************/
/* Wrapper for LALSimulation waveforms: */
/* XLALSimInspiralChooseFDWaveform() and XLALSimInspiralChooseTDWaveform(). */
/* */
/* model->params parameters are: */
/* - "name" description; type OPTIONAL (default value) */
/* */
/* MODEL PARAMETERS */
/* - "LAL_APPROXIMANT Approximant; Approximant */
/* - "LAL_PNORDER" Phase PN order; INT4 */
/* - "LAL_AMPORDER" Amplitude PN order; INT4 OPTIONAL (-1) */
/* - "spinO" Spin order; LALSimInspiralSpinOrder OPTIONAL (LAL_SIM_INSPIRAL_SPIN_ORDER_DEFAULT) */
/* - "tideO" Tidal order; LALSimInspiralTidalOrder OPTIONAL (LAL_SIM_INSPIRAL_TIDAL_ORDER_DEFAULT) */
/* - "f_ref" frequency at which the (frequency dependent) parameters are defined; REAL8 OPTIONAL (0.0) */
/* - "fLow" lower frequency bound; REAL8 OPTIONAL (model->fLow) */
/* */
/* MASS PARAMETERS; either: */
/* - "mass1" mass of object 1 in solar mass; REAL8 */
/* - "mass2" mass of object 1 in solar mass; REAL8 */
/* OR */
/* - "chirpmass" chirpmass in solar mass; REAL8 */
/* - "q" asymmetric mass ratio m2/m1, 0<q<1; REAL8 */
/* OR */
/* - "chirpmass" chirpmass in solar mass; REAL8 */
/* - "eta" symmetric mass ratio (m1*m2)/(m1+m2)^2; REAL8 */
/* */
/* ORIENTATION AND SPIN PARAMETERS */
/* - "phi0" reference phase as per LALSimulation convention; REAL8 */
/* - "distance" distance in Mpc */
/* - "costheta_jn"); cos of zenith angle between J and N in radians; REAL8 */
/* - "phi_jl"); azimuthal angle of L_N on its cone about J radians; REAL8 */
/* - "tilt_spin1"); zenith angle between S1 and LNhat in radians; REAL8 */
/* - "tilt_spin2"); zenith angle between S2 and LNhat in radians; REAL8 */
/* - "phi12"); difference in azimuthal angle between S1, S2 in radians; REAL8 */
/* - "a_spin1" magnitude of spin 1 in general configuration, -1<a_spin1<1; REAL8 OPTIONAL (0.0) */
/* - "a_spin2" magnitude of spin 2 in general configuration, -1<a_spin1<1; REAL8 OPTIONAL (0.0) */
/* */
/* OTHER PARAMETERS */
/* - "lambda1" tidal parameter of object 1; REAL8 OPTIONAL (0.0) */
/* - "lambda2" tidal parameter of object 1; REAL8 OPTIONAL (0.0) */
/* */
/* - "time" used as an OUTPUT only; REAL8 */
/* */
/* */
/* model needs to also contain: */
/* - model->fLow Unless - "fLow" OPTIONAL */
/* - model->deltaT */
/* - if model->domain == LAL_SIM_DOMAIN_FREQUENCY */
/* - model->deltaF */
/* - model->freqhCross */
/* - model->freqhPlus */
/* - else */
/* - model->timehPlus */
/* - model->timehCross */
/*************************************************************************************************************************/
{
Approximant approximant = (Approximant) 0;
INT4 order=-1;
INT4 amporder;
static int sizeWarning = 0;
int ret=0;
INT4 errnum=0;
REAL8TimeSeries *hplus=NULL; /**< +-polarization waveform [returned] */
REAL8TimeSeries *hcross=NULL; /**< x-polarization waveform [returned] */
COMPLEX16FrequencySeries *hptilde=NULL, *hctilde=NULL;
REAL8 mc;
REAL8 phi0, deltaT, m1, m2, f_low, f_start, distance, inclination;
REAL8 *m1_p,*m2_p;
REAL8 deltaF, f_max;
/* Sampling rate for time domain models */
deltaT = model->deltaT;
if (LALInferenceCheckVariable(model->params, "LAL_APPROXIMANT"))
approximant = *(Approximant*) LALInferenceGetVariable(model->params, "LAL_APPROXIMANT");
else {
XLALPrintError(" ERROR in templateLALGenerateInspiral(): (INT4) \"LAL_APPROXIMANT\" parameter not provided!\n");
XLAL_ERROR_VOID(XLAL_EDATA);
}
if (LALInferenceCheckVariable(model->params, "LAL_PNORDER"))
order = *(INT4*) LALInferenceGetVariable(model->params, "LAL_PNORDER");
else {
XLALPrintError(" ERROR in templateLALGenerateInspiral(): (INT4) \"LAL_PNORDER\" parameter not provided!\n");
XLAL_ERROR_VOID(XLAL_EDATA);
}
/* Explicitly set the default amplitude order if one is not specified.
* This serves two purposes:
* 1) The default behavior of the code won't change unexpectedly due to changes in LALSimulation.
* 2) We need to know the amplitude order in order to set the starting frequency of the waveform properly. */
if (LALInferenceCheckVariable(model->params, "LAL_AMPORDER"))
amporder = *(INT4*) LALInferenceGetVariable(model->params, "LAL_AMPORDER");
else
amporder = -1;
REAL8 f_ref = 100.0;
if (LALInferenceCheckVariable(model->params, "f_ref")) f_ref = *(REAL8 *)LALInferenceGetVariable(model->params, "f_ref");
REAL8 fTemp = f_ref;
if(LALInferenceCheckVariable(model->params,"chirpmass"))
{
mc = *(REAL8*) LALInferenceGetVariable(model->params, "chirpmass");
if (LALInferenceCheckVariable(model->params,"q")) {
REAL8 q = *(REAL8 *)LALInferenceGetVariable(model->params,"q");
q2masses(mc, q, &m1, &m2);
} else {
REAL8 eta = *(REAL8*) LALInferenceGetVariable(model->params, "eta");
mc2masses(mc, eta, &m1, &m2);
}
}
else if((m1_p=(REAL8 *)LALInferenceGetVariable(model->params, "mass1")) && (m2_p=(REAL8 *)LALInferenceGetVariable(model->params, "mass2")))
{
m1=*m1_p;
m2=*m2_p;
}
else
{
fprintf(stderr,"No mass parameters found!");
exit(0);
}
distance = LALInferenceGetREAL8Variable(model->params,"distance")* LAL_PC_SI * 1.0e6; /* distance (1 Mpc) in units of metres */
phi0 = LALInferenceGetREAL8Variable(model->params, "phase"); /* START phase as per lalsimulation convention, radians*/
/* Zenith angle between J and N in radians. Also known as inclination angle when spins are aligned */
REAL8 thetaJN = acos(LALInferenceGetREAL8Variable(model->params, "costheta_jn")); /* zenith angle between J and N in radians */
/* Check if fLow is a model parameter, otherwise use data structure definition */
if(LALInferenceCheckVariable(model->params, "flow"))
f_low = *(REAL8*) LALInferenceGetVariable(model->params, "flow");
else
f_low = model->fLow;
f_start = fLow2fStart(f_low, amporder, approximant);
f_max = 0.0; /* for freq domain waveforms this will stop at ISCO. Previously found using model->fHigh causes NaNs in waveform (see redmine issue #750)*/
/* ==== SPINS ==== */
/* We will default to spinless signal and then add in the spin components if required */
/* If there are non-aligned spins, we must convert between the System Frame coordinates
* and the cartestian coordinates */
/* The cartesian spin coordinates (default 0), as passed to LALSimulation */
REAL8 spin1x = 0.0;
REAL8 spin1y = 0.0;
REAL8 spin1z = 0.0;
REAL8 spin2x = 0.0;
REAL8 spin2y = 0.0;
REAL8 spin2z = 0.0;
/* System frame coordinates as used for jump proposals */
REAL8 a_spin1 = 0.0; /* Magnitude of spin1 */
REAL8 a_spin2 = 0.0; /* Magnitude of spin2 */
REAL8 phiJL = 0.0; /* azimuthal angle of L_N on its cone about J radians */
REAL8 tilt1 = 0.0; /* zenith angle between S1 and LNhat in radians */
REAL8 tilt2 = 0.0; /* zenith angle between S2 and LNhat in radians */
REAL8 phi12 = 0.0; /* difference in azimuthal angle btwn S1, S2 in radians */
/* Now check if we have spin amplitudes */
if(LALInferenceCheckVariable(model->params, "a_spin1")) a_spin1 = *(REAL8*) LALInferenceGetVariable(model->params, "a_spin1");
if(LALInferenceCheckVariable(model->params, "a_spin2")) a_spin2 = *(REAL8*) LALInferenceGetVariable(model->params, "a_spin2");
/* Check if we have spin angles too */
if(LALInferenceCheckVariable(model->params, "phi_jl"))
phiJL = LALInferenceGetREAL8Variable(model->params, "phi_jl");
if(LALInferenceCheckVariable(model->params, "tilt_spin1"))
tilt1 = LALInferenceGetREAL8Variable(model->params, "tilt_spin1");
if(LALInferenceCheckVariable(model->params, "tilt_spin2"))
tilt2 = LALInferenceGetREAL8Variable(model->params, "tilt_spin2");
if(LALInferenceCheckVariable(model->params, "phi12"))
phi12 = LALInferenceGetREAL8Variable(model->params, "phi12");
/* If we have tilt angles zero, then the spins are aligned and we just set the z component */
/* However, if the waveform supports precession then we still need to get the right coordinate components */
SpinSupport spin_support=XLALSimInspiralGetSpinSupportFromApproximant(approximant);
if(tilt1==0.0 && tilt2==0.0 && (spin_support==LAL_SIM_INSPIRAL_SPINLESS || spin_support==LAL_SIM_INSPIRAL_ALIGNEDSPIN))
{
spin1z=a_spin1;
spin2z=a_spin2;
inclination = thetaJN; /* Inclination angle is just thetaJN */
}
else
{ /* Template is not aligned-spin only. */
/* Set all the other spin components according to the angles we received above */
/* The transformation function doesn't know fLow, so f_ref==0 isn't interpretted as a request to use the starting frequency for reference. */
if(fTemp==0.0)
fTemp = f_start;
XLAL_TRY(ret=XLALSimInspiralTransformPrecessingNewInitialConditions(
&inclination, &spin1x, &spin1y, &spin1z, &spin2x, &spin2y, &spin2z,
thetaJN, phiJL, tilt1, tilt2, phi12, a_spin1, a_spin2, m1*LAL_MSUN_SI, m2*LAL_MSUN_SI, fTemp), errnum);
if (ret == XLAL_FAILURE)
{
XLALPrintError(" ERROR in XLALSimInspiralTransformPrecessingNewInitialConditions(): error converting angles. errnum=%d\n",errnum );
return;
}
}
/* ==== TIDAL PARAMETERS ==== */
REAL8 lambda1 = 0.;
if(LALInferenceCheckVariable(model->params, "lambda1")) lambda1 = *(REAL8*) LALInferenceGetVariable(model->params, "lambda1");
REAL8 lambda2 = 0.;
if(LALInferenceCheckVariable(model->params, "lambda2")) lambda2 = *(REAL8*) LALInferenceGetVariable(model->params, "lambda2");
REAL8 lambdaT = 0.;
REAL8 dLambdaT = 0.;
REAL8 sym_mass_ratio_eta = 0.;
if(LALInferenceCheckVariable(model->params, "lambdaT")&&LALInferenceCheckVariable(model->params, "dLambdaT")){
lambdaT = *(REAL8*) LALInferenceGetVariable(model->params, "lambdaT");
dLambdaT = *(REAL8*) LALInferenceGetVariable(model->params, "dLambdaT");
sym_mass_ratio_eta = m1*m2/((m1+m2)*(m1+m2));
LALInferenceLambdaTsEta2Lambdas(lambdaT,dLambdaT,sym_mass_ratio_eta,&lambda1,&lambda2);
}
/* Only use GR templates */
LALSimInspiralTestGRParam *nonGRparams = NULL;
/* ==== Call the waveform generator ==== */
if(model->domain == LAL_SIM_DOMAIN_FREQUENCY) {
deltaF = model->deltaF;
XLAL_TRY(ret=XLALSimInspiralChooseFDWaveformFromCache(&hptilde, &hctilde, phi0,
deltaF, m1*LAL_MSUN_SI, m2*LAL_MSUN_SI, spin1x, spin1y, spin1z,
spin2x, spin2y, spin2z, f_start, f_max, f_ref, distance, inclination,lambda1, lambda2, model->waveFlags, nonGRparams, amporder, order,
approximant,model->waveformCache, NULL), errnum);
/* if the waveform failed to generate, fill the buffer with zeros
* so that the previous waveform is not left there
*/
if (ret != XLAL_SUCCESS || hptilde == NULL || hctilde == NULL)
{
XLALPrintError(" ERROR in XLALSimInspiralChooseWaveformFromCache(): error generating waveform. errnum=%d\n",errnum );
memset(model->freqhPlus->data->data,0,sizeof(model->freqhPlus->data->data[0])*model->freqhPlus->data->length);
memset(model->freqhCross->data->data,0,sizeof(model->freqhCross->data->data[0])*model->freqhCross->data->length);
if ( hptilde ) XLALDestroyCOMPLEX16FrequencySeries(hptilde);
if ( hctilde ) XLALDestroyCOMPLEX16FrequencySeries(hctilde);
XLALSimInspiralDestroyTestGRParam(nonGRparams);
XLAL_ERROR_VOID(XLAL_FAILURE);
}
if (hptilde==NULL || hptilde->data==NULL || hptilde->data->data==NULL ) {
XLALPrintError(" ERROR in LALInferenceTemplateXLALSimInspiralChooseWaveform(): encountered unallocated 'hptilde'.\n");
XLAL_ERROR_VOID(XLAL_EFAULT);
}
if (hctilde==NULL || hctilde->data==NULL || hctilde->data->data==NULL ) {
XLALPrintError(" ERROR in LALInferenceTemplateXLALSimInspiralChooseWaveform(): encountered unallocated 'hctilde'.\n");
XLAL_ERROR_VOID(XLAL_EFAULT);
}
INT4 rem=0;
UINT4 size=hptilde->data->length;
if(size>model->freqhPlus->data->length) size=model->freqhPlus->data->length;
memcpy(model->freqhPlus->data->data,hptilde->data->data,sizeof(hptilde->data->data[0])*size);
if( (rem=(model->freqhPlus->data->length - size)) > 0)
memset(&(model->freqhPlus->data->data[size]),0, rem*sizeof(hptilde->data->data[0]) );
size=hctilde->data->length;
if(size>model->freqhCross->data->length) size=model->freqhCross->data->length;
memcpy(model->freqhCross->data->data,hctilde->data->data,sizeof(hctilde->data->data[0])*size);
if( (rem=(model->freqhCross->data->length - size)) > 0)
memset(&(model->freqhCross->data->data[size]),0, rem*sizeof(hctilde->data->data[0]) );
/* Destroy the nonGr params */
XLALSimInspiralDestroyTestGRParam(nonGRparams);
REAL8 instant = model->freqhPlus->epoch.gpsSeconds + 1e-9*model->freqhPlus->epoch.gpsNanoSeconds;
LALInferenceSetVariable(model->params, "time", &instant);
} else {
XLAL_TRY(ret=XLALSimInspiralChooseTDWaveformFromCache(&hplus, &hcross, phi0, deltaT,
m1*LAL_MSUN_SI, m2*LAL_MSUN_SI, spin1x, spin1y, spin1z,
spin2x, spin2y, spin2z, f_start, f_ref, distance,
inclination, lambda1, lambda2, model->waveFlags, nonGRparams,
amporder, order, approximant,model->waveformCache), errnum);
XLALSimInspiralDestroyTestGRParam(nonGRparams);
if (ret == XLAL_FAILURE || hplus == NULL || hcross == NULL)
{
XLALPrintError(" ERROR in XLALSimInspiralChooseWaveformFromCache(): error generating waveform. errnum=%d\n",errnum );
memset(model->timehPlus->data->data,0,sizeof(model->timehPlus->data->data[0]) * model->timehPlus->data->length);
memset(model->timehCross->data->data,0,sizeof(model->timehCross->data->data[0]) * model->timehCross->data->length);
if ( hplus ) XLALDestroyREAL8TimeSeries(hplus);
if ( hcross ) XLALDestroyREAL8TimeSeries(hcross);
XLALSimInspiralDestroyTestGRParam(nonGRparams);
XLAL_ERROR_VOID(XLAL_FAILURE);
}
/* The following complicated mess is a result of the following considerations:
1) The discrete time samples of the template and the timeModel
buffers will not, in general line up.
2) The likelihood function will timeshift the template in the
frequency domain to align it properly with the desired tc in
each detector (these are different because the detectors
receive the signal at different times). Because this
timeshifting is done in the frequency domain, the effective
time-domain template is periodic. We want to avoid the
possibility of non-zero template samples wrapping around from
the start/end of the buffer, since real templates are not
periodic!
3) If the template apporaches the ends of the timeModel buffer,
then it should be tapered in the same way as the timeData
(currently 0.4 seconds, hard-coded! Tukey window; see
LALInferenceReadData.c, near line 233) so that template and
signal in the data match. However, as an optimization, we
perform only one tapering and FFT-ing in the likelihood
function; subsequent timeshifts for the different detectors
will cause the tapered regions of the template and data to
become mis-aligned.
The algorthim we use is the following:
1) Inject the template to align with the nearest sample in the
timeModel buffer to the desired geocent_end time.
2) Check whether either the start or the end of the template
overlaps the tapered region, plus a safety buffer corresponding
to a conservative estimate of the largest geocenter <-->
detector timeshift.
a) If there is no overlap at the start or end of the buffer,
we're done.
b) If there is an overlap, issue one warning per process
(which can be disabled by setting the LAL debug level) about
a too-short segment length, and return.
*/
size_t waveLength = hplus->data->length;
size_t bufLength = model->timehPlus->data->length;
/* 2*Rearth/(c*deltaT)---2 is safety factor---is the maximum time
shift for any earth-based detector. */
size_t maxShift = (size_t)lround(4.255e-2/deltaT);
/* Taper 0.4 seconds at start and end (hard-coded! in
LALInferenceReadData.c, around line 233). */
size_t taperLength = (size_t)lround(0.4/deltaT);
/* Within unsafeLength of ends of buffer, possible danger of
wrapping and/or tapering interactions. */
size_t unsafeLength = taperLength + maxShift;
REAL8 desiredTc = *(REAL8 *)LALInferenceGetVariable(model->params, "time");
REAL8 tStart = XLALGPSGetREAL8(&(model->timehPlus->epoch));
REAL8 tEnd = tStart + deltaT * model->timehPlus->data->length;
if (desiredTc < tStart || desiredTc > tEnd) {
XLALDestroyREAL8TimeSeries(hplus);
XLALDestroyREAL8TimeSeries(hcross);
XLAL_PRINT_ERROR("desired tc (%.4f) outside data buffer\n", desiredTc);
XLAL_ERROR_VOID(XLAL_EDOM);
}
/* The nearest sample in model buffer to the desired tc. */
size_t tcSample = (size_t)lround((desiredTc - XLALGPSGetREAL8(&(model->timehPlus->epoch)))/deltaT);
/* The acutal coalescence time that corresponds to the buffer
sample on which the waveform's tC lands. */
REAL8 injTc = XLALGPSGetREAL8(&(model->timehPlus->epoch)) + tcSample*deltaT;
/* The sample at which the waveform reaches tc. */
size_t waveTcSample = (size_t)lround(-XLALGPSGetREAL8(&(hplus->epoch))/deltaT);
/* 1 + (number of samples post-tc in waveform) */
size_t wavePostTc = waveLength - waveTcSample;
size_t bufStartIndex = (tcSample >= waveTcSample ? tcSample - waveTcSample : 0);
size_t bufEndIndex = (wavePostTc + tcSample <= bufLength ? wavePostTc + tcSample : bufLength);
size_t bufWaveLength = bufEndIndex - bufStartIndex;
size_t waveStartIndex = (tcSample >= waveTcSample ? 0 : waveTcSample - tcSample);
if (bufStartIndex < unsafeLength || (bufLength - bufEndIndex) <= unsafeLength) {
/* The waveform could be timeshifted into a region where it will
be tapered improperly, or even wrap around from the periodic
timeshift. Issue warning. */
if (!sizeWarning) {
fprintf(stderr, "WARNING: Generated template is too long to guarantee that it will not\n");
fprintf(stderr, "WARNING: (a) lie in a tapered region of the time-domain buffer\n");
fprintf(stderr, "WARNING: (b) wrap periodically when timeshifted in likelihood computation\n");
fprintf(stderr, "WARNING: Either of these may cause differences between the template and the\n");
fprintf(stderr, "WARNING: correct GW waveform in each detector.\n");
fprintf(stderr, "WARNING: Parameter estimation will continue, but you should consider\n");
fprintf(stderr, "WARNING: increasing the data segment length (using the --seglen) option.\n");
sizeWarning = 1;
}
}
/* Clear model buffers */
memset(model->timehPlus->data->data, 0, sizeof(REAL8)*model->timehPlus->data->length);
memset(model->timehCross->data->data, 0, sizeof(REAL8)*model->timehCross->data->length);
/* Inject */
memcpy(model->timehPlus->data->data + bufStartIndex,
hplus->data->data + waveStartIndex,
bufWaveLength*sizeof(REAL8));
memcpy(model->timehCross->data->data + bufStartIndex,
hcross->data->data + waveStartIndex,
bufWaveLength*sizeof(REAL8));
LALInferenceSetVariable(model->params, "time", &injTc);
}
if ( hplus ) XLALDestroyREAL8TimeSeries(hplus);
if ( hcross ) XLALDestroyREAL8TimeSeries(hcross);
if ( hptilde ) XLALDestroyCOMPLEX16FrequencySeries(hptilde);
if ( hctilde ) XLALDestroyCOMPLEX16FrequencySeries(hctilde);
return;
}
void ReadInput(InputParams *inputParams, int argc, char *argv[]){
struct LALoption long_options[] =
{
{ "help", no_argument, 0, 'h' },
{ "detector", required_argument, 0, 'i' },
{ "channel", required_argument, 0, 'c' },
{ "epoch", required_argument, 0, 'e' },
{ "geocentre", no_argument, 0, 'g' },
{ "duration", required_argument, 0, 'd' },
{ "pulsar-dir", required_argument, 0, 'p' },
{ "output-dir", required_argument, 0, 'o' },
{ "output-str", required_argument, 0, 's' },
{ "ephem-dir", required_argument, 0, 'm' },
{ "ephem-type", required_argument, 0, 'y' },
{ "dbg-lvl", required_argument, 0, 'l' },
{ 0, 0, 0, 0 }
};
const CHAR *fn = __func__;
CHAR args[] = "hi:c:e:gd:p:o:s:m:y:l:";
CHAR *program = argv[0];
/* default the debug level to 1 */
/* default to no set the detector to the geocentre */
inputParams->geocentre = 0;
/* default ephemeris to use DE405 */
inputParams->ephemType = XLALStringDuplicate( "DE405" );
/* get input arguments */
while(1){
INT4 option_index = 0;
INT4 c;
c = LALgetopt_long( argc, argv, args, long_options, &option_index );
if ( c == -1 ) /* end of options */
break;
switch(c){
case 0: /* if option set a flag, nothing else to do */
if ( long_options[option_index].flag )
break;
else
fprintf(stderr, "Error parsing option %s with argument %s\n",
long_options[option_index].name, LALoptarg );
case 'h': /* help message */
fprintf(stderr, USAGE, program);
exit(0);
case 'l': /* debug level */
break;
case 'i': /* interferometer/detector */
inputParams->det = XLALStringDuplicate( LALoptarg );
break;
case 'c': /* channel name */
inputParams->channel = XLALStringDuplicate( LALoptarg );
break;
case 'e': /* frame epoch */
inputParams->epoch = atoi(LALoptarg);
break;
case 'g': /* geocentre flag */
inputParams->geocentre = 1;
break;
case 'd': /* frame duration */
inputParams->frDur = atoi(LALoptarg);
break;
case 'p': /* pulsar par file directory */
inputParams->pulsarDir = XLALStringDuplicate( LALoptarg );
break;
case 'o': /* output directory */
inputParams->outDir = XLALStringDuplicate( LALoptarg );
break;
case 's': /* output name string */
inputParams->outStr = XLALStringDuplicate( LALoptarg );
break;
case 'm': /* ephemeris file directory */
inputParams->ephemDir = XLALStringDuplicate( LALoptarg );
break;
case 'y': /* ephemeris file year */
inputParams->ephemType = XLALStringDuplicate( LALoptarg );
break;
case '?':
fprintf(stderr, "unknown error while parsing options\n" );
default:
fprintf(stderr, "unknown error while parsing options\n" );
}
}
if( inputParams->epoch == 0 || inputParams->frDur == 0 ){
XLALPrintError ("%s: Frame epoch or duration are 0!\n", fn );
XLAL_ERROR_VOID ( XLAL_EFUNC );
}
}
/**
* XLAL function to compute the binary time delay
*/
void
XLALBinaryPulsarDeltaT( BinaryPulsarOutput *output,
BinaryPulsarInput *input,
BinaryPulsarParams *params )
{
REAL8 dt=0.; /* binary pulsar deltaT */
REAL8 x, xdot; /* x = asini/c */
REAL8 w=0; /* longitude of periastron */
REAL8 e, edot; /* eccentricity */
REAL8 eps1, eps2;
REAL8 eps1dot, eps2dot;
REAL8 w0, wdot;
REAL8 Pb, pbdot;
REAL8 xpbdot;
REAL8 T0, Tasc, tb=0.; /* time parameters */
REAL8 s, r; /* Shapiro shape and range params */
REAL8 lal_gamma; /* time dilation and grav redshift */
REAL8 dr, dth;
REAL8 shapmax; /* Shapiro max parameter for DDS model */
REAL8 a0, b0; /* abberation parameters */
REAL8 m2;
const REAL8 c3 = (REAL8)LAL_C_SI*(REAL8)LAL_C_SI*(REAL8)LAL_C_SI;
CHAR *model = params->model;
/* Check input arguments */
if( input == (BinaryPulsarInput *)NULL ){
XLAL_ERROR_VOID( BINARYPULSARTIMINGH_ENULLINPUT );
}
if( output == (BinaryPulsarOutput *)NULL ){
XLAL_ERROR_VOID( BINARYPULSARTIMINGH_ENULLOUTPUT );
}
if( params == (BinaryPulsarParams *)NULL ){
XLAL_ERROR_VOID( BINARYPULSARTIMINGH_ENULLPARAMS );
}
if((!strcmp(params->model, "BT")) &&
(!strcmp(params->model, "BT1P")) &&
(!strcmp(params->model, "BT2P")) &&
(!strcmp(params->model, "BTX")) &&
(!strcmp(params->model, "ELL1")) &&
(!strcmp(params->model, "DD")) &&
(!strcmp(params->model, "DDS")) &&
(!strcmp(params->model, "MSS")) &&
(!strcmp(params->model, "T2"))){
XLAL_ERROR_VOID( BINARYPULSARTIMINGH_ENULLBINARYMODEL );
}
/* convert certain params to SI units */
w0 = params->w0;
wdot = params->wdot; /* wdot in rads/s */
Pb = params->Pb; /* period in secs */
pbdot = params->Pbdot;
T0 = params->T0; /* these should be in TDB in seconds */
Tasc = params->Tasc;
e = params->e;
edot = params->edot;
eps1 = params->eps1;
eps2 = params->eps2;
eps1dot = params->eps1dot;
eps2dot = params->eps2dot;
x = params->x;
xdot = params->xdot;
xpbdot = params->xpbdot;
lal_gamma = params->gamma;
s = params->s; /* sin i */
dr = params->dr;
dth = params->dth;
shapmax = params->shapmax;
a0 = params->a0;
b0 = params->b0;
m2 = params->m2;
/* Shapiro range parameter r defined as Gm2/c^3 (secs) */
r = LAL_G_SI*m2/c3;
/* if T0 is not defined, but Tasc is */
if(T0 == 0.0 && Tasc != 0.0 && eps1 == 0.0 && eps2 == 0.0){
REAL8 fe, uasc, Dt; /* see TEMPO tasc2t0.f */
fe = sqrt((1.0 - e)/(1.0 + e));
uasc = 2.0*atan(fe*tan(w0/2.0));
Dt = (Pb/LAL_TWOPI)*(uasc-e*sin(uasc));
T0 = Tasc + Dt;
}
/* set time at which to calculate the binary time delay */
tb = input->tb;
/* for BT, BT1P and BT2P models (and BTX model, but only for one orbit) */
if(strstr(model, "BT") != NULL){
REAL8 tt0;
REAL8 orbits=0.;
INT4 norbits=0.;
REAL8 phase; /* same as mean anomaly */
REAL8 u = 0.0; /* eccentric anomaly */
INT4 nplanets=1; /* number of orbiting bodies in system */
INT4 i=1, j=1;
REAL8 fac=1.; /* factor in front of fb coefficients */
REAL8 su = 0., cu = 0.;
REAL8 sw = 0., cw = 0.;
/* work out number of orbits i.e. have we got a BT1P or BT2P model */
if( !strcmp(model, "BT1P") ) nplanets = 2;
if( !strcmp(model, "BT2P") ) nplanets = 3;
for ( i=1 ; i < nplanets+1 ; i++){
/* set some vars for bnrybt.f (TEMPO) method */
/*REAL8 tt;
REAL8 som;
REAL8 com;
REAL8 alpha, beta;*/
/*REAL8 q, r, s;*/
/*fprintf(stderr, "You are using the Blandford-Teukolsky (BT) binary
model.\n");*/
if(i==2){
T0 = params->T02;
w0 = params->w02;
x = params->x2;
e = params->e2;
Pb = params->Pb2;
}
else if(i==3){
T0 = params->T03;
w0 = params->w03;
x = params->x3;
e = params->e3;
Pb = params->Pb3;
}
tt0 = tb - T0;
/* only do relativistic corrections for first orbit */
if(i==1){
x = x + xdot*tt0;
e = e + edot*tt0;
w = w0 + wdot*tt0; /* calculate w */
if( !strcmp(model, "BTX") ){
fac = 1.;
for ( j=1 ; j < params->nfb + 1; j++){
fac /= (REAL8)j;
orbits += fac*params->fb[j-1]*pow(tt0,j);
}
}
else{
orbits = tt0/Pb - 0.5*(pbdot+xpbdot)*(tt0/Pb)*(tt0/Pb);
}
}
else{
orbits = tt0/Pb;
}
norbits = (INT4)orbits;
if(orbits < 0.) norbits--;
phase = LAL_TWOPI*(orbits - (REAL8)norbits); /* called phase in TEMPO */
/* compute eccentric anomaly */
XLALComputeEccentricAnomaly( phase, e, &u );
su = sin(u);
cu = cos(u);
/*fprintf(stderr, "Eccentric anomaly = %f, phase = %f.\n", u, phase);*/
sw = sin(w);
cw = cos(w);
/* see eq 5 of Taylor and Weisberg (1989) */
/**********************************************************/
if( !strcmp(model, "BTX") ){
/* dt += (x*sin(w)*(cos(u)-e) + (x*cos(w)*sqrt(1.0-e*e) +
lal_gamma)*sin(u))*(1.0 - params->fb[0]*(x*cos(w)*sqrt(1.0 -
e*e)*cos(u) - x*sin(w)*sin(u))/(1.0 - e*cos(u))); */
dt += (x*sw*(cu-e) + (x*cw*sqrt(1.0-e*e) +
lal_gamma)*su)*(1.0 - LAL_TWOPI*params->fb[0]*(x*cw*sqrt(1.0 -
e*e)*cu - x*sw*su)/(1.0 - e*cu));
}
else{
/* dt += (x*sin(w)*(cos(u)-e) + (x*cos(w)*sqrt(1.0-e*e) +
lal_gamma)*sin(u))*(1.0 - (LAL_TWOPI/Pb)*(x*cos(w)*sqrt(1.0 -
e*e)*cos(u) - x*sin(w)*sin(u))/(1.0 - e*cos(u))); */
dt += (x*sw*(cu-e) + (x*cw*sqrt(1.0-e*e) +
lal_gamma)*su)*(1.0 - (LAL_TWOPI/Pb)*(x*cw*sqrt(1.0 -
e*e)*cu - x*sw*su)/(1.0 - e*cu));
}
/**********************************************************/
}
/* use method from Taylor etal 1976 ApJ Lett and used in bnrybt.f */
/**********************************************************/
/*tt = 1.0-e*e;
som = sin(w);
com = cos(w);
alpha = x*som;
beta = x*com*sqrt(tt);
q = alpha*(cos(u)-e) + (beta+lal_gamma)*sin(u);
r = -alpha*sin(u) + beta*cos(u);
s = 1.0/(1.0-e*cos(u));
dt = -(-q+(LAL_TWOPI/Pb)*q*r*s);*/
/**********************************************************/
/* There appears to be NO difference between either method */
output->deltaT = -dt;
}
/* for ELL1 model (low eccentricity orbits so use eps1 and eps2) */
/* see Appendix A, Ch. Lange etal, MNRAS (2001) (also accept T2 model if
eps values are set - this will include Kopeikin terms if necessary) */
if( !strcmp(model, "ELL1") || (!strcmp(model, "T2") && eps1 != 0. ) ){
REAL8 nb = LAL_TWOPI/Pb;
REAL8 tt0;
REAL8 w_int; /* omega internal to this model */
REAL8 orbits, phase;
INT4 norbits;
REAL8 e1, e2, ecc;
REAL8 DRE, DREp, DREpp; /* Roemer and Einstein delays (cf DD) */
REAL8 dlogbr;
REAL8 DS, DA; /* Shapiro delay and Abberation delay terms */
REAL8 Dbb;
REAL8 DAOP, DSR; /* Kopeikin delay terms */
KopeikinTerms kt;
REAL8 Ck, Sk;
REAL8 sp = 0., cp = 0., s2p = 0., c2p = 0.;
/* fprintf(stderr, "You are using the ELL1 low eccentricity orbit model.\n");*/
/*********************************************************/
/* CORRECT CODE (as in TEMPO bnryell1.f) FROM HERE */
ecc = sqrt(eps1*eps1 + eps2*eps2);
/* if Tasc is not defined convert T0 */
if(Tasc == 0.0 && T0 != 0.0){
REAL8 fe, uasc, Dt; /* see TEMPO tasc2t0.f */
fe = sqrt((1.0 - ecc)/(1.0 + ecc));
uasc = 2.0*atan(fe*tan(w0/2.0));
Dt = (Pb/LAL_TWOPI)*(uasc-ecc*sin(uasc));
/* rearrange from what's in tasc2t0.f */
Tasc = T0 - Dt;
}
tt0 = tb - Tasc;
orbits = tt0/Pb - 0.5*(pbdot+xpbdot)*(tt0/Pb)*(tt0/Pb);
norbits = (INT4)orbits;
if(orbits < 0.0) norbits--;
phase=LAL_TWOPI*(orbits - (REAL8)norbits);
x = x + xdot*tt0;
/* depending on whether we have eps derivs or w time derivs calculate e1 and e2 accordingly */
if(params->nEll == 0){
e1 = eps1 + eps1dot*tt0;
e2 = eps2 + eps2dot*tt0;
}
else{
ecc = sqrt(eps1*eps1 + eps2*eps2);
ecc += edot*tt0;
w_int = atan2(eps1, eps2);
w_int = w_int + wdot*tt0;
e1 = ecc*sin(w_int);
e2 = ecc*cos(w_int);
}
//sin_cos_LUT(&sp, &cp, phase);
//sin_cos_LUT(&s2p, &c2p, 2.*phase);
sp = sin(phase);
cp = cos(phase);
s2p = sin(2.*phase);
c2p = cos(2.*phase);
/* this timing delay (Roemer + Einstein) should be most important in most cases */
/* DRE = x*(sin(phase)-0.5*(e1*cos(2.0*phase)-e2*sin(2.0*phase)));
DREp = x*cos(phase);
DREpp = -x*sin(phase); */
DRE = x*(sp-0.5*(e1*c2p-e2*s2p));
DREp = x*cp;
DREpp = -x*sp;
/* these params will normally be negligable */
dlogbr = log(1.0-s*sp);
DS = -2.0*r*dlogbr;
DA = a0*sp + b0*cp;
/* compute Kopeikin terms */
if( params->kinset && params->komset && ( params->pmra != 0. ||
params->pmdec != 0. ) ){
XLALComputeKopeikinTerms( &kt, params, input );
Ck = sp - 0.5*(e1*c2p - e2*s2p);
Sk = cp + 0.5*(e2*c2p + e1*s2p);
DAOP = (kt.DK011 + kt.DK012)*Ck - (kt.DK021 + kt.DK022)*Sk;
DSR = (kt.DK031 + kt.DK032)*Ck + (kt.DK041 + kt.DK042)*Sk;
}
else{
DAOP = 0.;
DSR = 0.;
}
Dbb = DRE*(1.0-nb*DREp+(nb*DREp)*(nb*DREp) + 0.5*nb*nb*DRE*DREpp) + DS + DA
+ DAOP + DSR;
output->deltaT = -Dbb;
/********************************************************/
}
/* for DD model - code partly adapted from TEMPO bnrydd.f */
/* also used for MSS model (Wex 1998) - main sequence star orbit - this only has two lines
different than DD model - TEMPO bnrymss.f */
/* also DDS model and (partial) T2 model (if EPS params not set) from TEMPO2
T2model.C */
if( !strcmp(model, "DD") || !strcmp(model, "MSS") || !strcmp(model, "DDS") ||
(!strcmp(model, "T2") && eps1 == 0.) ){
REAL8 u; /* new eccentric anomaly */
REAL8 Ae; /* eccentricity parameter */
REAL8 DRE; /* Roemer delay + Einstein delay */
REAL8 DREp, DREpp; /* see DD eqs 48 - 50 */
REAL8 DS; /* Shapiro delay */
REAL8 DA; /* aberation caused by pulsar rotation delay */
REAL8 DAOP, DSR; /* Kopeikin term delays */
REAL8 tt0;
/* various variable use during calculation */
REAL8 er, eth, an, k;
REAL8 orbits, phase;
INT4 norbits;
REAL8 onemecu, cae, sae;
REAL8 alpha, beta, bg;
REAL8 anhat, sqr1me2, cume, brace, dlogbr;
REAL8 Dbb; /* Delta barbar in DD eq 52 */
REAL8 xi; /* parameter for MSS model - the only other one needed */
REAL8 sdds = 0.; /* parameter for DDS model */
REAL8 su = 0., cu = 0.;
REAL8 sw = 0., cw = 0.;
KopeikinTerms kt;
REAL8 Ck, Sk;
/* fprintf(stderr, "You are using the Damour-Deruelle (DD) binary model.\n");*/
/* part of code adapted from TEMPO bnrydd.f */
an = LAL_TWOPI/Pb;
k = wdot/an;
xi = xdot/an; /* MSS parameter */
tt0 = tb - T0;
/* x = x + xdot*tt0; */
e = e + edot*tt0;
er = e*(1.0+dr);
eth = e*(1.0+dth);
orbits = (tt0/Pb) - 0.5*(pbdot+xpbdot)*(tt0/Pb)*(tt0/Pb);
norbits = (INT4)orbits;
if(orbits < 0.0) norbits--;
phase = LAL_TWOPI*(orbits - (REAL8)norbits);
/* compute eccentric anomaly */
XLALComputeEccentricAnomaly( phase, e, &u );
su = sin(u);
cu = cos(u);
/* compute Ae as in TEMPO bnrydd.f */
onemecu = 1.0 - e*cu;
cae = (cu - e)/onemecu;
sae = sqrt(1.0 - e*e)*su/onemecu;
Ae = atan2(sae,cae);
if(Ae < 0.0)
Ae = Ae + LAL_TWOPI;
Ae = LAL_TWOPI*orbits + Ae - phase;
w = w0 + k*Ae; /* add corrections to omega */ /* MSS also uses (om2dot, but not defined) */
/* small difference between MSS and DD */
if( !strcmp(model, "MSS") ){
x = x + xi*Ae; /* in bnrymss.f they also include a second time derivative of x (x2dot), but
this isn't defined for either of the two pulsars currently using this model */
}
else
x = x + xdot*tt0;
/* now compute time delays as in DD eqs 46 - 52 */
/* calculate Einstein and Roemer delay */
sw = sin(w);
cw = cos(w);
alpha = x*sw;
beta = x*sqrt(1.0-eth*eth)*cw;
bg = beta + lal_gamma;
DRE = alpha*(cu-er)+bg*su;
DREp = -alpha*su + bg*cu;
DREpp = -alpha*cu - bg*su;
anhat = an/onemecu;
/* calculate Shapiro and abberation delays DD eqs 26, 27 */
sqr1me2 = sqrt(1.0-e*e);
cume = cu-e;
if( !strcmp(model, "DDS") ){
sdds = 1. - exp(-1.*shapmax);
brace = onemecu-sdds*(sw*cume + sqr1me2*cw*su);
}
else brace = onemecu-s*(sw*cume + sqr1me2*cw*su);
dlogbr = log(brace);
DS = -2.0*r*dlogbr;
/* this abberation delay is prob fairly small */
DA = a0*(sin(w+Ae)+e*sw) + b0*(cos(w+Ae)+e*cw);
/* compute Kopeikin terms */
if( params->kinset && params->komset && ( params->pmra != 0. ||
params->pmdec != 0. ) ){
XLALComputeKopeikinTerms( &kt, params, input );
Ck = cw*(cu-er) - sqrt(1.-eth*eth)*sw*su;
Sk = sw*(cu-er) + sqrt(1.-eth*eth)*cw*su;
DAOP = (kt.DK011 + kt.DK012)*Ck - (kt.DK021 + kt.DK022)*Sk;
DSR = (kt.DK031 + kt.DK032)*Ck + (kt.DK041 + kt.DK042)*Sk;
}
else{
DAOP = 0.;
DSR = 0.;
}
/* timing difference */
Dbb = DRE*(1.0 - anhat*DREp+anhat*anhat*DREp*DREp + 0.5*anhat*anhat*DRE*DREpp -
0.5*e*su*anhat*anhat*DRE*DREp/onemecu) + DS + DA + DAOP + DSR;
output->deltaT = -Dbb;
}
/* for DDGR model */
/* for Epstein-Haugan (EH) model - see Haugan, ApJ (1985) eqs 69 and 71 */
/* check that the returned value is not a NaN */
if( isnan(output->deltaT) ){
XLAL_ERROR_VOID( BINARYPULSARTIMINGH_ENAN );
}
}
/**
* XLAL function to compute Kopeikin terms that include the effect of
* binary orbital parameters of parallax
*/
void XLALComputeKopeikinTerms( KopeikinTerms *kop,
BinaryPulsarParams *params,
BinaryPulsarInput *in ){
REAL8 sini, cosi, tani;
REAL8 sin_delta, cos_delta, sin_alpha, cos_alpha;
REAL8 delta_i0, delta_j0;
REAL8 sin_omega, cos_omega;
REAL8 ca, sa, cd, sd;
REAL8 delt;
REAL8 posPulsar[3], velPulsar[3], psrPos[3];
REAL8 tt0;
REAL8 dpara; /* parallax */
REAL8 x;
sini = sin(params->kin);
cosi = cos(params->kin);
tani = sini / cosi;
sin_omega = sin(params->kom);
cos_omega = cos(params->kom);
/* ki_dot is set in tempo2 function, but not used */
/* ki_dot = -params.pmra * sin_omega + params.pmdec*cos_omega; */
/* Equation 8 in Kopeikin 1996 */
// (*x) += ((*x)*ki_dot/tani)*tt0;
/* Equation 9 in Kopeikin 1996 */
//(*omz) += (pmra*cos_omega+pmdec*sin_omega)/sini*tt0;
/* Now modify x and omega due to the annual-orbital parallax term
* as described in Kopeikin 1995
*
* Require knowledge of the barycentric earth position vector - earth_ssb
*/
/* get pulsar vector */
ca = cos(params->ra);
sa = sin(params->ra);
cd = cos(params->dec);
sd = sin(params->dec);
posPulsar[0] = ca*cd;
posPulsar[1] = sa*cd;
posPulsar[2] = sd;
velPulsar[0] = -params->pmra/cos(params->dec)*sa*cd - params->pmdec*ca*sd;
velPulsar[1] = params->pmra/cos(params->dec)*ca*cd - params->pmdec*sa*sd;
velPulsar[2] = params->pmdec*cd;
delt = in->tb - params->posepoch;
/* add proper motion onto the pulsar position */
for( UINT4 i = 0; i < 3; i++ ) psrPos[i] = posPulsar[i] + delt*velPulsar[i];
/* Obtain vector pointing at the pulsar */
sin_delta = psrPos[2];
cos_delta = cos(asin(sin_delta));
sin_alpha = psrPos[1] / cos_delta;
cos_alpha = psrPos[0] / cos_delta;
/* Equation 15 in Kopeikin 1995 */
delta_i0 = -in->earth.posNow[0]/AULTSC*sin_alpha +
in->earth.posNow[1]/AULTSC*cos_alpha;
/* Equation 16 in Kopeikin 1995 */
delta_j0 = -in->earth.posNow[0]/AULTSC * sin_delta*cos_alpha -
in->earth.posNow[1]/AULTSC * sin_delta*sin_alpha +
in->earth.posNow[2]/AULTSC * cos_delta;
dpara = params->px;
x = params->x;
/* xpr and ypr are set in tempo2 function, but not used */
/* xpr = delta_i0*sin_omega - delta_j0*cos_omega;
ypr = delta_i0*cos_omega + delta_j0*sin_omega; */
/* Equations 18 and 19 in Kopeikin 1995 */
if( params->daopset ){
REAL8 daop = params->daop;
kop->DK011 = - x / daop / sini*delta_i0*sin_omega;
kop->DK012 = - x / daop / sini*delta_j0*cos_omega;
kop->DK013 = - x / daop / sini*delta_i0*cos_omega;
kop->DK014 = x / daop / sini*delta_j0*sin_omega;
kop->DK021 = x / daop / tani*delta_i0*cos_omega;
kop->DK022 = -x / daop / tani*delta_j0*sin_omega;
kop->DK023 = x / daop / tani*delta_i0*sin_omega;
kop->DK024 = x / daop / tani*delta_j0*cos_omega;
}
else{
kop->DK011 = -x * dpara / sini*delta_i0*sin_omega;
kop->DK012 = -x * dpara / sini*delta_j0*cos_omega;
kop->DK013 = -x * dpara / sini*delta_i0*cos_omega;
kop->DK014 = x * dpara / sini*delta_j0*sin_omega;
kop->DK021 = x * dpara / tani*delta_i0*cos_omega;
kop->DK022 = -x * dpara / tani*delta_j0*sin_omega;
kop->DK023 = x * dpara / tani*delta_i0*sin_omega;
kop->DK024 = x * dpara / tani*delta_j0*cos_omega;
}
if( params->T0 != 0. ) tt0 = in->tb - params->T0;
else if( params->Tasc != 0. ) tt0 = in->tb - params->Tasc;
else{
XLALPrintError("%s: Neither T0 or Tasc is defined!\n", __func__);
XLAL_ERROR_VOID( XLAL_EINVAL );
}
kop->DK031 = x * tt0 / sini*params->pmra*sin_omega;
kop->DK032 = x * tt0 / sini*params->pmdec*cos_omega;
kop->DK033 = x * tt0 / sini*params->pmra*cos_omega;
kop->DK034 = -x * tt0 / sini*params->pmdec*sin_omega;
kop->DK041 = x * tt0 / tani*params->pmra*cos_omega;
kop->DK042 = -x * tt0 / tani*params->pmdec*sin_omega;
kop->DK043 = -x * tt0 / tani*params->pmra*sin_omega;
kop->DK044 = -x * tt0 / tani*params->pmdec*cos_omega;
}
/**
* \brief Gzip the nested sample files
*
* This function gzips the output nested sample files. It will also strip unneccesary parameters
* from the header "_params.txt" file.
*
* \param runState [in] The analysis information structure
*/
void gzip_output( LALInferenceRunState *runState ){
/* Single thread here */
LALInferenceThreadState *threadState = runState->threads[0];
/* Open original output output file */
CHAR *outfile = NULL;
ProcessParamsTable *ppt1 = LALInferenceGetProcParamVal( runState->commandLine, "--outfile" );
if( ppt1 ){
CHAR outfilepars[256] = "", outfileparstmp[256] = "";
FILE *fppars = NULL, *fpparstmp = NULL;
UINT4 nonfixed = 1;
outfile = ppt1->value;
/* open file for printing out list of parameter names - this should already exist */
sprintf(outfilepars, "%s_params.txt", outfile);
if( (fppars = fopen(outfilepars, "r")) == NULL ){
XLAL_ERROR_VOID(XLAL_EIO, "Error... cannot open parameter name output file %s.", outfilepars);
}
/* read in the parameter names and remove the "model" value */
sprintf(outfileparstmp, "%s_params.txt_tmp", outfile);
if( (fpparstmp = fopen(outfileparstmp, "w")) == NULL ){
XLAL_ERROR_VOID(XLAL_EIO, "Error... cannot open parameter name output file %s.", outfileparstmp);
}
if ( LALInferenceGetProcParamVal( runState->commandLine, "--output-all-params" ) ){ nonfixed = 0; }
CHAR v[128] = "";
while( fscanf(fppars, "%s", v) != EOF ){
/* if outputing only non-fixed values then only re-output names of those non-fixed things */
if ( nonfixed ){
if ( LALInferenceCheckVariable( threadState->currentParams, v ) ){
if ( LALInferenceGetVariableVaryType( threadState->currentParams, v ) != LALINFERENCE_PARAM_FIXED ){
fprintf(fpparstmp, "%s\t", v);
}
}
}
else{
/* re-output everything to a temporary file */
fprintf(fpparstmp, "%s\t", v);
}
}
fclose(fppars);
fclose(fpparstmp);
/* move the temporary file name to the standard outfile_param name */
rename( outfileparstmp, outfilepars );
/* gzip the output file if required */
if( LALInferenceGetProcParamVal( runState->commandLine, "--gzip" ) ){
if ( XLALGzipTextFile( outfile ) != XLAL_SUCCESS ){
XLAL_PRINT_ERROR( "Error... Could not gzip the output file!\n" );
XLAL_ERROR_VOID( XLAL_EIO );
}
}
}
/* if we have XML enabled */
#ifdef HAVE_LIBLALXML
ProcessParamsTable *ppt2 = LALInferenceGetProcParamVal( runState->commandLine, "--outxml" );
if(!ppt2){
ppt2=LALInferenceGetProcParamVal(runState->commandLine,"--outXML");
}
CHAR *outVOTable = NULL;
if ( !ppt2 && !ppt1 ){
XLAL_PRINT_ERROR("Must specify either --outfile or --outXML\n");
XLAL_ERROR_VOID( XLAL_EIO );
}
if( ppt2 ){
outVOTable = ppt2->value;
/* gzip the output file if required */
if( LALInferenceGetProcParamVal( runState->commandLine, "--gzip" ) ){
if ( XLALGzipTextFile( outVOTable ) != XLAL_SUCCESS ){
XLAL_ERROR_VOID( XLAL_EIO, "Error... Could not gzip the output file!" );
}
}
}
#else
if ( !ppt1 ){ XLAL_ERROR_VOID( XLAL_EIO, "Error... --outfile not defined!" ); }
#endif
return;
}
void
LALFindChirpTDTemplate (
LALStatus *status,
FindChirpTemplate *fcTmplt,
InspiralTemplate *tmplt,
FindChirpTmpltParams *params
)
{
UINT4 j;
UINT4 shift;
UINT4 waveLength;
UINT4 numPoints;
REAL4 *xfac;
REAL8 deltaF;
REAL8 deltaT;
REAL8 sampleRate;
const REAL4 cannonDist = 1.0; /* Mpc */
/*CHAR infomsg[512];*/
PPNParamStruc ppnParams;
CoherentGW waveform;
REAL4Vector *tmpxfac = NULL; /* Used for band-passing */
INITSTATUS(status);
ATTATCHSTATUSPTR( status );
/*
*
* check that the arguments are reasonable
*
*/
/* check that the output structures exist */
ASSERT( fcTmplt, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( fcTmplt->data, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( fcTmplt->data->data, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* check that the parameter structure exists */
ASSERT( params, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( params->xfacVec, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
ASSERT( params->xfacVec->data, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* check we have an fft plan for the template */
ASSERT( params->fwdPlan, status,
FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* check that the timestep is positive */
ASSERT( params->deltaT > 0, status,
FINDCHIRPTDH_EDELT, FINDCHIRPTDH_MSGEDELT );
/* check that the input exists */
ASSERT( tmplt, status, FINDCHIRPTDH_ENULL, FINDCHIRPTDH_MSGENULL );
/* store deltaT and zero out the time domain waveform vector */
deltaT = params->deltaT;
sampleRate = 1.0 / deltaT;
xfac = params->xfacVec->data;
numPoints = params->xfacVec->length;
memset( xfac, 0, numPoints * sizeof(REAL4) );
ASSERT( numPoints == (2 * (fcTmplt->data->length - 1)), status,
FINDCHIRPTDH_EMISM, FINDCHIRPTDH_MSGEMISM );
/* choose the time domain template */
if ( params->approximant == GeneratePPN )
{
/*
*
* generate the waveform using LALGeneratePPNInspiral() from inject
*
*/
/* input parameters */
memset( &ppnParams, 0, sizeof(PPNParamStruc) );
ppnParams.deltaT = deltaT;
ppnParams.mTot = tmplt->mass1 + tmplt->mass2;
ppnParams.eta = tmplt->mass1 * tmplt->mass2 /
( ppnParams.mTot * ppnParams.mTot );
ppnParams.d = 1.0;
ppnParams.fStartIn = params->fLow;
ppnParams.fStopIn = -1.0 /
(6.0 * sqrt(6.0) * LAL_PI * ppnParams.mTot * LAL_MTSUN_SI);
/* generate waveform amplitude and phase */
memset( &waveform, 0, sizeof(CoherentGW) );
LALGeneratePPNInspiral( status->statusPtr, &waveform, &ppnParams );
CHECKSTATUSPTR( status );
/* print termination information and check sampling */
LALInfo( status, ppnParams.termDescription );
if ( ppnParams.dfdt > 2.0 )
{
ABORT( status, FINDCHIRPTDH_ESMPL, FINDCHIRPTDH_MSGESMPL );
}
if ( waveform.a->data->length > numPoints )
{
ABORT( status, FINDCHIRPTDH_ELONG, FINDCHIRPTDH_MSGELONG );
}
/* compute h(t) */
for ( j = 0; j < waveform.a->data->length; ++j )
{
xfac[j] =
waveform.a->data->data[2*j] * cos( waveform.phi->data->data[j] );
}
/* free the memory allocated by LALGeneratePPNInspiral() */
LALSDestroyVectorSequence( status->statusPtr, &(waveform.a->data) );
CHECKSTATUSPTR( status );
LALSDestroyVector( status->statusPtr, &(waveform.f->data) );
CHECKSTATUSPTR( status );
LALDDestroyVector( status->statusPtr, &(waveform.phi->data) );
CHECKSTATUSPTR( status );
LALFree( waveform.a );
LALFree( waveform.f );
LALFree( waveform.phi );
/* waveform parameters needed for findchirp filter */
tmplt->approximant = params->approximant;
tmplt->tC = ppnParams.tc;
tmplt->fFinal = ppnParams.fStop;
fcTmplt->tmpltNorm = params->dynRange / ( cannonDist * 1.0e6 * LAL_PC_SI );
fcTmplt->tmpltNorm *= fcTmplt->tmpltNorm;
}
else
{
/*
*
* generate the waveform by calling LALInspiralWave() from inspiral
*
*/
/* set up additional template parameters */
deltaF = 1.0 / ((REAL8) numPoints * deltaT);
tmplt->ieta = 1;
tmplt->approximant = params->approximant;
tmplt->order = params->order;
tmplt->massChoice = m1Andm2;
tmplt->tSampling = sampleRate;
tmplt->fLower = params->fLow;
tmplt->fCutoff = sampleRate / 2.0 - deltaF;
/* get the template norm right */
if ( params->approximant==EOBNR )
{
/* lalinspiral EOBNR code produces correct norm when
fed unit signalAmplitude and non-physical distance */
tmplt->signalAmplitude = 1.0;
tmplt->distance = -1.0;
}
else if ( params->approximant==EOBNRv2 )
{
/* this formula sets the ampl0 variable to 1.0
* within the lalsimulation EOBNRv2 waveform engine
* which again produces a correct template norm */
tmplt->distance = tmplt->totalMass*LAL_MRSUN_SI;
}
else if ( params->approximant==IMRPhenomD )
{
/* 1Mpc standard distance - not clear if this produces correct norm */
tmplt->distance = 1.0;
}
else if ( (params->approximant==IMRPhenomB) || (params->approximant==IMRPhenomC) )
{
XLALPrintError("**** LALFindChirpTDTemplate ERROR ****\n");
XLALPrintError("Old IMRPhenom approximant requested! Please switch to IMRPhenomD.\n");
XLALPrintError("If an approximant that precedes IMRPhenomD MUST be used, then\n");
XLALPrintError("comment out lines 251-257 in lalinspiral/src/FindChirpTDTemplate.c,\n");
XLALPrintError("recompile, and rerun.\n");
XLALPrintError("**************************************\n");
XLAL_ERROR_VOID(XLAL_EFUNC);
/* 1Mpc standard distance - not clear if this produces correct norm */
tmplt->distance = 1.0;
tmplt->spin1[2] = 2 * tmplt->chi/(1. + sqrt(1.-4.*tmplt->eta));
}
else
{
tmplt->distance = -1.0;
}
/* compute the tau parameters from the input template */
LALInspiralParameterCalc( status->statusPtr, tmplt );
CHECKSTATUSPTR( status );
/* determine the length of the chirp in sample points */
/* This call implicitely checks that a valid approximant+order combination
was fed in, because LALInspiralWaveLength calls XLALInspiralChooseModel
which is what ultimately limits the available choices. */
LALInspiralWaveLength( status->statusPtr, &waveLength, *tmplt );
CHECKSTATUSPTR( status );
if ( waveLength > numPoints )
{
ABORT( status, FINDCHIRPTDH_ELONG, FINDCHIRPTDH_MSGELONG );
}
/* generate the chirp in the time domain */
LALInspiralWave( status->statusPtr, params->xfacVec, tmplt );
CHECKSTATUSPTR( status );
/* template dependent normalization */
fcTmplt->tmpltNorm = 2 * tmplt->mu;
fcTmplt->tmpltNorm *= 2 * LAL_MRSUN_SI / ( cannonDist * 1.0e6 * LAL_PC_SI );
fcTmplt->tmpltNorm *= params->dynRange;
fcTmplt->tmpltNorm *= fcTmplt->tmpltNorm;
}
/* Taper the waveform if required */
if ( params->taperTmplt != LAL_SIM_INSPIRAL_TAPER_NONE )
{
if ( XLALSimInspiralREAL4WaveTaper( params->xfacVec, params->taperTmplt )
== XLAL_FAILURE )
{
ABORTXLAL( status );
}
}
/* Find the end of the chirp */
j = numPoints - 1;
while ( xfac[j] == 0 )
{
/* search for the end of the chirp but don't fall off the array */
if ( --j == 0 )
{
ABORT( status, FINDCHIRPTDH_EEMTY, FINDCHIRPTDH_MSGEEMTY );
}
}
++j;
/* Band pass the template if required */
if ( params->bandPassTmplt )
{
REAL4Vector bpVector; /*Used to save time */
/* We want to shift the template to the middle of the vector so */
/* that band-passing will work properly */
shift = ( numPoints - j ) / 2;
memmove( xfac + shift, xfac, j * sizeof( *xfac ) );
memset( xfac, 0, shift * sizeof( *xfac ) );
memset( xfac + ( numPoints + j ) / 2, 0,
( numPoints - ( numPoints + j ) / 2 ) * sizeof( *xfac ) );
/* Select an appropriate part of the vector to band pass. */
/* band passing the whole thing takes a lot of time */
if ( j > 2 * sampleRate && 2 * j <= numPoints )
{
bpVector.length = 2 * j;
bpVector.data = params->xfacVec->data + numPoints / 2 - j;
}
else if ( j <= 2 * sampleRate && j + 2 * sampleRate <= numPoints )
{
bpVector.length = j + 2 * sampleRate;
bpVector.data = params->xfacVec->data
+ ( numPoints - j ) / 2 - (INT4)sampleRate;
}
else
{
bpVector.length = params->xfacVec->length;
bpVector.data = params->xfacVec->data;
}
if ( XLALBandPassInspiralTemplate( &bpVector, 0.95 * tmplt->fLower,
1.02 * tmplt->fFinal, sampleRate ) == XLAL_FAILURE )
{
ABORTXLAL( status );
}
/* Now we need to do the shift to the end. */
/* Use a temporary vector to avoid mishaps */
if ( ( tmpxfac = XLALCreateREAL4Vector( numPoints ) ) == NULL )
{
ABORTXLAL( status );
}
if ( params->approximant == EOBNR || params->approximant == EOBNRv2
|| params->approximant == IMRPhenomB || params->approximant == IMRPhenomC )
{
/* We need to do something slightly different for EOBNR */
UINT4 endIndx = (UINT4) (tmplt->tC * sampleRate);
memcpy( tmpxfac->data, xfac + ( numPoints - j ) / 2 + endIndx,
( numPoints - ( numPoints - j ) / 2 - endIndx ) * sizeof( *xfac ) );
memcpy( tmpxfac->data + numPoints - ( numPoints - j ) / 2 - endIndx,
xfac, ( ( numPoints - j ) / 2 + endIndx ) * sizeof( *xfac ) );
}
else
{
memcpy( tmpxfac->data, xfac + ( numPoints + j ) / 2,
( numPoints - ( numPoints + j ) / 2 ) * sizeof( *xfac ) );
memcpy( tmpxfac->data + numPoints - ( numPoints + j ) / 2,
xfac, ( numPoints + j ) / 2 * sizeof( *xfac ) );
}
memcpy( xfac, tmpxfac->data, numPoints * sizeof( *xfac ) );
XLALDestroyREAL4Vector( tmpxfac );
tmpxfac = NULL;
}
else if ( params->approximant == EOBNR || params->approximant == EOBNRv2
|| params->approximant == IMRPhenomB || params->approximant == IMRPhenomC )
{
/* For EOBNR we shift so that tC is at the end of the vector */
if ( ( tmpxfac = XLALCreateREAL4Vector( numPoints ) ) == NULL )
{
ABORTXLAL( status );
}
/* Set the coalescence index depending on tC */
j = (UINT4) (tmplt->tC * sampleRate);
memcpy( tmpxfac->data + numPoints - j, xfac, j * sizeof( *xfac ) );
memcpy( tmpxfac->data, xfac + j, ( numPoints - j ) * sizeof( *xfac ) );
memcpy( xfac, tmpxfac->data, numPoints * sizeof( *xfac ) );
XLALDestroyREAL4Vector( tmpxfac );
tmpxfac = NULL;
}
else
{
/* No need for so much shifting around if not band passing */
/* shift chirp to end of vector so it is the correct place for the filter */
memmove( xfac + numPoints - j, xfac, j * sizeof( *xfac ) );
memset( xfac, 0, ( numPoints - j ) * sizeof( *xfac ) );
}
/*
*
* create the frequency domain findchirp template
*
*/
/* fft chirp */
if ( XLALREAL4ForwardFFT( fcTmplt->data, params->xfacVec,
params->fwdPlan ) == XLAL_FAILURE )
{
ABORTXLAL( status );
}
/* copy the template parameters to the findchirp template structure */
memcpy( &(fcTmplt->tmplt), tmplt, sizeof(InspiralTemplate) );
/* normal exit */
DETATCHSTATUSPTR( status );
RETURN( status );
}
/* The phasing function for TaylorF2 frequency-domain waveform.
* This function is tested in ../test/PNCoefficients.c for consistency
* with the energy and flux in this file.
*/
static void UNUSED
XLALSimInspiralPNPhasing_F2(
PNPhasingSeries *pfa, /**< \todo UNDOCUMENTED */
const REAL8 m1, /**< Mass of body 1, in Msol */
const REAL8 m2, /**< Mass of body 2, in Msol */
const REAL8 chi1L, /**< Component of dimensionless spin 1 along Lhat */
const REAL8 chi2L, /**< Component of dimensionless spin 2 along Lhat */
const REAL8 chi1sq,/**< Magnitude of dimensionless spin 1 */
const REAL8 chi2sq, /**< Magnitude of dimensionless spin 2 */
const REAL8 chi1dotchi2, /**< Dot product of dimensionles spin 1 and spin 2 */
LALDict *p /**< LAL dictionary containing accessory parameters */
)
{
const REAL8 mtot = m1 + m2;
const REAL8 d = (m1 - m2) / (m1 + m2);
const REAL8 eta = m1*m2/mtot/mtot;
const REAL8 m1M = m1/mtot;
const REAL8 m2M = m2/mtot;
/* Use the spin-orbit variables from arXiv:1303.7412, Eq. 3.9
* We write dSigmaL for their (\delta m/m) * \Sigma_\ell
* There's a division by mtotal^2 in both the energy and flux terms
* We just absorb the division by mtotal^2 into SL and dSigmaL
*/
const REAL8 SL = m1M*m1M*chi1L + m2M*m2M*chi2L;
const REAL8 dSigmaL = d*(m2M*chi2L - m1M*chi1L);
const REAL8 pfaN = 3.L/(128.L * eta);
memset(pfa, 0, sizeof(PNPhasingSeries));
/* Non-spin phasing terms - see arXiv:0907.0700, Eq. 3.18 */
pfa->v[0] = 1.L;
pfa->v[1] = 0.L;
pfa->v[2] = 5.L*(743.L/84.L + 11.L * eta)/9.L;
pfa->v[3] = -16.L*LAL_PI;
pfa->v[4] = 5.L*(3058.673L/7.056L + 5429.L/7.L * eta
+ 617.L * eta*eta)/72.L;
pfa->v[5] = 5.L/9.L * (7729.L/84.L - 13.L * eta) * LAL_PI;
pfa->vlogv[5] = 5.L/3.L * (7729.L/84.L - 13.L * eta) * LAL_PI;
pfa->v[6] = (11583.231236531L/4.694215680L
- 640.L/3.L * LAL_PI * LAL_PI - 6848.L/21.L*LAL_GAMMA)
+ eta * (-15737.765635L/3.048192L
+ 2255./12. * LAL_PI * LAL_PI)
+ eta*eta * 76055.L/1728.L
- eta*eta*eta * 127825.L/1296.L;
pfa->v[6] += (-6848.L/21.L)*log(4.);
pfa->vlogv[6] = -6848.L/21.L;
pfa->v[7] = LAL_PI * ( 77096675.L/254016.L
+ 378515.L/1512.L * eta - 74045.L/756.L * eta*eta);
/* modify the PN coefficients if a non null LALSimInspiralTestGRParam structure is passed */
pfa->v[0]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi0(p));
pfa->v[1] = XLALSimInspiralWaveformParamsLookupNonGRDChi1(p);
pfa->v[2]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi2(p));
pfa->v[3]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi3(p));
pfa->v[4]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi4(p));
pfa->v[5]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi5(p));
pfa->vlogv[5]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi5L(p));
pfa->v[6]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi6(p));
pfa->vlogv[6]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi6L(p));
pfa->v[7]*=(1.0+XLALSimInspiralWaveformParamsLookupNonGRDChi7(p));
REAL8 qm_def1=1.+XLALSimInspiralWaveformParamsLookupdQuadMon1(p);
REAL8 qm_def2=1.+XLALSimInspiralWaveformParamsLookupdQuadMon2(p);
/* Compute 2.0PN SS, QM, and self-spin */
// See Eq. (6.24) in arXiv:0810.5336
// 9b,c,d in arXiv:astro-ph/0504538
REAL8 pn_sigma = eta * (721.L/48.L*chi1L*chi2L - 247.L/48.L*chi1dotchi2);
pn_sigma += (720.L*qm_def1 - 1.L)/96.0L * m1M * m1M * chi1L * chi1L;
pn_sigma += (720.L*qm_def2 - 1.L)/96.0L * m2M * m2M * chi2L * chi2L;
pn_sigma -= (240.L*qm_def1 - 7.L)/96.0L * m1M * m1M * chi1sq;
pn_sigma -= (240.L*qm_def2 - 7.L)/96.0L * m2M * m2M * chi2sq;
REAL8 pn_ss3 = (326.75L/1.12L + 557.5L/1.8L*eta)*eta*chi1L*chi2L;
pn_ss3 += ((4703.5L/8.4L+2935.L/6.L*m1M-120.L*m1M*m1M)*qm_def1 + (-4108.25L/6.72L-108.5L/1.2L*m1M+125.5L/3.6L*m1M*m1M)) *m1M*m1M * chi1sq;
pn_ss3 += ((4703.5L/8.4L+2935.L/6.L*m2M-120.L*m2M*m2M)*qm_def2 + (-4108.25L/6.72L-108.5L/1.2L*m2M+125.5L/3.6L*m2M*m2M)) *m2M*m2M * chi2sq;
/* Spin-orbit terms - can be derived from arXiv:1303.7412, Eq. 3.15-16 */
const REAL8 pn_gamma = (554345.L/1134.L + 110.L*eta/9.L)*SL + (13915.L/84.L - 10.L*eta/3.L)*dSigmaL;
switch( XLALSimInspiralWaveformParamsLookupPNSpinOrder(p) )
{
case LAL_SIM_INSPIRAL_SPIN_ORDER_ALL:
case LAL_SIM_INSPIRAL_SPIN_ORDER_35PN:
pfa->v[7] += (-8980424995.L/762048.L + 6586595.L*eta/756.L - 305.L*eta*eta/36.L)*SL - (170978035.L/48384.L - 2876425.L*eta/672.L - 4735.L*eta*eta/144.L) * dSigmaL;
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case LAL_SIM_INSPIRAL_SPIN_ORDER_3PN:
pfa->v[6] += LAL_PI * (3760.L*SL + 1490.L*dSigmaL)/3.L + pn_ss3;
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case LAL_SIM_INSPIRAL_SPIN_ORDER_25PN:
pfa->v[5] += -1.L * pn_gamma;
pfa->vlogv[5] += -3.L * pn_gamma;
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case LAL_SIM_INSPIRAL_SPIN_ORDER_2PN:
pfa->v[4] += -10.L * pn_sigma;
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case LAL_SIM_INSPIRAL_SPIN_ORDER_15PN:
pfa->v[3] += 188.L*SL/3.L + 25.L*dSigmaL;
#if __GNUC__ >= 7
__attribute__ ((fallthrough));
#endif
case LAL_SIM_INSPIRAL_SPIN_ORDER_1PN:
case LAL_SIM_INSPIRAL_SPIN_ORDER_05PN:
case LAL_SIM_INSPIRAL_SPIN_ORDER_0PN:
break;
default:
XLALPrintError("XLAL Error - %s: Invalid spin PN order %i\n",
__func__, XLALSimInspiralWaveformParamsLookupPNSpinOrder(p) );
XLAL_ERROR_VOID(XLAL_EINVAL);
break;
}
/* At the very end, multiply everything in the series by pfaN */
for(int ii = 0; ii <= PN_PHASING_SERIES_MAX_ORDER; ii++)
{
pfa->v[ii] *= pfaN;
pfa->vlogv[ii] *= pfaN;
pfa->vlogvsq[ii] *= pfaN;
}
}
