/**
* Wrapper similar to XLALSimInspiralChooseFDWaveform() for waveforms to be generated a specific freqencies.
* Returns the waveform in the frequency domain at the frequencies of the REAL8Sequence frequencies.
*/
int XLALSimInspiralChooseFDWaveformSequence(
COMPLEX16FrequencySeries **hptilde, /**< FD plus polarization */
COMPLEX16FrequencySeries **hctilde, /**< FD cross polarization */
REAL8 phiRef, /**< reference orbital phase (rad) */
REAL8 m1, /**< mass of companion 1 (kg) */
REAL8 m2, /**< mass of companion 2 (kg) */
REAL8 S1x, /**< x-component of the dimensionless spin of object 1 */
REAL8 S1y, /**< y-component of the dimensionless spin of object 1 */
REAL8 S1z, /**< z-component of the dimensionless spin of object 1 */
REAL8 S2x, /**< x-component of the dimensionless spin of object 2 */
REAL8 S2y, /**< y-component of the dimensionless spin of object 2 */
REAL8 S2z, /**< z-component of the dimensionless spin of object 2 */
REAL8 f_ref, /**< Reference frequency (Hz) */
REAL8 distance, /**< distance of source (m) */
REAL8 inclination, /**< inclination of source (rad) */
LALDict *LALpars, /**< LALDictionary containing non-mandatory variables/flags */
Approximant approximant, /**< post-Newtonian approximant to use for waveform production */
REAL8Sequence *frequencies /**< sequence of frequencies for which the waveform will be computed. Pass in NULL (or None in python) for standard f_min to f_max sequence. */
)
{
int ret;
unsigned int j;
REAL8 pfac, cfac;
REAL8 LNhatx, LNhaty, LNhatz;
/* Support variables for precessing wfs*/
REAL8 incl;
REAL8 spin1x,spin1y,spin1z;
REAL8 spin2x,spin2y,spin2z;
/* Variables for IMRPhenomP and IMRPhenomPv2 */
REAL8 chi1_l, chi2_l, chip, thetaJ, alpha0;
/* General sanity checks that will abort
*
* If non-GR approximants are added, include them in
* XLALSimInspiralApproximantAcceptTestGRParams()
*/
if ( !XLALSimInspiralWaveformParamsNonGRAreDefault(LALpars) && XLALSimInspiralApproximantAcceptTestGRParams(approximant) != LAL_SIM_INSPIRAL_TESTGR_PARAMS ) {
XLALPrintError("XLAL Error - %s: Passed in non-NULL testGRparams for an approximant that does not use them\n", __func__);
XLAL_ERROR(XLAL_EINVAL);
}
if (!frequencies) XLAL_ERROR(XLAL_EFAULT);
REAL8 f_min = frequencies->data[0];
/* General sanity check the input parameters - only give warnings! */
if( m1 < 0.09 * LAL_MSUN_SI )
XLALPrintWarning("XLAL Warning - %s: Small value of m1 = %e (kg) = %e (Msun) requested...Perhaps you have a unit conversion error?\n", __func__, m1, m1/LAL_MSUN_SI);
if( m2 < 0.09 * LAL_MSUN_SI )
XLALPrintWarning("XLAL Warning - %s: Small value of m2 = %e (kg) = %e (Msun) requested...Perhaps you have a unit conversion error?\n", __func__, m2, m2/LAL_MSUN_SI);
if( m1 + m2 > 1000. * LAL_MSUN_SI )
XLALPrintWarning("XLAL Warning - %s: Large value of total mass m1+m2 = %e (kg) = %e (Msun) requested...Signal not likely to be in band of ground-based detectors.\n", __func__, m1+m2, (m1+m2)/LAL_MSUN_SI);
if( S1x*S1x + S1y*S1y + S1z*S1z > 1.000001 )
XLALPrintWarning("XLAL Warning - %s: S1 = (%e,%e,%e) with norm > 1 requested...Are you sure you want to violate the Kerr bound?\n", __func__, S1x, S1y, S1z);
if( S2x*S2x + S2y*S2y + S2z*S2z > 1.000001 )
XLALPrintWarning("XLAL Warning - %s: S2 = (%e,%e,%e) with norm > 1 requested...Are you sure you want to violate the Kerr bound?\n", __func__, S2x, S2y, S2z);
if( f_min < 1. )
XLALPrintWarning("XLAL Warning - %s: Small value of fmin = %e requested...Check for errors, this could create a very long waveform.\n", __func__, f_min);
if( f_min > 40.000001 )
XLALPrintWarning("XLAL Warning - %s: Large value of fmin = %e requested...Check for errors, the signal will start in band.\n", __func__, f_min);
/* The non-precessing waveforms return h(f) for optimal orientation
* (i=0, Fp=1, Fc=0; Lhat pointed toward the observer)
* To get generic polarizations we multiply by inclination dependence
* and note hc(f) \propto -I * hp(f)
* Non-precessing waveforms multiply hp by pfac, hc by -I*cfac
*/
cfac = cos(inclination);
pfac = 0.5 * (1. + cfac*cfac);
REAL8 lambda1=XLALSimInspiralWaveformParamsLookupTidalLambda1(LALpars);
REAL8 lambda2=XLALSimInspiralWaveformParamsLookupTidalLambda2(LALpars);
switch (approximant)
{
/* inspiral-only models */
case TaylorF2:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFrameAxisIsDefault(LALpars) )
ABORT_NONDEFAULT_FRAME_AXIS(LALpars);
if( !XLALSimInspiralWaveformParamsModesChoiceIsDefault(LALpars) )
ABORT_NONDEFAULT_MODES_CHOICE(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
/* Call the waveform driver routine */
ret = XLALSimInspiralTaylorF2Core(hptilde, frequencies, phiRef,
m1, m2, S1z, S2z, f_ref, 0., distance, LALpars);
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
/* Produce both polarizations */
*hctilde = XLALCreateCOMPLEX16FrequencySeries("FD hcross",
&((*hptilde)->epoch), (*hptilde)->f0, 0.0,
&((*hptilde)->sampleUnits), (*hptilde)->data->length);
for(j = 0; j < (*hptilde)->data->length; j++) {
(*hctilde)->data->data[j] = -I*cfac * (*hptilde)->data->data[j];
(*hptilde)->data->data[j] *= pfac;
}
break;
/* inspiral-merger-ringdown models */
case SEOBNRv1_ROM_EffectiveSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if (!checkAlignedSpinsEqual(S1z, S2z))
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv1ROMEffectiveSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, XLALSimIMRPhenomBComputeChi(m1, m2, S1z, S2z));
break;
case SEOBNRv1_ROM_DoubleSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv1ROMDoubleSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, S2z);
break;
case SEOBNRv2_ROM_EffectiveSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv2ROMEffectiveSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, XLALSimIMRPhenomBComputeChi(m1, m2, S1z, S2z));
break;
case SEOBNRv2_ROM_DoubleSpin:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv2ROMDoubleSpinFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, S2z);
break;
case SEOBNRv2_ROM_DoubleSpin_HI:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
ret = XLALSimIMRSEOBNRv2ROMDoubleSpinHIFrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, S2z, -1);
break;
case Lackey_Tidal_2013_SEOBNRv2_ROM:
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFlagsAreDefault(LALpars) )
ABORT_NONDEFAULT_LALDICT_FLAGS(LALpars);
if( !checkTransverseSpinsZero(S1x, S1y, S2x, S2y) )
ABORT_NONZERO_TRANSVERSE_SPINS(LALpars);
ret = XLALSimIMRLackeyTidal2013FrequencySequence(hptilde, hctilde, frequencies,
phiRef, f_ref, distance, inclination, m1, m2, S1z, lambda2);
break;
case IMRPhenomP:
XLALSimInspiralInitialConditionsPrecessingApproxs(&incl,&spin1x,&spin1y,&spin1z,&spin2x,&spin2y,&spin2z,inclination,S1x,S1y,S1z,S2x,S2y,S2z,m1,m2,f_ref,phiRef,XLALSimInspiralWaveformParamsLookupFrameAxis(LALpars));
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFrameAxisIsDefault(LALpars) )
ABORT_NONDEFAULT_FRAME_AXIS(LALpars);/* Default is LAL_SIM_INSPIRAL_FRAME_AXIS_VIEW : z-axis along direction of GW propagation (line of sight). */
if( !XLALSimInspiralWaveformParamsModesChoiceIsDefault(LALpars) )
ABORT_NONDEFAULT_MODES_CHOICE(LALpars);
/* Default is (2,2) or l=2 modes. */
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
LNhatx = sin(incl);
LNhaty = 0.;
LNhatz = cos(incl);
/* Tranform to model parameters */
if(f_ref==0.0)
f_ref = f_min; /* Default reference frequency is minimum frequency */
XLALSimIMRPhenomPCalculateModelParameters(
&chi1_l, &chi2_l, &chip, &thetaJ, &alpha0,
m1, m2, f_ref,
LNhatx, LNhaty, LNhatz,
spin1x, spin1y, spin1z,
spin2x, spin2y, spin2z, IMRPhenomPv1_V);
/* Call the waveform driver routine */
ret = XLALSimIMRPhenomPFrequencySequence(hptilde, hctilde, frequencies,
chi1_l, chi2_l, chip, thetaJ,
m1, m2, distance, alpha0, phiRef, f_ref, IMRPhenomPv1_V, NULL);
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
break;
case IMRPhenomPv2:
XLALSimInspiralInitialConditionsPrecessingApproxs(&incl,&spin1x,&spin1y,&spin1z,&spin2x,&spin2y,&spin2z,inclination,S1x,S1y,S1z,S2x,S2y,S2z,m1,m2,f_ref,phiRef,XLALSimInspiralWaveformParamsLookupFrameAxis(LALpars));
/* Waveform-specific sanity checks */
if( !XLALSimInspiralWaveformParamsFrameAxisIsDefault(LALpars) )
ABORT_NONDEFAULT_FRAME_AXIS(LALpars);/* Default is LAL_SIM_INSPIRAL_FRAME_AXIS_VIEW : z-axis along direction of GW propagation (line of sight). */
if( !XLALSimInspiralWaveformParamsModesChoiceIsDefault(LALpars) )
ABORT_NONDEFAULT_MODES_CHOICE(LALpars);
/* Default is (2,2) or l=2 modes. */
if( !checkTidesZero(lambda1, lambda2) )
ABORT_NONZERO_TIDES(LALpars);
LNhatx = sin(incl);
LNhaty = 0.;
LNhatz = cos(incl);
/* Tranform to model parameters */
if(f_ref==0.0)
f_ref = f_min; /* Default reference frequency is minimum frequency */
XLALSimIMRPhenomPCalculateModelParameters(
&chi1_l, &chi2_l, &chip, &thetaJ, &alpha0,
m1, m2, f_ref,
LNhatx, LNhaty, LNhatz,
spin1x, spin1y, spin1z,
spin2x, spin2y, spin2z, IMRPhenomPv2_V);
/* Call the waveform driver routine */
ret = XLALSimIMRPhenomPFrequencySequence(hptilde, hctilde, frequencies,
chi1_l, chi2_l, chip, thetaJ,
m1, m2, distance, alpha0, phiRef, f_ref, IMRPhenomPv2_V, NULL);
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
break;
default:
XLALPrintError("FD version of approximant not implemented in lalsimulation\n");
XLAL_ERROR(XLAL_EINVAL);
}
if (ret == XLAL_FAILURE) XLAL_ERROR(XLAL_EFUNC);
return ret;
}
static void Test_XLALSimIMRPhenomP(void) {
printf("\n** Test_XLALSimIMRPhenomP: **\n");
REAL8 eta, chi_eff, chip, thetaJ, phiJ, alpha0;
REAL8 m1 = 10;
REAL8 m2 = 40;
REAL8 m1_SI = m1 * LAL_MSUN_SI;
REAL8 m2_SI = m2 * LAL_MSUN_SI;
REAL8 s1x = 0.3;
REAL8 s1y = 0;
REAL8 s1z = 0.45;
REAL8 s2x = 0;
REAL8 s2y = 0;
REAL8 s2z = 0.45;
REAL8 lnhatx = sin(0.4);
REAL8 lnhaty = 0;
REAL8 lnhatz = cos(0.4);
REAL8 f_min = 20;
XLALSimIMRPhenomPCalculateModelParameters(
&chi_eff, /**< Output: Effective aligned spin */
&chip, /**< Output: Effective spin in the orbital plane */
&eta, /**< Output: Symmetric mass-ratio */
&thetaJ, /**< Output: Angle between J0 and line of sight (z-direction) */
&phiJ, /**< Output: Angle of J0 in the plane of the sky */
&alpha0, /**< Output: Initial value of alpha angle */
m1_SI, /**< Mass of companion 1 (kg) */
m2_SI, /**< Mass of companion 2 (kg) */
f_min, /**< Starting GW frequency (Hz) */
lnhatx, /**< Initial value of LNhatx: orbital angular momentum unit vector */
lnhaty, /**< Initial value of LNhaty */
lnhatz, /**< Initial value of LNhatz */
s1x, /**< Initial value of s1x: dimensionless spin of larger BH */
s1y, /**< Initial value of s1y: dimensionless spin of larger BH */
s1z, /**< Initial value of s1z: dimensionless spin of larger BH */
s2x, /**< Initial value of s2x: dimensionless spin of larger BH */
s2y, /**< Initial value of s2y: dimensionless spin of larger BH */
s2z); /**< Initial value of s2z: dimensionless spin of larger BH */
COMPLEX16FrequencySeries *hptilde = NULL;
COMPLEX16FrequencySeries *hctilde = NULL;
REAL8 phic = 0;
REAL8 deltaF = 0.06;
REAL8 f_max = 0; // 8000;
REAL8 distance = 100 * 1e6 * LAL_PC_SI;
int ret = XLALSimIMRPhenomP(
&hptilde, /**< Frequency-domain waveform h+ */
&hctilde, /**< Frequency-domain waveform hx */
chi_eff, /**< Effective aligned spin */
chip, /**< Effective spin in the orbital plane */
eta, /**< Symmetric mass-ratio */
thetaJ, /**< Angle between J0 and line of sight (z-direction) */
phiJ, /**< Angle of J0 in the plane of the sky */
m1_SI + m2_SI, /**< Total mass of binary (kg) */
distance, /**< Distance of source (m) */
alpha0, /**< Initial value of alpha angle */
phic, /**< Orbital coalescence phase (rad) */
deltaF, /**< Sampling frequency (Hz) */
f_min, /**< Starting GW frequency (Hz) */
f_max); /**< End frequency; 0 defaults to ringdown cutoff freq */
dump_file("PhenomP_Test1.dat", hptilde, hctilde, m1+m2);
UNUSED(ret);
COMPLEX16 hp = (hptilde->data->data)[1000];
COMPLEX16 hc = (hctilde->data->data)[1000];
prC("hp", hp);
prC("hc", hc);
COMPLEX16 hp_expected = 2.10915e-24 - I*5.50997e-23;
COMPLEX16 hc_expected = -5.48992e-23 - I*2.12973e-24;
const REAL8 eps = 1e-5;
assert(
approximatelyEqualC(hp, hp_expected, eps)
&& approximatelyEqualC(hc, hc_expected, eps)
&& "XLALSimIMRPhenomP()"
);
}
static void Test_PhenomC_PhenomP(void) {
printf("\n** Test_PhenomC_PhenomP: **\n");
REAL8 eta = 0.16;
REAL8 chi = 0.45;
REAL8 q = (1 + sqrt(1 - 4*eta) - 2*eta)/(2.*eta);
REAL8 M = 50;
// Parameters for XLALSimIMRPhenomPCalculateModelParameters
COMPLEX16FrequencySeries *hptilde = NULL;
COMPLEX16FrequencySeries *hctilde = NULL;
REAL8 phic = 0;
REAL8 deltaF = 0.06;
REAL8 m1_SI = M * q/(1+q) * LAL_MSUN_SI;
REAL8 m2_SI = M * 1.0/(1+q) * LAL_MSUN_SI;
REAL8 f_min = 10;
REAL8 f_max = 0; // 8000;
REAL8 distance = 100 * 1e6 * LAL_PC_SI;
REAL8 s1x = 0;
REAL8 s1y = 0;
REAL8 s1z = chi;
REAL8 s2x = 0;
REAL8 s2y = 0;
REAL8 s2z = chi;
REAL8 lnhatx = 0;
REAL8 lnhaty = 0;
REAL8 lnhatz = 1;
REAL8 chi_eff, chip, thetaJ, phiJ, alpha0;
XLALSimIMRPhenomPCalculateModelParameters(
&chi_eff, /**< Output: Effective aligned spin */
&chip, /**< Output: Effective spin in the orbital plane */
&eta, /**< Output: Symmetric mass-ratio */
&thetaJ, /**< Output: Angle between J0 and line of sight (z-direction) */
&phiJ, /**< Output: Angle of J0 in the plane of the sky */
&alpha0, /**< Output: Initial value of alpha angle */
m1_SI, /**< Mass of companion 1 (kg) */
m2_SI, /**< Mass of companion 2 (kg) */
f_min, /**< Starting GW frequency (Hz) */
lnhatx, /**< Initial value of LNhatx: orbital angular momentum unit vector */
lnhaty, /**< Initial value of LNhaty */
lnhatz, /**< Initial value of LNhatz */
s1x, /**< Initial value of s1x: dimensionless spin of larger BH */
s1y, /**< Initial value of s1y: dimensionless spin of larger BH */
s1z, /**< Initial value of s1z: dimensionless spin of larger BH */
s2x, /**< Initial value of s2x: dimensionless spin of larger BH */
s2y, /**< Initial value of s2y: dimensionless spin of larger BH */
s2z); /**< Initial value of s2z: dimensionless spin of larger BH */
printf("chi_eff = %g\n", chi_eff);
printf("chip = %g\n", chip);
printf("eta = %g\n", eta);
printf("thetaJ = %g\n", thetaJ);
printf("phiJ = %g\n", phiJ);
int ret = XLALSimIMRPhenomP(
&hptilde, /**< Frequency-domain waveform h+ */
&hctilde, /**< Frequency-domain waveform hx */
chi_eff, /**< Effective aligned spin */
chip, /**< Effective spin in the orbital plane */
eta, /**< Symmetric mass-ratio */
thetaJ, /**< Angle between J0 and line of sight (z-direction) */
phiJ, /**< Angle of J0 in the plane of the sky */
m1_SI + m2_SI, /**< Total mass of binary (kg) */
distance, /**< Distance of source (m) */
alpha0, /**< Initial value of alpha angle */
phic, /**< Orbital coalescence phase (rad) */
deltaF, /**< Sampling frequency (Hz) */
f_min, /**< Starting GW frequency (Hz) */
f_max); /**< End frequency; 0 defaults to ringdown cutoff freq */
int wflen = hptilde->data->length;
REAL8 f_max_prime = 0;
FILE *out;
out = fopen("XLALSimIMRPhenomP.dat", "w");
for (int i=1;i<wflen;i++) {
REAL8 f = i*deltaF;
COMPLEX16 hp = (hptilde->data->data)[i];
COMPLEX16 hc = (hctilde->data->data)[i];
if (!(creal(hp) == 0 && cimag(hp) == 0 && creal(hc) == 0 && cimag(hc) == 0)) {
f_max_prime = (f > f_max_prime) ? f : f_max_prime;
fprintf(out, "%.15g\t%.15g\t%.15g\t%.15g\t%.15g\n", f*LAL_MTSUN_SI*M, creal(hp), cimag(hp), creal(hc), cimag(hc));
}
}
fclose(out);
printf("f_max_prime = %g\n", f_max_prime);
COMPLEX16FrequencySeries *htildePC = NULL;
ret = XLALSimIMRPhenomCGenerateFD(
&htildePC, /**< FD waveform */
phic, /**< orbital phase at peak (rad) */
deltaF, /**< sampling interval (Hz) */
m1_SI, /**< mass of companion 1 (kg) */
m2_SI, /**< mass of companion 2 (kg) */
chi, /**< mass-weighted aligned-spin parameter */
f_min, /**< starting GW frequency (Hz) */
f_max, /**< end frequency; 0 defaults to ringdown cutoff freq */
distance /**< distance of source (m) */
);
out = fopen("XLALSimIMRPhenomC.dat", "w");
wflen = hptilde->data->length;
for (int i=1;i<wflen;i++) {
REAL8 f = i*deltaF;
COMPLEX16 hp = (htildePC->data->data)[i];
if (!(creal(hp) == 0 && cimag(hp) == 0))
fprintf(out, "%.15g\t%.15g\t%.15g\n", f*LAL_MTSUN_SI*M, creal(hp), cimag(hp));
}
fclose(out);
// Now compute match between PhenomC and PhenomP for this aligned configuration
REAL8 match = MatchSI(&hptilde, &htildePC, f_min, f_max_prime, deltaF);
REAL8 match_expected = 0.999443;
const REAL8 eps = 1e-5;
assert(
approximatelyEqualC(match, match_expected, eps)
&& "Test_PhenomC_PhenomP()"
);
printf("match(PhenomP_aligned, PhenomC) = %g\n", match);
UNUSED(ret);
}
static void Test_XLALSimIMRPhenomPCalculateModelParameters(void) {
printf("\n** Test_XLALSimIMRPhenomPCalculateModelParameters: **\n");
REAL8 eta, chi_eff, chip, thetaJ, phiJ, alpha0;
REAL8 m1_SI = 10 * LAL_MSUN_SI;
REAL8 m2_SI = 40 * LAL_MSUN_SI;
REAL8 s1x = 0.3;
REAL8 s1y = 0;
REAL8 s1z = 0.45;
REAL8 s2x = 0;
REAL8 s2y = 0;
REAL8 s2z = 0.45;
REAL8 lnhatx = sin(0.4);
REAL8 lnhaty = 0;
REAL8 lnhatz = cos(0.4);
REAL8 f_min = 20;
XLALSimIMRPhenomPCalculateModelParameters(
&chi_eff, /**< Output: Effective aligned spin */
&chip, /**< Output: Effective spin in the orbital plane */
&eta, /**< Output: Symmetric mass-ratio */
&thetaJ, /**< Output: Angle between J0 and line of sight (z-direction) */
&phiJ, /**< Output: Angle of J0 in the plane of the sky */
&alpha0, /**< Output: Initial value of alpha angle */
m1_SI, /**< Mass of companion 1 (kg) */
m2_SI, /**< Mass of companion 2 (kg) */
f_min, /**< Starting GW frequency (Hz) */
lnhatx, /**< Initial value of LNhatx: orbital angular momentum unit vector */
lnhaty, /**< Initial value of LNhaty */
lnhatz, /**< Initial value of LNhatz */
s1x, /**< Initial value of s1x: dimensionless spin of larger BH */
s1y, /**< Initial value of s1y: dimensionless spin of larger BH */
s1z, /**< Initial value of s1z: dimensionless spin of larger BH */
s2x, /**< Initial value of s2x: dimensionless spin of larger BH */
s2y, /**< Initial value of s2y: dimensionless spin of larger BH */
s2z); /**< Initial value of s2z: dimensionless spin of larger BH */
REAL8 eta_expected = 0.16;
REAL8 chi_eff_expected = 0.437843;
REAL8 chip_expected = 0.175238;
REAL8 thetaJ_expected = 0.298553;
REAL8 phiJ_expected = 0;
REAL8 alpha0_expected = 0;
print_difference("eta", eta, eta_expected);
print_difference("chi_eff", chi_eff, chi_eff_expected);
print_difference("chip", chip, chip_expected);
print_difference("thetaJ", thetaJ, thetaJ_expected);
print_difference("phiJ", phiJ, phiJ_expected);
print_difference("alpha0", alpha0, alpha0_expected);
//const REAL8 eps = DBL_EPSILON;
const REAL8 eps = 1e-5;
assert(
approximatelyEqual(eta, eta_expected, eps)
&& approximatelyEqual(chi_eff, chi_eff_expected, eps)
&& approximatelyEqual(chip, chip_expected, eps)
&& approximatelyEqual(thetaJ, thetaJ_expected, eps)
&& approximatelyEqual(phiJ, phiJ_expected, eps)
&& approximatelyEqual(alpha0, alpha0_expected, eps)
&& "Test_XLALSimIMRPhenomPCalculateModelParameters()"
);
}
