Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALSimulation 6.2.0.1-5e288d3
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
LALSimInspiralWaveformParams.c
Go to the documentation of this file.
1#include <lal/LALStdio.h>
2#include <lal/LALDict.h>
3#include <lal/LALSimInspiral.h>
4#include <lal/LALSimInspiralWaveformFlags.h>
5#include <lal/LALSimInspiralWaveformParams.h>
6#include <math.h>
7#include <gsl/gsl_poly.h>
8#include "LALSimInspiralWaveformParams_common.c"
9
10/* Warning message for unreviewed code.
11 The XLAL warning messages are suppressed by default.
12 Here we temporarily change the lalDebugLevel to print the warning message and
13 inmediately afterwards we reset the lalDebugLevel to its original value.
14 In this way we avoid showing any other unwanted warning messages.
15*/
16#define UNREVIEWED_CODE_WARNING \
17 int debug_level = XLALGetDebugLevel(); \
18 XLALClobberDebugLevel(2); \
19 XLAL_PRINT_WARNING("This code is currently UNREVIEWED, use with caution!"); \
20 XLALClobberDebugLevel(debug_level);
21
22#if 1 /* generate definitions for source */
23
24#define DEFINE_INSERT_FUNC(NAME, TYPE, KEY, DEFAULT) \
25 int XLALSimInspiralWaveformParamsInsert ## NAME(LALDict *params, TYPE value) \
26 { \
27 return XLALDictInsert ## TYPE ## Value(params, KEY, value); \
28 }
29
30#define DEFINE_LOOKUP_FUNC(NAME, TYPE, KEY, DEFAULT) \
31 TYPE XLALSimInspiralWaveformParamsLookup ## NAME(LALDict *params) \
32 { \
33 TYPE value = DEFAULT; \
34 if (params && XLALDictContains(params, KEY)) \
35 value = XLALDictLookup ## TYPE ## Value(params, KEY); \
36 return value; \
37 }
38
39#define DEFINE_ISDEFAULT_FUNC(NAME, TYPE, KEY, DEFAULT) \
40 int XLALSimInspiralWaveformParams ## NAME ## IsDefault(LALDict *params) \
41 { \
42 return XLALSimInspiralWaveformParamsLookup ## NAME(params) == DEFAULT; \
43 }
44
45#else /* generate prototypes for header */
46
47#define DEFINE_INSERT_FUNC(NAME, TYPE, KEY, DEFAULT) \
48 int XLALSimInspiralWaveformParamsInsert ## NAME(LALDict *params, TYPE value);
49
50#define DEFINE_LOOKUP_FUNC(NAME, TYPE, KEY, DEFAULT) \
51 TYPE XLALSimInspiralWaveformParamsLookup ## NAME(LALDict *params);
52
53#define DEFINE_ISDEFAULT_FUNC(NAME, TYPE, KEY, DEFAULT) \
54 int XLALSimInspiralWaveformParams ## NAME ## IsDefault(LALDict *params);
55
56#endif
57
58/* "String" is function names becomes type "const char *" */
59#ifdef String
60#undef String
61#endif
62#define String const char *
63
64/*
65 * Note: missing one type of data for SpinTaylorF2:
66 * DEFINE_INSERT_FUNC(PNSideband, INT4, "sideband", 0)
67 */
68
69/* New Waveforms Interface */
70
71/** Check if the key belong to the know waveform params defined in LALSimInspiralWaveformParams_common.c */
72int XLALSimInspiralCheckKnownREAL8Key(const char* key){
73 size_t num_par = XLAL_NUM_ELEM(lalSimInspiralREAL8WaveformParams);
74 for(size_t i = 0; i < num_par; i++) {
75 if (strcmp(lalSimInspiralREAL8WaveformParams[i].name, key) == 0){
76 return 1;
77 }
78 }
79 return 0;
80}
81
82/**
83 * Check if the mass paramters inserted in the LALDict allow to determine the two mass components mass1, mass2.
84 * It accepts only two mass parameters and at least one must be dimensionful.
85 */
86int XLALSimInspiralCheckDeterminationOfMasses(LALDict *params){
87 UNREVIEWED_CODE_WARNING
88
89 UINT2 dim_number = 0; /* dimensionful-mass counter */
90 UINT2 nodim_number = 0; /* dimensionless-mass counter */
91 UINT2 sym_number = 0; /* symmetric masses counter */
92 const char *dimensionful_masses[6] = {"mass1", "mass2", "total_mass", \
93 "chirp_mass", "mass_difference", "reduced_mass"};
94 const char *dimensionless_masses[2] = {"mass_ratio", "sym_mass_ratio"};
95 const char *symetric_masses[6] = {"mass1", "mass2", "total_mass", "chirp_mass", "sym_mass_ratio", "reduced_mass"};
96
97 for (size_t j = 0; j < sizeof(dimensionful_masses)/sizeof(*dimensionful_masses); ++j){
98 if (XLALDictContains(params, dimensionful_masses[j]) == 1){
99 dim_number += 1;
100 }
101 }
102 for (size_t j = 0; j < sizeof(dimensionless_masses)/sizeof(*dimensionless_masses); ++j){
103 if (XLALDictContains(params, dimensionless_masses[j]) == 1){
104 nodim_number += 1;
105 }
106 }
107 for (size_t j = 0; j < sizeof(symetric_masses)/sizeof(*symetric_masses); ++j){
108 if (XLALDictContains(params, symetric_masses[j]) == 1){
109 sym_number += 1;
110 }
111 }
112 if(XLALDictContains(params, "mass1") && XLALDictContains(params, "mass2")){
113 sym_number = 0;
114 }
115
116 if ((dim_number == 2 && nodim_number == 0) || (dim_number == 1 && nodim_number == 1)){
117 if(sym_number == 2){
118 XLAL_PRINT_WARNING("The larger object cannot be determined, assuming m1 >= m2.");
119 }
120 return XLAL_SUCCESS;
121 }
122 else if ((dim_number == 1 && nodim_number == 0) || dim_number == 0){
123 XLAL_ERROR(XLAL_FAILURE, "Mass parameters are underspecified. Please include" \
124 " one dimensionless and one dimensionful mass parameters, or two dimensionful masses.");
125 }
126 else{
127 XLAL_ERROR(XLAL_FAILURE, "Mass parameters are overspecified. Please include" \
128 " one dimensionless and one dimensionful mass parameters, or two dimensionful masses.");
129 }
130}
131
132
133/* INSERT FUNCTIONS */
134DEFINE_INSERT_FUNC(Mass1, REAL8, "mass1", 0)
135DEFINE_INSERT_FUNC(Mass2, REAL8, "mass2", 0)
136DEFINE_INSERT_FUNC(TotalMass, REAL8, "total_mass", 0)
137DEFINE_INSERT_FUNC(MassRatio, REAL8, "mass_ratio", 0)
138DEFINE_INSERT_FUNC(SymMassRatio, REAL8, "sym_mass_ratio", 0)
139DEFINE_INSERT_FUNC(ChirpMass, REAL8, "chirp_mass", 0)
140DEFINE_INSERT_FUNC(MassDifference, REAL8, "mass_difference", 0)
141DEFINE_INSERT_FUNC(ReducedMass, REAL8, "reduced_mass", 0)
142DEFINE_INSERT_FUNC(Spin1x, REAL8, "spin1x", 0)
143DEFINE_INSERT_FUNC(Spin2x, REAL8, "spin2x", 0)
144DEFINE_INSERT_FUNC(Spin1y, REAL8, "spin1y", 0)
145DEFINE_INSERT_FUNC(Spin2y, REAL8, "spin2y", 0)
146DEFINE_INSERT_FUNC(Spin1z, REAL8, "spin1z", 0)
147DEFINE_INSERT_FUNC(Spin2z, REAL8, "spin2z", 0)
148DEFINE_INSERT_FUNC(Spin1norm, REAL8, "spin1_norm", 0)
149DEFINE_INSERT_FUNC(Spin2norm, REAL8, "spin2_norm", 0)
150DEFINE_INSERT_FUNC(Spin1tilt, REAL8, "spin1_tilt", 0)
151DEFINE_INSERT_FUNC(Spin2tilt, REAL8, "spin2_tilt", 0)
152DEFINE_INSERT_FUNC(Spin1phi, REAL8, "spin1_phi", 0)
153DEFINE_INSERT_FUNC(Spin2phi, REAL8, "spin2_phi", 0)
154DEFINE_INSERT_FUNC(DeltaF, REAL8, "deltaF", 0)
155DEFINE_INSERT_FUNC(DeltaT, REAL8, "deltaT", 0)
156DEFINE_INSERT_FUNC(F22Ref, REAL8, "f22_ref", 0)
157DEFINE_INSERT_FUNC(RefPhase, REAL8, "phi_ref", 0)
158DEFINE_INSERT_FUNC(F22Start, REAL8, "f22_start", 0)
159DEFINE_INSERT_FUNC(FMax, REAL8, "f_max", 0)
160DEFINE_INSERT_FUNC(Distance, REAL8, "distance", 0)
161DEFINE_INSERT_FUNC(Inclination, REAL8, "inclination", 0)
162DEFINE_INSERT_FUNC(LongAscNodes, REAL8, "longAscNodes", 0)
163DEFINE_INSERT_FUNC(Eccentricity, REAL8, "eccentricity", 0)
164DEFINE_INSERT_FUNC(MeanPerAno, REAL8, "meanPerAno", 0)
165
166DEFINE_INSERT_FUNC(Lmax, INT4, "lmax", 0)
167DEFINE_INSERT_FUNC(ModesChoice, INT4, "modes", LAL_SIM_INSPIRAL_MODES_CHOICE_ALL)
168DEFINE_INSERT_FUNC(FrameAxis, INT4, "axis", LAL_SIM_INSPIRAL_FRAME_AXIS_ORBITAL_L)
169DEFINE_INSERT_FUNC(Sideband, INT4, "sideband", 0)
170DEFINE_INSERT_FUNC(NumRelData, String, "numreldata", NULL)
171
172int XLALSimInspiralWaveformParamsInsertModeArray(LALDict *params, LALValue *value)
173{
174 return XLALDictInsertValue(params, "ModeArray", value);
175}
176
177int XLALSimInspiralWaveformParamsInsertModeArrayJframe(LALDict *params, LALValue *value)
178{
179 return XLALDictInsertValue(params, "ModeArrayJframe", value);
180}
181
182int XLALSimInspiralWaveformParamsInsertModeArrayFromModeString(LALDict *params, const char *modestr)
183{
184 UNREVIEWED_CODE_WARNING
185 LALValue *modes = XLALSimInspiralModeArrayFromModeString(modestr);
186 XLAL_CHECK(modes, XLAL_EFUNC);
187 return XLALSimInspiralWaveformParamsInsertModeArray(params, modes);
188}
189
190int XLALSimInspiralWaveformParamsInsertModeArrayJframeFromModeString(LALDict *params, const char *modestr)
191{
192 UNREVIEWED_CODE_WARNING
193 LALValue *modes = XLALSimInspiralModeArrayFromModeString(modestr);
194 XLAL_CHECK(modes, XLAL_EFUNC);
195 return XLALSimInspiralWaveformParamsInsertModeArrayJframe(params, modes);
196}
197
198DEFINE_INSERT_FUNC(PNPhaseOrder, INT4, "phaseO", -1)
199DEFINE_INSERT_FUNC(PNAmplitudeOrder, INT4, "ampO", -1)
200DEFINE_INSERT_FUNC(PNEccentricityOrder, INT4, "eccO", -1)
201DEFINE_INSERT_FUNC(PNSpinOrder, INT4, "spinO", -1)
202DEFINE_INSERT_FUNC(PNTidalOrder, INT4, "tideO", -1)
203DEFINE_INSERT_FUNC(GETides, INT4, "GEtideO", 0)
204DEFINE_INSERT_FUNC(GMTides, INT4, "GMtideO", 0)
205
206DEFINE_INSERT_FUNC(TidalLambda1, REAL8, "lambda1", 0)
207DEFINE_INSERT_FUNC(TidalLambda2, REAL8, "lambda2", 0)
208DEFINE_INSERT_FUNC(TidalOctupolarLambda1, REAL8, "TidalOctupolarLambda1", 0)
209DEFINE_INSERT_FUNC(TidalOctupolarLambda2, REAL8, "TidalOctupolarLambda2", 0)
210DEFINE_INSERT_FUNC(TidalHexadecapolarLambda1, REAL8, "TidalHexadecapolarLambda1", 0)
211DEFINE_INSERT_FUNC(TidalHexadecapolarLambda2, REAL8, "TidalHexadecapolarLambda2", 0)
212DEFINE_INSERT_FUNC(TidalQuadrupolarFMode1, REAL8, "TidalQuadrupolarFMode1", 0)
213DEFINE_INSERT_FUNC(TidalQuadrupolarFMode2, REAL8, "TidalQuadrupolarFMode2", 0)
214DEFINE_INSERT_FUNC(TidalOctupolarFMode1, REAL8, "TidalOctupolarFMode1", 0)
215DEFINE_INSERT_FUNC(TidalOctupolarFMode2, REAL8, "TidalOctupolarFMode2", 0)
216/* Note: some approximants like SEOBNRv2T/SEOBNRv4T will by default compute dQuadMon1, dQuadMon2 */
217/* from TidalLambda1, TidalLambda2 using universal relations, rather than using the default value 0 */
218DEFINE_INSERT_FUNC(dQuadMon1, REAL8, "dQuadMon1", 0)
219DEFINE_INSERT_FUNC(dQuadMon2, REAL8, "dQuadMon2", 0)
220DEFINE_INSERT_FUNC(Redshift, REAL8, "redshift", 0)
221DEFINE_INSERT_FUNC(EccentricityFreq, REAL8, "f_ecc", LAL_DEFAULT_F_ECC)
222DEFINE_INSERT_FUNC(Lscorr, INT4, "lscorr", 0)
223DEFINE_INSERT_FUNC(FinalFreq, REAL8, "fend", 0)
224DEFINE_INSERT_FUNC(OnlyFinal, INT4, "OnlyFinal", 0)
225
226DEFINE_INSERT_FUNC(NonGRPhi1, REAL8, "phi1", 0)
227DEFINE_INSERT_FUNC(NonGRPhi2, REAL8, "phi2", 0)
228DEFINE_INSERT_FUNC(NonGRPhi3, REAL8, "phi3", 0)
229DEFINE_INSERT_FUNC(NonGRPhi4, REAL8, "phi4", 0)
230DEFINE_INSERT_FUNC(NonGRDChiMinus2, REAL8, "dchiMinus2", 0)
231DEFINE_INSERT_FUNC(NonGRDChiMinus1, REAL8, "dchiMinus1", 0)
232DEFINE_INSERT_FUNC(NonGRDChi0, REAL8, "dchi0", 0)
233DEFINE_INSERT_FUNC(NonGRDChi1, REAL8, "dchi1", 0)
234DEFINE_INSERT_FUNC(NonGRDChi2, REAL8, "dchi2", 0)
235DEFINE_INSERT_FUNC(NonGRDChi3, REAL8, "dchi3", 0)
236DEFINE_INSERT_FUNC(NonGRDChi3S, REAL8, "dchi3S", 0)
237DEFINE_INSERT_FUNC(NonGRDChi3NS, REAL8, "dchi3NS", 0)
238DEFINE_INSERT_FUNC(NonGRDChi4, REAL8, "dchi4", 0)
239DEFINE_INSERT_FUNC(NonGRDChi4S, REAL8, "dchi4S", 0)
240DEFINE_INSERT_FUNC(NonGRDChi4NS, REAL8, "dchi4NS", 0)
241DEFINE_INSERT_FUNC(NonGRDChi5, REAL8, "dchi5", 0)
242DEFINE_INSERT_FUNC(NonGRDChi5S, REAL8, "dchi5S", 0)
243DEFINE_INSERT_FUNC(NonGRDChi5NS, REAL8, "dchi5NS", 0)
244DEFINE_INSERT_FUNC(NonGRDChi5L, REAL8, "dchi5l", 0)
245DEFINE_INSERT_FUNC(NonGRDChi5LS, REAL8, "dchi5lS", 0)
246DEFINE_INSERT_FUNC(NonGRDChi5LNS, REAL8, "dchi5lNS", 0)
247DEFINE_INSERT_FUNC(NonGRDChi6, REAL8, "dchi6", 0)
248DEFINE_INSERT_FUNC(NonGRDChi6S, REAL8, "dchi6S", 0)
249DEFINE_INSERT_FUNC(NonGRDChi6NS, REAL8, "dchi6NS", 0)
250DEFINE_INSERT_FUNC(NonGRDChi6L, REAL8, "dchi6l", 0)
251DEFINE_INSERT_FUNC(NonGRDChi7, REAL8, "dchi7", 0)
252DEFINE_INSERT_FUNC(NonGRDChi7S, REAL8, "dchi7S", 0)
253DEFINE_INSERT_FUNC(NonGRDChi7NS, REAL8, "dchi7NS", 0)
254DEFINE_INSERT_FUNC(NonGRDXi1, REAL8, "dxi1", 0)
255DEFINE_INSERT_FUNC(NonGRDXi2, REAL8, "dxi2", 0)
256DEFINE_INSERT_FUNC(NonGRDXi3, REAL8, "dxi3", 0)
257DEFINE_INSERT_FUNC(NonGRDXi4, REAL8, "dxi4", 0)
258DEFINE_INSERT_FUNC(NonGRDXi5, REAL8, "dxi5", 0)
259DEFINE_INSERT_FUNC(NonGRDXi6, REAL8, "dxi6", 0)
260DEFINE_INSERT_FUNC(NonGRDSigma1, REAL8, "dsigma1", 0)
261DEFINE_INSERT_FUNC(NonGRDSigma2, REAL8, "dsigma2", 0)
262DEFINE_INSERT_FUNC(NonGRDSigma3, REAL8, "dsigma3", 0)
263DEFINE_INSERT_FUNC(NonGRDSigma4, REAL8, "dsigma4", 0)
264DEFINE_INSERT_FUNC(NonGRDAlpha1, REAL8, "dalpha1", 0)
265DEFINE_INSERT_FUNC(NonGRDAlpha2, REAL8, "dalpha2", 0)
266DEFINE_INSERT_FUNC(NonGRDAlpha3, REAL8, "dalpha3", 0)
267DEFINE_INSERT_FUNC(NonGRDAlpha4, REAL8, "dalpha4", 0)
268DEFINE_INSERT_FUNC(NonGRDAlpha5, REAL8, "dalpha5", 0)
269DEFINE_INSERT_FUNC(NonGRDBeta1, REAL8, "dbeta1", 0)
270DEFINE_INSERT_FUNC(NonGRDBeta2, REAL8, "dbeta2", 0)
271DEFINE_INSERT_FUNC(NonGRDBeta3, REAL8, "dbeta3", 0)
272DEFINE_INSERT_FUNC(NonGRAlphaPPE, REAL8, "alphaPPE", 0)
273DEFINE_INSERT_FUNC(NonGRBetaPPE, REAL8, "betaPPE", 0)
274DEFINE_INSERT_FUNC(NonGRAlphaPPE0, REAL8, "alphaPPE0", 0)
275DEFINE_INSERT_FUNC(NonGRBetaPPE0, REAL8, "betaPPE0", 0)
276DEFINE_INSERT_FUNC(NonGRAlphaPPE1, REAL8, "alphaPPE1", 0)
277DEFINE_INSERT_FUNC(NonGRBetaPPE1, REAL8, "betaPPE1", 0)
278DEFINE_INSERT_FUNC(NonGRAlphaPPE2, REAL8, "alphaPPE2", 0)
279DEFINE_INSERT_FUNC(NonGRBetaPPE2, REAL8, "betaPPE2", 0)
280DEFINE_INSERT_FUNC(NonGRAlphaPPE3, REAL8, "alphaPPE3", 0)
281DEFINE_INSERT_FUNC(NonGRBetaPPE3, REAL8, "betaPPE3", 0)
282DEFINE_INSERT_FUNC(NonGRAlphaPPE4, REAL8, "alphaPPE4", 0)
283DEFINE_INSERT_FUNC(NonGRBetaPPE4, REAL8, "betaPPE4", 0)
284DEFINE_INSERT_FUNC(NonGRAlphaPPE5, REAL8, "alphaPPE5", 0)
285DEFINE_INSERT_FUNC(NonGRBetaPPE5, REAL8, "betaPPE5", 0)
286DEFINE_INSERT_FUNC(NonGRAlphaPPE6, REAL8, "alphaPPE6", 0)
287DEFINE_INSERT_FUNC(NonGRBetaPPE6, REAL8, "betaPPE6", 0)
288DEFINE_INSERT_FUNC(NonGRAlphaPPE7, REAL8, "alphaPPE7", 0)
289DEFINE_INSERT_FUNC(NonGRBetaPPE7, REAL8, "betaPPE7", 0)
290DEFINE_INSERT_FUNC(EnableLIV, INT4, "liv", 0)
291DEFINE_INSERT_FUNC(NonGRLIVLogLambdaEff, REAL8, "log10lambda_eff", 100)
292DEFINE_INSERT_FUNC(NonGRLIVASign, REAL8, "LIV_A_sign", 1)
293DEFINE_INSERT_FUNC(NonGRLIVAlpha, REAL8, "nonGR_alpha", 0)
294DEFINE_INSERT_FUNC(NonGRDChikappaS, REAL8, "dchikappaS", 0)
295DEFINE_INSERT_FUNC(NonGRDChikappaA, REAL8, "dchikappaA", 0)
296
297/* PhenomXPHM TGR Coefficients */
298DEFINE_INSERT_FUNC(NonGRDC1, REAL8, "nongr_dc1", 0)
299DEFINE_INSERT_FUNC(NonGRDC2, REAL8, "nongr_dc2", 0)
300DEFINE_INSERT_FUNC(NonGRDC4, REAL8, "nongr_dc4", 0)
301DEFINE_INSERT_FUNC(NonGRDCL, REAL8, "nongr_dcl", 0)
302DEFINE_INSERT_FUNC(NonGRDB1, REAL8, "nongr_db1", 0)
303DEFINE_INSERT_FUNC(NonGRDB2, REAL8, "nongr_db2", 0)
304DEFINE_INSERT_FUNC(NonGRDB3, REAL8, "nongr_db3", 0)
305DEFINE_INSERT_FUNC(NonGRDB4, REAL8, "nongr_db4", 0)
306DEFINE_INSERT_FUNC(NonGRParameterization, INT4, "tgr_parameterization", 0)
307
308
309/* NLTides parameters */
310/* used within LALSimInspiralTaylorF2NLTides.c */
311DEFINE_INSERT_FUNC(NLTidesA1, REAL8, "nlTidesA1", 0)
312DEFINE_INSERT_FUNC(NLTidesN1, REAL8, "nlTidesN1", 0)
313DEFINE_INSERT_FUNC(NLTidesF1, REAL8, "nlTidesF1", 0)
314DEFINE_INSERT_FUNC(NLTidesA2, REAL8, "nlTidesA2", 0)
315DEFINE_INSERT_FUNC(NLTidesN2, REAL8, "nlTidesN2", 0)
316DEFINE_INSERT_FUNC(NLTidesF2, REAL8, "nlTidesF2", 0)
317DEFINE_INSERT_FUNC(DOmega220, REAL8, "domega220", 0)
318DEFINE_INSERT_FUNC(DTau220, REAL8, "dtau220", 0)
319DEFINE_INSERT_FUNC(DOmega210, REAL8, "domega210", 0)
320DEFINE_INSERT_FUNC(DTau210, REAL8, "dtau210", 0)
321DEFINE_INSERT_FUNC(DOmega330, REAL8, "domega330", 0)
322DEFINE_INSERT_FUNC(DTau330, REAL8, "dtau330", 0)
323DEFINE_INSERT_FUNC(DOmega440, REAL8, "domega440", 0)
324DEFINE_INSERT_FUNC(DTau440, REAL8, "dtau440", 0)
325DEFINE_INSERT_FUNC(DOmega550, REAL8, "domega550", 0)
326DEFINE_INSERT_FUNC(DTau550, REAL8, "dtau550", 0)
327
328/* SEOBNRv4P */
329DEFINE_INSERT_FUNC(EOBChooseNumOrAnalHamDer, INT4, "EOBChooseNumOrAnalHamDer", 1)
330DEFINE_INSERT_FUNC(EOBEllMaxForNyquistCheck, INT4, "EOBEllMaxForNyquistCheck", 5)
331
332
333/* IMRPhenomX Parameters */
334DEFINE_INSERT_FUNC(PhenomXInspiralPhaseVersion, INT4, "InsPhaseVersion", 104)
335DEFINE_INSERT_FUNC(PhenomXInspiralAmpVersion, INT4, "InsAmpVersion", 103)
336DEFINE_INSERT_FUNC(PhenomXIntermediatePhaseVersion, INT4, "IntPhaseVersion", 105)
337DEFINE_INSERT_FUNC(PhenomXIntermediateAmpVersion, INT4, "IntAmpVersion", 104)
338DEFINE_INSERT_FUNC(PhenomXRingdownPhaseVersion, INT4, "RDPhaseVersion", 105)
339DEFINE_INSERT_FUNC(PhenomXRingdownAmpVersion, INT4, "RDAmpVersion", 103)
340DEFINE_INSERT_FUNC(PhenomXPrecVersion, INT4, "PrecVersion", 300)
341DEFINE_INSERT_FUNC(PhenomXReturnCoPrec, INT4, "ReturnCoPrec", 0)
342DEFINE_INSERT_FUNC(PhenomXPExpansionOrder, INT4, "ExpansionOrder", 5)
343DEFINE_INSERT_FUNC(PhenomXPConvention, INT4, "Convention", 1)
344DEFINE_INSERT_FUNC(PhenomXPFinalSpinMod, INT4, "FinalSpinMod", 4)
345DEFINE_INSERT_FUNC(PhenomXPTransPrecessionMethod, INT4, "TransPrecessionMethod", 1)
346DEFINE_INSERT_FUNC(PhenomXPSpinTaylorVersion, String, "SpinTaylorVersion", NULL)
347DEFINE_INSERT_FUNC(PhenomXPSpinTaylorCoarseFactor, INT4, "SpinTaylorCoarseFactor",10);
348
349/* IMRPhenomXAS_NRTidalvX */
350DEFINE_INSERT_FUNC(PhenomXTidalFlag, INT4, "PhenXTidal", 0)
351
352/* IMRPhenomXHM Parameters */
353DEFINE_INSERT_FUNC(PhenomXHMReleaseVersion, INT4, "PhenomXHMReleaseVersion", 122022)
354DEFINE_INSERT_FUNC(PhenomXHMInspiralPhaseVersion, INT4, "InsPhaseHMVersion", 122019)
355DEFINE_INSERT_FUNC(PhenomXHMIntermediatePhaseVersion, INT4, "IntPhaseHMVersion", 122019)
356DEFINE_INSERT_FUNC(PhenomXHMRingdownPhaseVersion, INT4, "RDPhaseHMVersion", 122019)
357DEFINE_INSERT_FUNC(PhenomXHMInspiralAmpVersion, INT4, "InsAmpHMVersion", 3)
358DEFINE_INSERT_FUNC(PhenomXHMIntermediateAmpVersion, INT4, "IntAmpHMVersion", 2)
359DEFINE_INSERT_FUNC(PhenomXHMRingdownAmpVersion, INT4, "RDAmpHMVersion", 0)
360DEFINE_INSERT_FUNC(PhenomXHMInspiralAmpFitsVersion, INT4, "InsAmpFitsVersion", 122018)
361DEFINE_INSERT_FUNC(PhenomXHMIntermediateAmpFitsVersion, INT4, "IntAmpFitsVersion", 122018)
362DEFINE_INSERT_FUNC(PhenomXHMRingdownAmpFitsVersion, INT4, "RDAmpFitsVersion", 122018)
363DEFINE_INSERT_FUNC(PhenomXHMInspiralAmpFreqsVersion, INT4, "InsAmpFreqsVersion", 122018)
364DEFINE_INSERT_FUNC(PhenomXHMIntermediateAmpFreqsVersion, INT4, "IntAmpFreqsVersion", 122018)
365DEFINE_INSERT_FUNC(PhenomXHMRingdownAmpFreqsVersion, INT4, "RDAmpFreqsVersion", 122018)
366DEFINE_INSERT_FUNC(PhenomXHMPhaseRef21, REAL8, "PhaseRef21", 0.)
367DEFINE_INSERT_FUNC(PhenomXHMThresholdMband, REAL8, "ThresholdMband", 0.001)
368DEFINE_INSERT_FUNC(PhenomXHMAmpInterpolMB, INT4, "AmpInterpol", 1)
369
370/* IMRPhenomXPHM Parameters */
371DEFINE_INSERT_FUNC(PhenomXPHMMBandVersion, INT4, "MBandPrecVersion", 0)
372DEFINE_INSERT_FUNC(PhenomXPHMThresholdMband, REAL8, "PrecThresholdMband", 0.001)
373DEFINE_INSERT_FUNC(PhenomXPHMUseModes, INT4, "UseModes", 0)
374DEFINE_INSERT_FUNC(PhenomXPHMModesL0Frame, INT4, "ModesL0Frame", 0)
375DEFINE_INSERT_FUNC(PhenomXPHMPrecModes, INT4, "PrecModes", 0)
376DEFINE_INSERT_FUNC(PhenomXPHMTwistPhenomHM, INT4, "TwistPhenomHM", 0)
377
378/* IMRPhenomTHM Parameters */
379DEFINE_INSERT_FUNC(PhenomTHMInspiralVersion, INT4, "InspiralVersion", 0)
380DEFINE_INSERT_FUNC(PhenomTPHMMergerVersion, INT4, "MergerVersion", 1)
381
382/* IMRPhenomX_PNR Parameters */
383DEFINE_INSERT_FUNC(PhenomXPNRUseTunedAngles, INT4, "PNRUseTunedAngles", 0)
384DEFINE_INSERT_FUNC(PhenomXPNRUseTunedCoprec, INT4, "PNRUseTunedCoprec", 0)
385DEFINE_INSERT_FUNC(PhenomXPNRUseTunedCoprec33, INT4, "PNRUseTunedCoprec33", 0)
386// Option to only be used when actively tuning PNR Coprec relative to XHM wherein the non-precessing final spin is used
387DEFINE_INSERT_FUNC(PhenomXPNRUseInputCoprecDeviations, INT4, "PNRUseInputCoprecDeviations", 0)
388// Dev option for forcing 22 phase derivative inspiral values to align with XHM at a low ref frequency
389DEFINE_INSERT_FUNC(PhenomXPNRForceXHMAlignment, INT4, "PNRForceXHMAlignment", 0)
390/* Toggle output of XAS phase for debugging purposes */
391DEFINE_INSERT_FUNC(PhenomXOnlyReturnPhase, INT4, "PhenomXOnlyReturnPhase", 0)
392DEFINE_INSERT_FUNC(PhenomXPNRInterpTolerance, REAL8, "PNRInterpTolerance", 0.01)
393/* IMRPhenomX_PNR_Asymmetry Parameters */
394DEFINE_INSERT_FUNC(PhenomXAntisymmetricWaveform, INT4, "AntisymmetricWaveform", 0)
395
396
397/* IMRPhenomXCP Parameters */
398DEFINE_INSERT_FUNC(PhenomXCPMU1, REAL8, "MU1", 0)
399DEFINE_INSERT_FUNC(PhenomXCPMU2, REAL8, "MU2", 0)
400DEFINE_INSERT_FUNC(PhenomXCPMU3, REAL8, "MU3", 0)
401DEFINE_INSERT_FUNC(PhenomXCPMU4, REAL8, "MU4", 0)
402DEFINE_INSERT_FUNC(PhenomXCPNU0, REAL8, "NU0", 0)
403DEFINE_INSERT_FUNC(PhenomXCPNU4, REAL8, "NU4", 0)
404DEFINE_INSERT_FUNC(PhenomXCPNU5, REAL8, "NU5", 0)
405DEFINE_INSERT_FUNC(PhenomXCPNU6, REAL8, "NU6", 0)
406DEFINE_INSERT_FUNC(PhenomXCPZETA1, REAL8, "ZETA1", 0)
407DEFINE_INSERT_FUNC(PhenomXCPZETA2, REAL8, "ZETA2", 0)
408/* l=3, m=3 */
409DEFINE_INSERT_FUNC(PhenomXCPMU1l3m3, REAL8, "MU1l3m3", 0)
410DEFINE_INSERT_FUNC(PhenomXCPMU2l3m3, REAL8, "MU2l3m3", 0)
411DEFINE_INSERT_FUNC(PhenomXCPMU3l3m3, REAL8, "MU3l3m3", 0)
412DEFINE_INSERT_FUNC(PhenomXCPMU4l3m3, REAL8, "MU4l3m3", 0)
413DEFINE_INSERT_FUNC(PhenomXCPNU0l3m3, REAL8, "NU0l3m3", 0)
414DEFINE_INSERT_FUNC(PhenomXCPNU4l3m3, REAL8, "NU4l3m3", 0)
415DEFINE_INSERT_FUNC(PhenomXCPNU5l3m3, REAL8, "NU5l3m3", 0)
416DEFINE_INSERT_FUNC(PhenomXCPNU6l3m3, REAL8, "NU6l3m3", 0)
417DEFINE_INSERT_FUNC(PhenomXCPZETA1l3m3, REAL8, "ZETA1l3m3", 0)
418DEFINE_INSERT_FUNC(PhenomXCPZETA2l3m3, REAL8, "ZETA2l3m3", 0)
419
420
421/* FLEXIBLE INPUT PARAMETERS FUNCTIONS */
422
423/* Auxiliar mass arguments transformation functions */
424
425REAL8 XLALSimInspiralGetMassRatioFromSymMassRatio(REAL8 sym_mass_ratio){
426 UNREVIEWED_CODE_WARNING
427
428 REAL8 mass_ratio;
429 REAL8 x;
430
431 if (sym_mass_ratio <= 0.25){
432 x = 1.0 - 4.0 * sym_mass_ratio;
433 mass_ratio = 0.5 * (1. - pow(x, 0.5)) / sym_mass_ratio - 1.0;
434 }
435 else{
436 XLAL_ERROR(XLAL_EINVAL, "Invalid value of symmetric mass ratio given");
437 }
438 return mass_ratio;
439}
440
441REAL8 XLALSimInspiralGetMassRatioFromChirpMassComponentMass2(REAL8 chirp_mass, REAL8 component_mass){
442 UNREVIEWED_CODE_WARNING
443 return 1./XLALSimInspiralGetMassRatioFromChirpMassComponentMass1(chirp_mass, component_mass);
444}
445
446REAL8 XLALSimInspiralGetMassRatioFromChirpMassComponentMass1(REAL8 chirp_mass, REAL8 component_mass){
447 UNREVIEWED_CODE_WARNING
448 REAL8 c;
449 REAL8 x;
450 REAL8 mass_ratio;
451
452 c = pow((chirp_mass / component_mass), 5);
453 x = 1.5 * pow((3.0/c), 0.5); // Implement trigonometric and hyperbolic solutions of cubic equation
454 if (x < 1.0){
455 mass_ratio = 3.0 * cos(acos(x) / 3.0) / x;
456 }
457 else{
458 mass_ratio = 3.0 * cosh(acosh(x) / 3.0) / x;
459 }
460 return mass_ratio;
461}
462
463/* MASS parameters LOOKUP functions */
464
465/**
466 * Compute mass1 from any possible combination of 2 mass parameters inserted in the LALDict.
467 * If the combination does not allow to distinguish the largest object then it assumes m1 > m2.
468 * mass_ratio is defined as q = m2/m1 and mass_difference as m1 - m2.
469 */
470REAL8 XLALSimInspiralWaveformParamsLookupMass1(LALDict *params){
471
472 REAL8 mass1 = 0;
473 REAL8 mass2;
474 REAL8 total_mass;
475 REAL8 mass_ratio;
476 REAL8 sym_mass_ratio;
477 REAL8 mass_difference;
478 REAL8 chirp_mass;
479 REAL8 reduced_mass;
480 REAL8 x;
481
482
483 if (XLALDictContains(params, "mass1") == 1){
484 mass1 = XLALDictLookupREAL8Value(params, "mass1");
485 XLAL_CHECK(mass1 > 0, XLAL_EDOM, "mass1 must be positive");
486 return mass1;
487 }
488
489 UNREVIEWED_CODE_WARNING
490
491 INT4 status = XLALSimInspiralCheckDeterminationOfMasses(params);
492 XLAL_CHECK(status==XLAL_SUCCESS, status, "Mass1 cannot be determined");
493
494 if (XLALDictContains(params, "mass2") == 1){
495 mass2 = XLALDictLookupREAL8Value(params, "mass2");
496 XLAL_CHECK(mass2 > 0, XLAL_EDOM, "mass2 must be positive");
497 if (XLALDictContains(params, "mass_ratio") == 1){
498 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
499 mass1 = mass2 / mass_ratio;
500 }
501 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
502 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
503 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
504 mass1 = mass2 / mass_ratio;
505 }
506 else if (XLALDictContains(params, "mass_difference") == 1){
507 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
508 mass1 = mass2 + mass_difference;
509 }
510 else if (XLALDictContains(params, "total_mass") == 1){
511 total_mass = XLALSimInspiralWaveformParamsLookupTotalMass(params);
512 mass1 = total_mass - mass2;
513 }
514 else if (XLALDictContains(params, "reduced_mass") == 1){
515 reduced_mass = XLALSimInspiralWaveformParamsLookupReducedMass(params);
516 mass1 = reduced_mass * mass2 / (mass2 - reduced_mass);
517 }
518 else if (XLALDictContains(params, "chirp_mass") == 1){
519 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
520 mass_ratio = XLALSimInspiralGetMassRatioFromChirpMassComponentMass2(chirp_mass, mass2);
521 mass1 = mass2 / mass_ratio;
522 }
523 }
524 else if (XLALDictContains(params, "total_mass") == 1){
525 total_mass = XLALSimInspiralWaveformParamsLookupTotalMass(params);
526 if (XLALDictContains(params, "mass_ratio") == 1){
527 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
528 mass1 = total_mass / (1. + mass_ratio);
529 }
530 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
531 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
532 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
533 mass1 = total_mass / (1. + mass_ratio);
534 }
535 else if (XLALDictContains(params, "mass_difference") == 1){
536 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
537 mass1 = 0.5 * (total_mass + mass_difference);
538 }
539 else if (XLALDictContains(params, "reduced_mass") == 1){
540 reduced_mass = XLALSimInspiralWaveformParamsLookupReducedMass(params);
541 if (total_mass < 4.0 * reduced_mass){
542 XLAL_ERROR(XLAL_EINVAL, "Invalid combination of total mass and reduced mass given");
543 }
544 x = total_mass * (total_mass - 4.0 * reduced_mass);
545 mass_difference = pow(x, 0.5);
546 mass1 = total_mass - 0.5 * (total_mass - mass_difference);
547 }
548 else if (XLALDictContains(params, "chirp_mass") == 1){
549 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
550 sym_mass_ratio = pow((chirp_mass / total_mass), 5.0/3.0);
551 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
552 mass1 = total_mass / (1.0 + mass_ratio);
553 }
554 }
555 else if (XLALDictContains(params, "reduced_mass") == 1){
556 reduced_mass = XLALSimInspiralWaveformParamsLookupReducedMass(params);
557 if (XLALDictContains(params, "mass_ratio") == 1){
558 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
559 mass1 = (1. + mass_ratio) * reduced_mass / mass_ratio;
560 }
561 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
562 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
563 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
564 mass1 = (1. + mass_ratio) * reduced_mass / mass_ratio;
565 }
566 else if (XLALDictContains(params, "mass_difference") == 1){
567 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
568 x = 4.0 * pow(reduced_mass,2) + pow(mass_difference,2);
569 mass1 = reduced_mass + 0.5 * mass_difference + 0.5 * pow(x, 0.5);
570 }
571 else if (XLALDictContains(params, "chirp_mass") == 1){
572 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
573 total_mass = pow(pow(chirp_mass, 5) / pow(reduced_mass, 3), 0.5);
574 x = total_mass * (total_mass - 4.0 * reduced_mass);
575 if (x >= 0){
576 mass_difference = pow(x, 0.5);
577 mass1 = total_mass - 0.5 * (total_mass - mass_difference);
578 }
579 else {
580 XLAL_ERROR(XLAL_FAILURE, "Invalid combination of reduced mass and chirp mass given");
581 }
582 }
583 }
584 else if (XLALDictContains(params, "mass_difference") == 1){
585 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
586 XLAL_CHECK(fabs(mass_difference) > 0, XLAL_EDOM, "Mass difference cannot be zero if it is combined with a dimensionless mass parameter.");
587 if (XLALDictContains(params, "mass_ratio") == 1){
588 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
589 mass1 = mass_difference / (1.0 - mass_ratio);
590 XLAL_CHECK(mass1 > 0, XLAL_EDOM, "Inconsistent values of mass_difference and mass_ratio.");
591 }
592 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
593 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
594 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
595 if (mass_difference < 0){
596 mass_ratio = 1./mass_ratio;
597 }
598 mass1 = mass_difference / (1.0 - mass_ratio);
599 }
600 else if (XLALDictContains(params, "chirp_mass") == 1){
601 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
602 /* We will solve the equation
603 * m2^6 + 3 mdiff m2^5 + 3 mdiff^2 m2^4 + mdiff^3 m2^3 - 2 chirpmass^5 m2 - mdiff chripmass^5 = 0
604 * which is obtained by substituting m1 = mdiff + m2 into the chirpmass formula.
605 * There will be 6 possible solutions that can be complex. We need to pick those that are real and positive, and then the one that also gives m1 positive.
606 */
607 double chirp_mass_5 = pow(chirp_mass, 5);
608 double coefficients[7] = { -mass_difference * chirp_mass_5, -2 * chirp_mass_5, 0, pow(mass_difference, 3), 3 * pow(mass_difference, 2), 3 * mass_difference, 1 };
609 double complex m2[6];
610
611 gsl_poly_complex_workspace * w = gsl_poly_complex_workspace_alloc(7);
612 gsl_poly_complex_solve(coefficients, 7, w, (double *)m2);
613 gsl_poly_complex_workspace_free(w);
614
615 // Pick real and positive solution
616 for (UINT2 i = 0; i < 6; i++)
617 {
618 if(cimag(m2[i]) == 0 && creal(m2[i])>0){
619 mass1 = creal(m2[i]) + mass_difference;
620 if (mass1 > 0) break;
621 }
622 }
623 XLAL_CHECK(mass1>0, XLAL_FAILURE, "Could not find solution for mass1\n");
624 }
625 }
626 else if (XLALDictContains(params, "chirp_mass") == 1){
627 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
628 if (XLALDictContains(params, "mass_ratio") == 1){
629 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
630 sym_mass_ratio = mass_ratio / pow((1.0 + mass_ratio), 2);
631 total_mass = chirp_mass / pow(sym_mass_ratio, 3.0/5.0);
632 mass1 = total_mass / (1.0 + mass_ratio);
633 }
634 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
635 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
636 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
637 total_mass = chirp_mass / pow(sym_mass_ratio, 3.0/5.0);
638 mass1 = total_mass / (1.0 + mass_ratio);
639 }
640 }
641
642 return mass1;
643
644}
645
646/**
647 * Compute mass2 from any possible combination of 2 mass parameters inserted in the LALDict.
648 * If the combination does not allow to distinguish the largest object then it assumes m1 > m2.
649 * mass_ratio is defined as q = m2/m1 and mass_difference as m1 - m2.
650 */
651REAL8 XLALSimInspiralWaveformParamsLookupMass2(LALDict *params){
652
653 REAL8 mass2 = 0;
654 REAL8 mass1;
655 REAL8 total_mass;
656 REAL8 mass_ratio;
657 REAL8 sym_mass_ratio;
658 REAL8 mass_difference;
659 REAL8 chirp_mass;
660 REAL8 reduced_mass;
661 REAL8 x;
662
663 if (XLALDictContains(params, "mass2") == 1){
664 mass2 = XLALDictLookupREAL8Value(params, "mass2");
665 return mass2;
666 }
667
668 UNREVIEWED_CODE_WARNING
669
670 INT4 status = XLALSimInspiralCheckDeterminationOfMasses(params);
671 XLAL_CHECK(status==XLAL_SUCCESS, status, "Mass2 cannot be determined");
672
673 if (XLALDictContains(params, "mass1") == 1){
674 mass1 = XLALDictLookupREAL8Value(params, "mass1");
675 if (XLALDictContains(params, "mass_ratio") == 1){
676 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
677 mass2 = mass1 * mass_ratio;
678 }
679 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
680 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
681 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
682 mass2 = mass1 * mass_ratio;
683 }
684 else if (XLALDictContains(params, "mass_difference") == 1){
685 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
686 mass2 = mass1 - mass_difference;
687 }
688 else if (XLALDictContains(params, "total_mass") == 1){
689 total_mass = XLALSimInspiralWaveformParamsLookupTotalMass(params);
690 mass2 = total_mass - mass1;
691 }
692 else if (XLALDictContains(params, "reduced_mass") == 1){
693 reduced_mass = XLALSimInspiralWaveformParamsLookupReducedMass(params);
694 mass2 = reduced_mass * mass1 / (mass1 - reduced_mass);
695 }
696 else if (XLALDictContains(params, "chirp_mass") == 1){
697 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
698 mass_ratio = XLALSimInspiralGetMassRatioFromChirpMassComponentMass1(chirp_mass, mass1);
699 mass2 = mass1 * mass_ratio;
700 }
701 }
702
703 else if (XLALDictContains(params, "total_mass") == 1){
704 total_mass = XLALSimInspiralWaveformParamsLookupTotalMass(params);
705 if (XLALDictContains(params, "mass_ratio") == 1){
706 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
707 mass2 = total_mass / (1. + mass_ratio) * mass_ratio;
708 }
709 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
710 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
711 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
712 mass2 = total_mass / (1. + mass_ratio) * mass_ratio;
713 }
714 else if (XLALDictContains(params, "mass_difference") == 1){
715 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
716 mass2 = 0.5 * (total_mass - mass_difference);
717 }
718 else if (XLALDictContains(params, "reduced_mass") == 1){
719 reduced_mass = XLALSimInspiralWaveformParamsLookupReducedMass(params);
720 if (total_mass < 4.0 * reduced_mass){
721 XLAL_ERROR(XLAL_EINVAL, "Invalid combination of total mass and reduced mass given");
722 }
723 x = total_mass * (total_mass - 4.0 * reduced_mass);
724 mass_difference = pow(x, 0.5);
725 mass2 = 0.5 * (total_mass - mass_difference);
726 }
727 else if (XLALDictContains(params, "chirp_mass") == 1){
728 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
729 sym_mass_ratio = pow((chirp_mass / total_mass), 5.0/3.0);
730 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
731 mass2 = total_mass / (1.0 + mass_ratio) * mass_ratio;
732 }
733 }
734
735 else if (XLALDictContains(params, "reduced_mass") == 1){
736 reduced_mass = XLALSimInspiralWaveformParamsLookupReducedMass(params);
737 if (XLALDictContains(params, "mass_ratio") == 1){
738 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
739 mass2 = (1. + mass_ratio) * reduced_mass;
740 }
741 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
742 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
743 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
744 mass2 = (1. + mass_ratio) * reduced_mass;
745 }
746 else if (XLALDictContains(params, "mass_difference") == 1){
747 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
748 x = 4.0 * pow(reduced_mass,2) + pow(mass_difference,2);
749 mass2 = reduced_mass + 0.5 * mass_difference + 0.5 * pow(x, 0.5) - mass_difference;
750 }
751 else if (XLALDictContains(params, "chirp_mass") == 1){
752 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
753 total_mass = pow(pow(chirp_mass, 5) / pow(reduced_mass, 3), 0.5);
754 x = total_mass * (total_mass - 4.0 * reduced_mass);
755 if (x >= 0){
756 mass_difference = pow(x, 0.5);
757 mass2 = 0.5 * (total_mass - mass_difference);
758 }
759 else {
760 XLAL_ERROR(XLAL_FAILURE, "Invalid combination of reduced mass and chirp mass given");
761 }
762 }
763 }
764
765 else if (XLALDictContains(params, "mass_difference") == 1){
766 mass_difference = XLALSimInspiralWaveformParamsLookupMassDifference(params);
767 XLAL_CHECK(fabs(mass_difference) > 0, XLAL_EDOM, "Mass difference cannot be zero if it is combined with a dimensionless mass parameter.");
768 if (XLALDictContains(params, "mass_ratio") == 1){
769 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
770 mass2 = mass_difference / (1.0 - mass_ratio) * mass_ratio;
771 XLAL_CHECK(mass2 > 0, XLAL_EDOM, "Inconsistent values of mass_difference and mass_ratio.");
772 }
773 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
774 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
775 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
776 if (mass_difference < 0){
777 mass_ratio = 1./mass_ratio;
778 }
779 mass2 = mass_ratio * mass_difference / (1.0 - mass_ratio);
780 }
781 else if (XLALDictContains(params, "chirp_mass") == 1){
782 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
783 /* We will solve the equation
784 * m2^6 + 3 mdiff m2^5 + 3 mdiff^2 m2^4 + mdiff^3 m2^3 - 2 chirpmass^5 m2 - mdiff chripmass^5 = 0
785 * which is obtained by substituting m1 = mdiff + m2 into the chirpmass formula.
786 * There will be 6 possible solutions that can be complex. We need to pick those that are real and positive, and then the one that also gives m1 positive.
787 */
788 double chirp_mass_5 = pow(chirp_mass, 5);
789 double coefficients[7] = { -mass_difference * chirp_mass_5, -2 * chirp_mass_5, 0, pow(mass_difference, 3), 3 * pow(mass_difference, 2), 3 * mass_difference, 1 };
790 double complex m2[6];
791
792 gsl_poly_complex_workspace * w = gsl_poly_complex_workspace_alloc(7);
793 gsl_poly_complex_solve(coefficients, 7, w, (double *)m2);
794 gsl_poly_complex_workspace_free(w);
795
796 // Pick real and positive solution
797 for (UINT2 i = 0; i < 6; i++)
798 {
799 if(cimag(m2[i]) == 0 && creal(m2[i])>0){
800 mass1 = creal(m2[i]) + mass_difference;
801 if (mass1 > 0){
802 mass2 = creal(m2[i]);
803 break;
804 }
805 }
806 }
807 XLAL_CHECK(mass2 > 0, XLAL_FAILURE, "Could not find solution for mass2\n");
808 }
809 }
810 else if (XLALDictContains(params, "chirp_mass") == 1){
811 chirp_mass = XLALSimInspiralWaveformParamsLookupChirpMass(params);
812 if (XLALDictContains(params, "mass_ratio") == 1){
813 mass_ratio = XLALSimInspiralWaveformParamsLookupMassRatio(params);
814 sym_mass_ratio = mass_ratio / pow((1.0 + mass_ratio), 2);
815 total_mass = chirp_mass / pow(sym_mass_ratio, 3.0/5.0);
816 mass2 = total_mass / (1.0 + mass_ratio) * mass_ratio;
817 }
818 else if (XLALDictContains(params, "sym_mass_ratio") == 1){
819 sym_mass_ratio = XLALSimInspiralWaveformParamsLookupSymMassRatio(params);
820 mass_ratio = XLALSimInspiralGetMassRatioFromSymMassRatio(sym_mass_ratio);
821 total_mass = chirp_mass / pow(sym_mass_ratio, 3.0/5.0);
822 mass2 = total_mass / (1.0 + mass_ratio) * mass_ratio;
823 }
824 }
825
826 return mass2;
827
828}
829
830
831REAL8 XLALSimInspiralWaveformParamsLookupTotalMass(LALDict *params){
832 UNREVIEWED_CODE_WARNING
833 REAL8 mass1;
834 REAL8 mass2;
835 REAL8 total_mass;
836
837 if (XLALDictContains(params, "total_mass") == 1){
838 total_mass = XLALDictLookupREAL8Value(params, "total_mass");
839 XLAL_CHECK(total_mass > 0, XLAL_EDOM, "total_mass must be positive");
840 }
841 else {
842 mass1 = XLALSimInspiralWaveformParamsLookupMass1(params);
843 mass2 = XLALSimInspiralWaveformParamsLookupMass2(params);
844 total_mass = mass1 + mass2;
845 }
846 return total_mass;
847}
848
849REAL8 XLALSimInspiralWaveformParamsLookupMassRatio(LALDict *params){
850 UNREVIEWED_CODE_WARNING
851 REAL8 mass1;
852 REAL8 mass2;
853 REAL8 mass_ratio;
854
855 if (XLALDictContains(params, "mass_ratio") == 1){
856 mass_ratio = XLALDictLookupREAL8Value(params, "mass_ratio");
857 XLAL_CHECK(mass_ratio > 0, XLAL_EDOM, "mass_ratio must be positive");
858 }
859 else {
860 mass1 = XLALSimInspiralWaveformParamsLookupMass1(params);
861 mass2 = XLALSimInspiralWaveformParamsLookupMass2(params);
862 mass_ratio = mass2 / mass1;
863 }
864 return mass_ratio;
865}
866
867REAL8 XLALSimInspiralWaveformParamsLookupSymMassRatio(LALDict *params){
868 UNREVIEWED_CODE_WARNING
869 REAL8 mass1;
870 REAL8 mass2;
871 REAL8 sym_mass_ratio;
872
873 if (XLALDictContains(params, "sym_mass_ratio") == 1){
874 sym_mass_ratio = XLALDictLookupREAL8Value(params, "sym_mass_ratio");
875 XLAL_CHECK(sym_mass_ratio > 0 && sym_mass_ratio <= 0.25, XLAL_EDOM, "sym_mass_ratio must be between (0, 0.25]");
876 }
877 else {
878 mass1 = XLALSimInspiralWaveformParamsLookupMass1(params);
879 mass2 = XLALSimInspiralWaveformParamsLookupMass2(params);
880 sym_mass_ratio = mass1 * mass2 / pow(mass1 + mass2, 2);
881 }
882 return sym_mass_ratio;
883}
884
885REAL8 XLALSimInspiralWaveformParamsLookupChirpMass(LALDict *params){
886 UNREVIEWED_CODE_WARNING
887 REAL8 mass1;
888 REAL8 mass2;
889 REAL8 chirp_mass;
890
891 if (XLALDictContains(params, "chirp_mass") == 1){
892 chirp_mass = XLALDictLookupREAL8Value(params, "chirp_mass");
893 XLAL_CHECK(chirp_mass > 0, XLAL_EDOM, "chirp_mass must be positive");
894 }
895 else {
896 mass1 = XLALSimInspiralWaveformParamsLookupMass1(params);
897 mass2 = XLALSimInspiralWaveformParamsLookupMass2(params);
898 chirp_mass = pow(mass1 * mass2, 3.0 / 5.0) / pow(mass1 + mass2, 1.0 / 5.0);
899 }
900 return chirp_mass;
901}
902
903REAL8 XLALSimInspiralWaveformParamsLookupMassDifference(LALDict *params){
904 UNREVIEWED_CODE_WARNING
905 REAL8 mass1;
906 REAL8 mass2;
907 REAL8 mass_difference;
908
909 if (XLALDictContains(params, "mass_difference") == 1){
910 mass_difference = XLALDictLookupREAL8Value(params, "mass_difference");
911 }
912 else {
913 mass1 = XLALSimInspiralWaveformParamsLookupMass1(params);
914 mass2 = XLALSimInspiralWaveformParamsLookupMass2(params);
915 mass_difference = mass1 - mass2;
916 }
917 return mass_difference;
918}
919
920REAL8 XLALSimInspiralWaveformParamsLookupReducedMass(LALDict *params){
921 UNREVIEWED_CODE_WARNING
922 REAL8 mass1;
923 REAL8 mass2;
924 REAL8 reduced_mass;
925
926 if (XLALDictContains(params, "reduced_mass") == 1){
927 reduced_mass = XLALDictLookupREAL8Value(params, "reduced_mass");
928 XLAL_CHECK(reduced_mass > 0, XLAL_EDOM, "reduced_mass must be positive");
929 }
930 else {
931 mass1 = XLALSimInspiralWaveformParamsLookupMass1(params);
932 mass2 = XLALSimInspiralWaveformParamsLookupMass2(params);
933 reduced_mass = mass1 * mass2 / (mass1 + mass2);
934 }
935 return reduced_mass;
936}
937
938/* Auxiliar spin transformations functions
939 * In polar components, the tilt angle is the angles between the Z axis and the spin vector.
940 * The phi angle is the angle between the X axis and the projection of the spin vector in the X-Y plane.
941 */
942
943REAL8 XLALSimInspiralGetCartesianSpinXFromPolar(REAL8 spin_norm, REAL8 spin_tilt, REAL8 spin_phi){
944 UNREVIEWED_CODE_WARNING
945 REAL8 spinx;
946 spinx = spin_norm * sin(spin_tilt) * cos(spin_phi);
947 return spinx;
948}
949
950
951REAL8 XLALSimInspiralGetCartesianSpinYFromPolar(REAL8 spin_norm, REAL8 spin_tilt, REAL8 spin_phi){
952 UNREVIEWED_CODE_WARNING
953 REAL8 spiny;
954 spiny = spin_norm * sin(spin_tilt) * sin(spin_phi);
955 return spiny;
956}
957
958REAL8 XLALSimInspiralGetCartesianSpinZFromPolar(REAL8 spin_norm, REAL8 spin_tilt){
959 UNREVIEWED_CODE_WARNING
960 REAL8 spinz;
961 spinz = spin_norm * cos(spin_tilt);
962 return spinz;
963}
964
965REAL8 XLALSimInspiralGetPolarSpin_normFromCartesian(REAL8 spinx, REAL8 spiny, REAL8 spinz){
966 UNREVIEWED_CODE_WARNING
967 REAL8 spin_norm;
968 spin_norm = sqrt(spinx* spinx+ spiny* spiny+ spinz * spinz);
969 return spin_norm;
970}
971
972REAL8 XLALSimInspiralGetPolarSpin_tiltFromCartesian(REAL8 spinx, REAL8 spiny, REAL8 spinz){
973 UNREVIEWED_CODE_WARNING
974 REAL8 spin_tilt;
975 spin_tilt = acos(spinz / sqrt(spinx* spinx+ spiny* spiny+ spinz * spinz));
976 return spin_tilt;
977}
978
979REAL8 XLALSimInspiralGetPolarSpin_phiFromCartesian(REAL8 spiny, REAL8 spinz){
980 UNREVIEWED_CODE_WARNING
981 REAL8 spin_phi;
982 spin_phi = atan(spiny / spinz);
983 return spin_phi;
984}
985
986/* SPIN parameters LOOKUP functions
987 * Read cartesian and polar spin components from LALDict
988 * These functions do not check if the spins are overdetermined.
989 * For one spin you cannot mix cartesian and polar components. The three components must be or cartesian or polar.
990 */
991
992REAL8 XLALSimInspiralWaveformParamsLookupSpin1x(LALDict *params){
993 REAL8 spin1x = -1;
994 REAL8 spin1_norm;
995 REAL8 spin1_tilt;
996 REAL8 spin1_phi;
997 if (XLALDictContains(params, "spin1x") == 1){
998 spin1x = XLALDictLookupREAL8Value(params, "spin1x");
999 return spin1x;
1000 }
1001 UNREVIEWED_CODE_WARNING
1002 if ((XLALDictContains(params, "spin1_norm") == 1) && (XLALDictContains(params, "spin1_tilt") == 1) && (XLALDictContains(params, "spin1_phi") == 1)){
1003 spin1_norm = XLALDictLookupREAL8Value(params,"spin1_norm");
1004 spin1_tilt = XLALDictLookupREAL8Value(params,"spin1_tilt");
1005 spin1_phi = XLALDictLookupREAL8Value(params,"spin1_phi");
1006 spin1x = XLALSimInspiralGetCartesianSpinXFromPolar(spin1_norm, spin1_tilt, spin1_phi);
1007 }
1008 else {
1009 spin1x = 0;
1010 XLAL_PRINT_WARNING("Not enough information provided to determine spin1x. Assuming zero as a default value. \n");
1011 }
1012 return spin1x;
1013 }
1014
1015REAL8 XLALSimInspiralWaveformParamsLookupSpin1y(LALDict *params){
1016 REAL8 spin1y = -1;
1017 REAL8 spin1_norm;
1018 REAL8 spin1_tilt;
1019 REAL8 spin1_phi;
1020 if (XLALDictContains(params, "spin1y") == 1){
1021 spin1y = XLALDictLookupREAL8Value(params, "spin1y");
1022 return spin1y;
1023 }
1024 UNREVIEWED_CODE_WARNING
1025 if ((XLALDictContains(params, "spin1_norm") == 1) && (XLALDictContains(params, "spin1_tilt") == 1) \
1026 && (XLALDictContains(params, "spin1_phi") == 1)){
1027 spin1_norm = XLALDictLookupREAL8Value(params,"spin1_norm");
1028 spin1_tilt = XLALDictLookupREAL8Value(params,"spin1_tilt");
1029 spin1_phi = XLALDictLookupREAL8Value(params,"spin1_phi");
1030 spin1y = XLALSimInspiralGetCartesianSpinYFromPolar(spin1_norm, spin1_tilt, spin1_phi);}
1031 else {
1032 spin1y = 0;
1033 XLAL_PRINT_WARNING("Not enough information provided to determine spin1y. Assuming zero as a default value. \n");
1034 }
1035 return spin1y;
1036}
1037
1038REAL8 XLALSimInspiralWaveformParamsLookupSpin1z(LALDict *params){
1039 REAL8 spin1z = -1;
1040 REAL8 spin1_norm;
1041 REAL8 spin1_tilt;
1042 if (XLALDictContains(params, "spin1z") == 1){
1043 spin1z = XLALDictLookupREAL8Value(params, "spin1z");
1044 return spin1z;
1045 }
1046 UNREVIEWED_CODE_WARNING
1047 if ((XLALDictContains(params, "spin1_norm") == 1) && (XLALDictContains(params, "spin1_tilt") == 1)){
1048 spin1_norm = XLALDictLookupREAL8Value(params,"spin1_norm");
1049 spin1_tilt = XLALDictLookupREAL8Value(params,"spin1_tilt");
1050 spin1z = XLALSimInspiralGetCartesianSpinZFromPolar(spin1_norm, spin1_tilt);}
1051 else {
1052 spin1z = 0;
1053 XLAL_PRINT_WARNING("Not enough information provided to determine spin1z. Assuming zero as a default value. \n");
1054 }
1055 return spin1z;
1056 }
1057
1058REAL8 XLALSimInspiralWaveformParamsLookupSpin2x(LALDict *params){
1059 REAL8 spin2x = -1;
1060 REAL8 spin2_norm;
1061 REAL8 spin2_tilt;
1062 REAL8 spin2_phi;
1063 if (XLALDictContains(params, "spin2x") == 1){
1064 spin2x = XLALDictLookupREAL8Value(params, "spin2x");
1065 return spin2x;
1066 }
1067 UNREVIEWED_CODE_WARNING
1068 if ((XLALDictContains(params, "spin2_norm") == 1) && (XLALDictContains(params, "spin2_tilt") == 1) \
1069 && (XLALDictContains(params, "spin2_phi") == 1)){
1070 spin2_norm = XLALDictLookupREAL8Value(params,"spin2_norm");
1071 spin2_tilt = XLALDictLookupREAL8Value(params,"spin2_tilt");
1072 spin2_phi = XLALDictLookupREAL8Value(params,"spin2_phi");
1073 spin2x = XLALSimInspiralGetCartesianSpinXFromPolar(spin2_norm, spin2_tilt, spin2_phi);}
1074 else {
1075 spin2x = 0;
1076 XLAL_PRINT_WARNING("Not enough information provided to determine spin2x. Assuming zero as a default value. \n");
1077 }
1078 return spin2x;
1079 }
1080
1081REAL8 XLALSimInspiralWaveformParamsLookupSpin2y(LALDict *params){
1082 REAL8 spin2y = -1;
1083 REAL8 spin2_norm;
1084 REAL8 spin2_tilt;
1085 REAL8 spin2_phi;
1086 if (XLALDictContains(params, "spin2y") == 1){
1087 spin2y = XLALDictLookupREAL8Value(params, "spin2y");
1088 return spin2y;
1089 }
1090 UNREVIEWED_CODE_WARNING
1091 if ((XLALDictContains(params, "spin2_norm") == 1) && (XLALDictContains(params, "spin2_tilt") == 1) \
1092 && (XLALDictContains(params, "spin2_phi") == 1)){
1093 spin2_norm = XLALDictLookupREAL8Value(params,"spin2_norm");
1094 spin2_tilt = XLALDictLookupREAL8Value(params,"spin2_tilt");
1095 spin2_phi = XLALDictLookupREAL8Value(params,"spin2_phi");
1096 spin2y = XLALSimInspiralGetCartesianSpinYFromPolar(spin2_norm, spin2_tilt, spin2_phi);}
1097 else {
1098 spin2y = 0;
1099 XLAL_PRINT_WARNING("Not enough information provided to determine spin2y. Assuming zero as a default value. \n");
1100 }
1101 return spin2y;
1102 }
1103
1104REAL8 XLALSimInspiralWaveformParamsLookupSpin2z(LALDict *params){
1105 REAL8 spin2z = -1;
1106 REAL8 spin2_norm;
1107 REAL8 spin2_tilt;
1108 if (XLALDictContains(params, "spin2z") == 1){
1109 spin2z = XLALDictLookupREAL8Value(params, "spin2z");
1110 return spin2z;
1111 }
1112 UNREVIEWED_CODE_WARNING
1113 if ((XLALDictContains(params, "spin2_norm") == 1) && (XLALDictContains(params, "spin2_tilt") == 1)){
1114 spin2_norm = XLALDictLookupREAL8Value(params,"spin2_norm");
1115 spin2_tilt = XLALDictLookupREAL8Value(params,"spin2_tilt");
1116 spin2z = XLALSimInspiralGetCartesianSpinZFromPolar(spin2_norm, spin2_tilt);}
1117 else {
1118 spin2z = 0;
1119 XLAL_PRINT_WARNING("Not enough information provided to determine spin2z. Assuming zero as a default value. \n");
1120 }
1121 return spin2z;
1122 }
1123
1124
1125REAL8 XLALSimInspiralWaveformParamsLookupSpin1norm(LALDict *params){
1126 UNREVIEWED_CODE_WARNING
1127 REAL8 spin1_norm = -1;
1128 REAL8 spin1x;
1129 REAL8 spin1y;
1130 REAL8 spin1z;
1131 if (XLALDictContains(params, "spin1_norm") == 1){
1132 spin1_norm = XLALDictLookupREAL8Value(params, "spin1_norm");
1133 }
1134 else if ((XLALDictContains(params, "spin1x") == 1) && (XLALDictContains(params, "spin1y") == 1) && (XLALDictContains(params, "spin1z") == 1))
1135 {
1136 spin1x = XLALDictLookupREAL8Value(params,"spin1x");
1137 spin1y = XLALDictLookupREAL8Value(params,"spin1y");
1138 spin1z = XLALDictLookupREAL8Value(params,"spin1z");
1139 spin1_norm = XLALSimInspiralGetPolarSpin_normFromCartesian(spin1x, spin1y, spin1z);}
1140 else {
1141 XLAL_ERROR_REAL8(XLAL_FAILURE, "Not enough information provided for spin1_norm calculation\n");
1142 }
1143 return spin1_norm;
1144 }
1145
1146REAL8 XLALSimInspiralWaveformParamsLookupSpin1tilt(LALDict *params){
1147 UNREVIEWED_CODE_WARNING
1148 REAL8 spin1_tilt = -1;
1149 REAL8 spin1x;
1150 REAL8 spin1y;
1151 REAL8 spin1z;
1152 if (XLALDictContains(params, "spin1_tilt") == 1){
1153 spin1_tilt = XLALDictLookupREAL8Value(params, "spin1_tilt");
1154 }
1155 else if ((XLALDictContains(params, "spin1x") == 1) && (XLALDictContains(params, "spin1y") == 1) && (XLALDictContains(params, "spin1z") == 1))
1156 {
1157 spin1x = XLALDictLookupREAL8Value(params,"spin1x");
1158 spin1y = XLALDictLookupREAL8Value(params,"spin1y");
1159 spin1z = XLALDictLookupREAL8Value(params,"spin1z");
1160 spin1_tilt = XLALSimInspiralGetPolarSpin_tiltFromCartesian(spin1x, spin1y, spin1z);}
1161 else {
1162 XLAL_ERROR_REAL8(XLAL_FAILURE, "Not enough information provided for spin1_tilt calculation\n");
1163 }
1164 return spin1_tilt;
1165 }
1166
1167
1168REAL8 XLALSimInspiralWaveformParamsLookupSpin1phi(LALDict *params){
1169 UNREVIEWED_CODE_WARNING
1170 REAL8 spin1_phi = -1;
1171 REAL8 spin1y;
1172 REAL8 spin1z;
1173 if (XLALDictContains(params, "spin1_phi") == 1){
1174 spin1_phi = XLALDictLookupREAL8Value(params, "spin1_phi");
1175 }
1176 else if ((XLALDictContains(params, "spin1y") == 1) && (XLALDictContains(params, "spin1z") == 1))
1177 {
1178 spin1y = XLALDictLookupREAL8Value(params,"spin1y");
1179 spin1z = XLALDictLookupREAL8Value(params,"spin1z");
1180 spin1_phi = XLALSimInspiralGetPolarSpin_phiFromCartesian(spin1y, spin1z);}
1181 else {
1182 XLAL_ERROR_REAL8(XLAL_FAILURE, "Not enough information provided for spin1_phi calculation\n");
1183 }
1184 return spin1_phi;
1185 }
1186
1187
1188REAL8 XLALSimInspiralWaveformParamsLookupSpin2norm(LALDict *params){
1189 UNREVIEWED_CODE_WARNING
1190 REAL8 spin2_norm = -1;
1191 REAL8 spin2x;
1192 REAL8 spin2y;
1193 REAL8 spin2z;
1194 if (XLALDictContains(params, "spin2_norm") == 1){
1195 spin2_norm = XLALDictLookupREAL8Value(params, "spin2_norm");
1196 }
1197 else if ((XLALDictContains(params, "spin2x") == 1) && (XLALDictContains(params, "spin2y") == 1) && (XLALDictContains(params, "spin2z") == 1))
1198 {
1199 spin2x = XLALDictLookupREAL8Value(params,"spin2x");
1200 spin2y = XLALDictLookupREAL8Value(params,"spin2y");
1201 spin2z = XLALDictLookupREAL8Value(params,"spin2z");
1202 spin2_norm = XLALSimInspiralGetPolarSpin_normFromCartesian(spin2x, spin2y, spin2z);}
1203 else {
1204 XLAL_ERROR_REAL8(XLAL_FAILURE, "Not enough information provided for spin2_norm calculation\n");
1205 }
1206 return spin2_norm;
1207 }
1208
1209REAL8 XLALSimInspiralWaveformParamsLookupSpin2tilt(LALDict *params){
1210 UNREVIEWED_CODE_WARNING
1211 REAL8 spin2_tilt = -1;
1212 REAL8 spin2x;
1213 REAL8 spin2y;
1214 REAL8 spin2z;
1215 if (XLALDictContains(params, "spin2_tilt") == 1){
1216 spin2_tilt = XLALDictLookupREAL8Value(params, "spin2_tilt");
1217 }
1218 else if ((XLALDictContains(params, "spin2x") == 1) && (XLALDictContains(params, "spin2y") == 1) && (XLALDictContains(params, "spin2z") == 1))
1219 {
1220 spin2x = XLALDictLookupREAL8Value(params,"spin2x");
1221 spin2y = XLALDictLookupREAL8Value(params,"spin2y");
1222 spin2z = XLALDictLookupREAL8Value(params,"spin2z");
1223 spin2_tilt = XLALSimInspiralGetPolarSpin_tiltFromCartesian(spin2x, spin2y, spin2z);}
1224 else {
1225 XLAL_ERROR_REAL8(XLAL_FAILURE, "Not enough information provided for spin2_tilt calculation\n");
1226 }
1227 return spin2_tilt;
1228 }
1229
1230REAL8 XLALSimInspiralWaveformParamsLookupSpin2phi(LALDict *params){
1231 UNREVIEWED_CODE_WARNING
1232 REAL8 spin2_phi = -1;
1233 REAL8 spin2y;
1234 REAL8 spin2z;
1235 if (XLALDictContains(params, "spin2_phi") == 1){
1236 spin2_phi = XLALDictLookupREAL8Value(params, "spin2_phi");
1237 }
1238 else if ((XLALDictContains(params, "spin2y") == 1) && (XLALDictContains(params, "spin2z") == 1))
1239 {
1240 spin2y = XLALDictLookupREAL8Value(params,"spin2y");
1241 spin2z = XLALDictLookupREAL8Value(params,"spin2z");
1242 spin2_phi = XLALSimInspiralGetPolarSpin_phiFromCartesian(spin2y, spin2z);}
1243 else {
1244 XLAL_ERROR_REAL8(XLAL_FAILURE, "Not enough information provided for spin2_phi calculation\n");
1245 }
1246 return spin2_phi;
1247}
1248
1249DEFINE_LOOKUP_FUNC(DeltaF, REAL8, "deltaF", 0)
1250DEFINE_LOOKUP_FUNC(DeltaT, REAL8, "deltaT", 0)
1251DEFINE_LOOKUP_FUNC(F22Ref, REAL8, "f22_ref", 0)
1252DEFINE_LOOKUP_FUNC(RefPhase, REAL8, "phi_ref", 0)
1253DEFINE_LOOKUP_FUNC(F22Start, REAL8, "f22_start", 0)
1254DEFINE_LOOKUP_FUNC(FMax, REAL8, "f_max", 0)
1255DEFINE_LOOKUP_FUNC(Distance, REAL8, "distance", 0)
1256DEFINE_LOOKUP_FUNC(Inclination, REAL8, "inclination", 0)
1257DEFINE_LOOKUP_FUNC(LongAscNodes, REAL8, "longAscNodes", 0)
1258DEFINE_LOOKUP_FUNC(Eccentricity, REAL8, "eccentricity", 0)
1259DEFINE_LOOKUP_FUNC(MeanPerAno, REAL8, "meanPerAno", 0)
1260
1261DEFINE_LOOKUP_FUNC(Lmax, INT4, "lmax", 0)
1262DEFINE_LOOKUP_FUNC(ModesChoice, INT4, "modes", LAL_SIM_INSPIRAL_MODES_CHOICE_ALL)
1263DEFINE_LOOKUP_FUNC(FrameAxis, INT4, "axis", LAL_SIM_INSPIRAL_FRAME_AXIS_ORBITAL_L)
1264DEFINE_LOOKUP_FUNC(Sideband, INT4, "sideband", 0)
1265DEFINE_LOOKUP_FUNC(NumRelData, String, "numreldata", NULL)
1266
1267LALValue* XLALSimInspiralWaveformParamsLookupModeArray(LALDict *params)
1268{
1269 /* Initialise and set Default to NULL */
1270 LALValue * value = NULL;
1271 if (params && XLALDictContains(params, "ModeArray"))
1272 {
1273 LALDictEntry * entry = XLALDictLookup(params, "ModeArray");
1274 value = XLALValueDuplicate(XLALDictEntryGetValue(entry));
1275 }
1276 return value;
1277}
1278
1279LALValue* XLALSimInspiralWaveformParamsLookupModeArrayJframe(LALDict *params)
1280{
1281 /* Initialise and set Default to NULL */
1282 LALValue * value = NULL;
1283 if (params && XLALDictContains(params, "ModeArrayJframe"))
1284 {
1285 LALDictEntry * entry = XLALDictLookup(params, "ModeArrayJframe");
1286 value = XLALValueDuplicate(XLALDictEntryGetValue(entry));
1287 }
1288 return value;
1289}
1290
1291DEFINE_LOOKUP_FUNC(PNPhaseOrder, INT4, "phaseO", -1)
1292DEFINE_LOOKUP_FUNC(PNAmplitudeOrder, INT4, "ampO", -1)
1293DEFINE_LOOKUP_FUNC(PNEccentricityOrder, INT4, "eccO", -1)
1294DEFINE_LOOKUP_FUNC(PNSpinOrder, INT4, "spinO", -1)
1295DEFINE_LOOKUP_FUNC(PNTidalOrder, INT4, "tideO", -1)
1296DEFINE_LOOKUP_FUNC(GETides, INT4, "GEtideO", 0)
1297DEFINE_LOOKUP_FUNC(GMTides, INT4, "GMtideO", 0)
1298
1299DEFINE_LOOKUP_FUNC(TidalLambda1, REAL8, "lambda1", 0)
1300DEFINE_LOOKUP_FUNC(TidalLambda2, REAL8, "lambda2", 0)
1301DEFINE_LOOKUP_FUNC(TidalOctupolarLambda1, REAL8, "TidalOctupolarLambda1", 0)
1302DEFINE_LOOKUP_FUNC(TidalOctupolarLambda2, REAL8, "TidalOctupolarLambda2", 0)
1303DEFINE_LOOKUP_FUNC(TidalHexadecapolarLambda1, REAL8, "TidalHexadecapolarLambda1", 0)
1304DEFINE_LOOKUP_FUNC(TidalHexadecapolarLambda2, REAL8, "TidalHexadecapolarLambda2", 0)
1305DEFINE_LOOKUP_FUNC(TidalQuadrupolarFMode1, REAL8, "TidalQuadrupolarFMode1", 0)
1306DEFINE_LOOKUP_FUNC(TidalQuadrupolarFMode2, REAL8, "TidalQuadrupolarFMode2", 0)
1307DEFINE_LOOKUP_FUNC(TidalOctupolarFMode1, REAL8, "TidalOctupolarFMode1", 0)
1308DEFINE_LOOKUP_FUNC(TidalOctupolarFMode2, REAL8, "TidalOctupolarFMode2", 0)
1309/* Note: some approximants like SEOBNRv2T/SEOBNRv4T will by default compute dQuadMon1, dQuadMon2 */
1310/* from TidalLambda1, TidalLambda2 using universal relations, rather than using the default value 0 */
1311DEFINE_LOOKUP_FUNC(dQuadMon1, REAL8, "dQuadMon1", 0)
1312DEFINE_LOOKUP_FUNC(dQuadMon2, REAL8, "dQuadMon2", 0)
1313DEFINE_LOOKUP_FUNC(Redshift, REAL8, "redshift", 0)
1314DEFINE_LOOKUP_FUNC(EccentricityFreq, REAL8, "f_ecc", LAL_DEFAULT_F_ECC)
1315DEFINE_LOOKUP_FUNC(Lscorr, INT4, "lscorr", 0)
1316DEFINE_LOOKUP_FUNC(FinalFreq, REAL8, "fend", 0)
1317DEFINE_LOOKUP_FUNC(OnlyFinal, INT4, "OnlyFinal", 0)
1318
1319DEFINE_LOOKUP_FUNC(NonGRPhi1, REAL8, "phi1", 0)
1320DEFINE_LOOKUP_FUNC(NonGRPhi2, REAL8, "phi2", 0)
1321DEFINE_LOOKUP_FUNC(NonGRPhi3, REAL8, "phi3", 0)
1322DEFINE_LOOKUP_FUNC(NonGRPhi4, REAL8, "phi4", 0)
1323DEFINE_LOOKUP_FUNC(NonGRDChiMinus2, REAL8, "dchiMinus2", 0)
1324DEFINE_LOOKUP_FUNC(NonGRDChiMinus1, REAL8, "dchiMinus1", 0)
1325DEFINE_LOOKUP_FUNC(NonGRDChi0, REAL8, "dchi0", 0)
1326DEFINE_LOOKUP_FUNC(NonGRDChi1, REAL8, "dchi1", 0)
1327DEFINE_LOOKUP_FUNC(NonGRDChi2, REAL8, "dchi2", 0)
1328DEFINE_LOOKUP_FUNC(NonGRDChi3, REAL8, "dchi3", 0)
1329DEFINE_LOOKUP_FUNC(NonGRDChi3S, REAL8, "dchi3S", 0)
1330DEFINE_LOOKUP_FUNC(NonGRDChi3NS, REAL8, "dchi3NS", 0)
1331DEFINE_LOOKUP_FUNC(NonGRDChi4, REAL8, "dchi4", 0)
1332DEFINE_LOOKUP_FUNC(NonGRDChi4S, REAL8, "dchi4S", 0)
1333DEFINE_LOOKUP_FUNC(NonGRDChi4NS, REAL8, "dchi4NS", 0)
1334DEFINE_LOOKUP_FUNC(NonGRDChi5, REAL8, "dchi5", 0)
1335DEFINE_LOOKUP_FUNC(NonGRDChi5S, REAL8, "dchi5S", 0)
1336DEFINE_LOOKUP_FUNC(NonGRDChi5NS, REAL8, "dchi5NS", 0)
1337DEFINE_LOOKUP_FUNC(NonGRDChi5L, REAL8, "dchi5l", 0)
1338DEFINE_LOOKUP_FUNC(NonGRDChi5LS, REAL8, "dchi5lS", 0)
1339DEFINE_LOOKUP_FUNC(NonGRDChi5LNS, REAL8, "dchi5lNS", 0)
1340DEFINE_LOOKUP_FUNC(NonGRDChi6, REAL8, "dchi6", 0)
1341DEFINE_LOOKUP_FUNC(NonGRDChi6S, REAL8, "dchi6S", 0)
1342DEFINE_LOOKUP_FUNC(NonGRDChi6NS, REAL8, "dchi6NS", 0)
1343DEFINE_LOOKUP_FUNC(NonGRDChi6L, REAL8, "dchi6l", 0)
1344DEFINE_LOOKUP_FUNC(NonGRDChi7, REAL8, "dchi7", 0)
1345DEFINE_LOOKUP_FUNC(NonGRDChi7S, REAL8, "dchi7S", 0)
1346DEFINE_LOOKUP_FUNC(NonGRDChi7NS, REAL8, "dchi7NS", 0)
1347DEFINE_LOOKUP_FUNC(NonGRDXi1, REAL8, "dxi1", 0)
1348DEFINE_LOOKUP_FUNC(NonGRDXi2, REAL8, "dxi2", 0)
1349DEFINE_LOOKUP_FUNC(NonGRDXi3, REAL8, "dxi3", 0)
1350DEFINE_LOOKUP_FUNC(NonGRDXi4, REAL8, "dxi4", 0)
1351DEFINE_LOOKUP_FUNC(NonGRDXi5, REAL8, "dxi5", 0)
1352DEFINE_LOOKUP_FUNC(NonGRDXi6, REAL8, "dxi6", 0)
1353DEFINE_LOOKUP_FUNC(NonGRDSigma1, REAL8, "dsigma1", 0)
1354DEFINE_LOOKUP_FUNC(NonGRDSigma2, REAL8, "dsigma2", 0)
1355DEFINE_LOOKUP_FUNC(NonGRDSigma3, REAL8, "dsigma3", 0)
1356DEFINE_LOOKUP_FUNC(NonGRDSigma4, REAL8, "dsigma4", 0)
1357DEFINE_LOOKUP_FUNC(NonGRDAlpha1, REAL8, "dalpha1", 0)
1358DEFINE_LOOKUP_FUNC(NonGRDAlpha2, REAL8, "dalpha2", 0)
1359DEFINE_LOOKUP_FUNC(NonGRDAlpha3, REAL8, "dalpha3", 0)
1360DEFINE_LOOKUP_FUNC(NonGRDAlpha4, REAL8, "dalpha4", 0)
1361DEFINE_LOOKUP_FUNC(NonGRDAlpha5, REAL8, "dalpha5", 0)
1362DEFINE_LOOKUP_FUNC(NonGRDBeta1, REAL8, "dbeta1", 0)
1363DEFINE_LOOKUP_FUNC(NonGRDBeta2, REAL8, "dbeta2", 0)
1364DEFINE_LOOKUP_FUNC(NonGRDBeta3, REAL8, "dbeta3", 0)
1365DEFINE_LOOKUP_FUNC(NonGRAlphaPPE, REAL8, "alphaPPE", 0)
1366DEFINE_LOOKUP_FUNC(NonGRBetaPPE, REAL8, "betaPPE", 0)
1367DEFINE_LOOKUP_FUNC(NonGRAlphaPPE0, REAL8, "alphaPPE0", 0)
1368DEFINE_LOOKUP_FUNC(NonGRBetaPPE0, REAL8, "betaPPE0", 0)
1369DEFINE_LOOKUP_FUNC(NonGRAlphaPPE1, REAL8, "alphaPPE1", 0)
1370DEFINE_LOOKUP_FUNC(NonGRBetaPPE1, REAL8, "betaPPE1", 0)
1371DEFINE_LOOKUP_FUNC(NonGRAlphaPPE2, REAL8, "alphaPPE2", 0)
1372DEFINE_LOOKUP_FUNC(NonGRBetaPPE2, REAL8, "betaPPE2", 0)
1373DEFINE_LOOKUP_FUNC(NonGRAlphaPPE3, REAL8, "alphaPPE3", 0)
1374DEFINE_LOOKUP_FUNC(NonGRBetaPPE3, REAL8, "betaPPE3", 0)
1375DEFINE_LOOKUP_FUNC(NonGRAlphaPPE4, REAL8, "alphaPPE4", 0)
1376DEFINE_LOOKUP_FUNC(NonGRBetaPPE4, REAL8, "betaPPE4", 0)
1377DEFINE_LOOKUP_FUNC(NonGRAlphaPPE5, REAL8, "alphaPPE5", 0)
1378DEFINE_LOOKUP_FUNC(NonGRBetaPPE5, REAL8, "betaPPE5", 0)
1379DEFINE_LOOKUP_FUNC(NonGRAlphaPPE6, REAL8, "alphaPPE6", 0)
1380DEFINE_LOOKUP_FUNC(NonGRBetaPPE6, REAL8, "betaPPE6", 0)
1381DEFINE_LOOKUP_FUNC(NonGRAlphaPPE7, REAL8, "alphaPPE7", 0)
1382DEFINE_LOOKUP_FUNC(NonGRBetaPPE7, REAL8, "betaPPE7", 0)
1383DEFINE_LOOKUP_FUNC(EnableLIV, INT4, "liv", 0)
1384DEFINE_LOOKUP_FUNC(NonGRLIVLogLambdaEff, REAL8, "log10lambda_eff", 100)
1385DEFINE_LOOKUP_FUNC(NonGRLIVASign, REAL8, "LIV_A_sign", 1)
1386DEFINE_LOOKUP_FUNC(NonGRLIVAlpha, REAL8, "nonGR_alpha", 0)
1387DEFINE_LOOKUP_FUNC(NonGRDChikappaS, REAL8, "dchikappaS", 0)
1388DEFINE_LOOKUP_FUNC(NonGRDChikappaA, REAL8, "dchikappaA", 0)
1389
1390/* PhenomXPHM TGR Coefficients */
1391DEFINE_LOOKUP_FUNC(NonGRDC1, REAL8, "nongr_dc1", 0)
1392DEFINE_LOOKUP_FUNC(NonGRDC2, REAL8, "nongr_dc2", 0)
1393DEFINE_LOOKUP_FUNC(NonGRDC4, REAL8, "nongr_dc4", 0)
1394DEFINE_LOOKUP_FUNC(NonGRDCL, REAL8, "nongr_dcl", 0)
1395DEFINE_LOOKUP_FUNC(NonGRDB1, REAL8, "nongr_db1", 0)
1396DEFINE_LOOKUP_FUNC(NonGRDB2, REAL8, "nongr_db2", 0)
1397DEFINE_LOOKUP_FUNC(NonGRDB3, REAL8, "nongr_db3", 0)
1398DEFINE_LOOKUP_FUNC(NonGRDB4, REAL8, "nongr_db4", 0)
1399DEFINE_LOOKUP_FUNC(NonGRParameterization, INT4, "tgr_parameterization", 0)
1400
1401
1402/* NLTides parameters */
1403/* used within LALSimInspiralTaylorF2NLTides.c */
1404DEFINE_LOOKUP_FUNC(NLTidesA1, REAL8, "nlTidesA1", 0)
1405DEFINE_LOOKUP_FUNC(NLTidesN1, REAL8, "nlTidesN1", 0)
1406DEFINE_LOOKUP_FUNC(NLTidesF1, REAL8, "nlTidesF1", 0)
1407DEFINE_LOOKUP_FUNC(NLTidesA2, REAL8, "nlTidesA2", 0)
1408DEFINE_LOOKUP_FUNC(NLTidesN2, REAL8, "nlTidesN2", 0)
1409DEFINE_LOOKUP_FUNC(NLTidesF2, REAL8, "nlTidesF2", 0)
1410/* SEOBNRv4P */
1411DEFINE_LOOKUP_FUNC(EOBChooseNumOrAnalHamDer, INT4, "EOBChooseNumOrAnalHamDer", 1)
1412DEFINE_LOOKUP_FUNC(EOBEllMaxForNyquistCheck, INT4, "EOBEllMaxForNyquistCheck", 5)
1413
1414/* IMRPhenomX Parameters */
1415DEFINE_LOOKUP_FUNC(PhenomXInspiralPhaseVersion, INT4, "InsPhaseVersion", 104)
1416DEFINE_LOOKUP_FUNC(PhenomXInspiralAmpVersion, INT4, "InsAmpVersion", 103)
1417DEFINE_LOOKUP_FUNC(PhenomXIntermediatePhaseVersion, INT4, "IntPhaseVersion", 105)
1418DEFINE_LOOKUP_FUNC(PhenomXIntermediateAmpVersion, INT4, "IntAmpVersion", 104)
1419DEFINE_LOOKUP_FUNC(PhenomXRingdownPhaseVersion, INT4, "RDPhaseVersion", 105)
1420DEFINE_LOOKUP_FUNC(PhenomXRingdownAmpVersion, INT4, "RDAmpVersion", 103)
1421DEFINE_LOOKUP_FUNC(PhenomXPrecVersion, INT4, "PrecVersion", 300)
1422DEFINE_LOOKUP_FUNC(PhenomXReturnCoPrec, INT4, "ReturnCoPrec", 0)
1423DEFINE_LOOKUP_FUNC(PhenomXPExpansionOrder, INT4, "ExpansionOrder", 5)
1424DEFINE_LOOKUP_FUNC(PhenomXPConvention, INT4, "Convention", 1)
1425DEFINE_LOOKUP_FUNC(PhenomXPFinalSpinMod, INT4, "FinalSpinMod", 4)
1426DEFINE_LOOKUP_FUNC(PhenomXPTransPrecessionMethod, INT4, "TransPrecessionMethod", 1)
1427DEFINE_LOOKUP_FUNC(PhenomXPSpinTaylorVersion, String, "SpinTaylorVersion", NULL)
1428DEFINE_LOOKUP_FUNC(PhenomXPSpinTaylorCoarseFactor, INT4, "SpinTaylorCoarseFactor",10);
1429
1430/* IMRPhenomX_NRTidalvX Parameters */
1431DEFINE_LOOKUP_FUNC(PhenomXTidalFlag, INT4, "PhenXTidal", 0)
1432
1433/* IMRPhenomXHM Parameters */
1434DEFINE_LOOKUP_FUNC(PhenomXHMReleaseVersion, INT4, "PhenomXHMReleaseVersion", 122022)
1435DEFINE_LOOKUP_FUNC(PhenomXHMInspiralPhaseVersion, INT4, "InsPhaseHMVersion", 122019)
1436DEFINE_LOOKUP_FUNC(PhenomXHMIntermediatePhaseVersion, INT4, "IntPhaseHMVersion", 122019)
1437DEFINE_LOOKUP_FUNC(PhenomXHMRingdownPhaseVersion, INT4, "RDPhaseHMVersion", 122019)
1438DEFINE_LOOKUP_FUNC(PhenomXHMInspiralAmpVersion, INT4, "InsAmpHMVersion", 3)
1439DEFINE_LOOKUP_FUNC(PhenomXHMIntermediateAmpVersion, INT4, "IntAmpHMVersion", 2)
1440DEFINE_LOOKUP_FUNC(PhenomXHMRingdownAmpVersion, INT4, "RDAmpHMVersion", 0)
1441DEFINE_LOOKUP_FUNC(PhenomXHMInspiralAmpFitsVersion, INT4, "InsAmpFitsVersion", 122018)
1442DEFINE_LOOKUP_FUNC(PhenomXHMIntermediateAmpFitsVersion, INT4, "IntAmpFitsVersion", 122018)
1443DEFINE_LOOKUP_FUNC(PhenomXHMRingdownAmpFitsVersion, INT4, "RDAmpFitsVersion", 122018)
1444DEFINE_LOOKUP_FUNC(PhenomXHMInspiralAmpFreqsVersion, INT4, "InsAmpFreqsVersion", 122018)
1445DEFINE_LOOKUP_FUNC(PhenomXHMIntermediateAmpFreqsVersion, INT4, "IntAmpFreqsVersion", 122018)
1446DEFINE_LOOKUP_FUNC(PhenomXHMRingdownAmpFreqsVersion, INT4, "RDAmpFreqsVersion", 122018)
1447DEFINE_LOOKUP_FUNC(PhenomXHMPhaseRef21, REAL8, "PhaseRef21", 0.)
1448DEFINE_LOOKUP_FUNC(PhenomXHMThresholdMband, REAL8, "ThresholdMband", 0.001)
1449DEFINE_LOOKUP_FUNC(PhenomXHMAmpInterpolMB, INT4, "AmpInterpol", 1)
1450DEFINE_LOOKUP_FUNC(DOmega220, REAL8, "domega220", 0)
1451DEFINE_LOOKUP_FUNC(DTau220, REAL8, "dtau220", 0)
1452DEFINE_LOOKUP_FUNC(DOmega210, REAL8, "domega210", 0)
1453DEFINE_LOOKUP_FUNC(DTau210, REAL8, "dtau210", 0)
1454DEFINE_LOOKUP_FUNC(DOmega330, REAL8, "domega330", 0)
1455DEFINE_LOOKUP_FUNC(DTau330, REAL8, "dtau330", 0)
1456DEFINE_LOOKUP_FUNC(DOmega440, REAL8, "domega440", 0)
1457DEFINE_LOOKUP_FUNC(DTau440, REAL8, "dtau440", 0)
1458DEFINE_LOOKUP_FUNC(DOmega550, REAL8, "domega550", 0)
1459DEFINE_LOOKUP_FUNC(DTau550, REAL8, "dtau550", 0)
1460
1461/* IMRPhenomXPHM */
1462DEFINE_LOOKUP_FUNC(PhenomXPHMMBandVersion, INT4, "MBandPrecVersion", 0)
1463DEFINE_LOOKUP_FUNC(PhenomXPHMThresholdMband, REAL8, "PrecThresholdMband", 0.001)
1464DEFINE_LOOKUP_FUNC(PhenomXPHMUseModes, INT4, "UseModes", 0)
1465DEFINE_LOOKUP_FUNC(PhenomXPHMModesL0Frame, INT4, "ModesL0Frame", 0)
1466DEFINE_LOOKUP_FUNC(PhenomXPHMPrecModes, INT4, "PrecModes", 0)
1467DEFINE_LOOKUP_FUNC(PhenomXPHMTwistPhenomHM, INT4, "TwistPhenomHM", 0)
1468
1469/* IMRPhenomTHM Parameters */
1470DEFINE_LOOKUP_FUNC(PhenomTHMInspiralVersion, INT4, "InspiralVersion", 0)
1471DEFINE_LOOKUP_FUNC(PhenomTPHMMergerVersion, INT4, "MergerVersion", 1)
1472
1473/* IMRPhenomX_PNR Parameters */
1474DEFINE_LOOKUP_FUNC(PhenomXPNRUseTunedAngles, INT4, "PNRUseTunedAngles", 0)
1475DEFINE_LOOKUP_FUNC(PhenomXPNRUseTunedCoprec, INT4, "PNRUseTunedCoprec", 0)
1476DEFINE_LOOKUP_FUNC(PhenomXPNRUseTunedCoprec33, INT4, "PNRUseTunedCoprec33", 0)
1477// Option to only be used when actively tuning PNR Coprec relative to XHM wherein the non-precessing final spin is used
1478DEFINE_LOOKUP_FUNC(PhenomXPNRUseInputCoprecDeviations, INT4, "PNRUseInputCoprecDeviations", 0)
1479// Dev option for forcing 22 phase derivative inspiral values to align with XHM at a low ref frequency
1480DEFINE_LOOKUP_FUNC(PhenomXPNRForceXHMAlignment, INT4, "PNRForceXHMAlignment", 0)
1481/* Toggle output of XAS phase for debugging purposes */
1482DEFINE_LOOKUP_FUNC(PhenomXOnlyReturnPhase, INT4, "PhenomXOnlyReturnPhase", 0)
1483DEFINE_LOOKUP_FUNC(PhenomXPNRInterpTolerance, REAL8, "PNRInterpTolerance", 0.01)
1484/* IMRPhenomX_PNR_Asymmetry Parameters */
1485DEFINE_LOOKUP_FUNC(PhenomXAntisymmetricWaveform, INT4, "AntisymmetricWaveform", 0)
1486
1487/* IMRPhenomXCP Parameters */
1488DEFINE_LOOKUP_FUNC(PhenomXCPMU1, REAL8, "MU1", 0)
1489DEFINE_LOOKUP_FUNC(PhenomXCPMU2, REAL8, "MU2", 0)
1490DEFINE_LOOKUP_FUNC(PhenomXCPMU3, REAL8, "MU3", 0)
1491DEFINE_LOOKUP_FUNC(PhenomXCPMU4, REAL8, "MU4", 0)
1492DEFINE_LOOKUP_FUNC(PhenomXCPNU0, REAL8, "NU0", 0)
1493DEFINE_LOOKUP_FUNC(PhenomXCPNU4, REAL8, "NU4", 0)
1494DEFINE_LOOKUP_FUNC(PhenomXCPNU5, REAL8, "NU5", 0)
1495DEFINE_LOOKUP_FUNC(PhenomXCPNU6, REAL8, "NU6", 0)
1496DEFINE_LOOKUP_FUNC(PhenomXCPZETA1, REAL8, "ZETA1", 0)
1497DEFINE_LOOKUP_FUNC(PhenomXCPZETA2, REAL8, "ZETA2", 0)
1498/* l=3, m=3 */
1499DEFINE_LOOKUP_FUNC(PhenomXCPMU1l3m3, REAL8, "MU1l3m3", 0)
1500DEFINE_LOOKUP_FUNC(PhenomXCPMU2l3m3, REAL8, "MU2l3m3", 0)
1501DEFINE_LOOKUP_FUNC(PhenomXCPMU3l3m3, REAL8, "MU3l3m3", 0)
1502DEFINE_LOOKUP_FUNC(PhenomXCPMU4l3m3, REAL8, "MU4l3m3", 0)
1503DEFINE_LOOKUP_FUNC(PhenomXCPNU0l3m3, REAL8, "NU0l3m3", 0)
1504DEFINE_LOOKUP_FUNC(PhenomXCPNU4l3m3, REAL8, "NU4l3m3", 0)
1505DEFINE_LOOKUP_FUNC(PhenomXCPNU5l3m3, REAL8, "NU5l3m3", 0)
1506DEFINE_LOOKUP_FUNC(PhenomXCPNU6l3m3, REAL8, "NU6l3m3", 0)
1507DEFINE_LOOKUP_FUNC(PhenomXCPZETA1l3m3, REAL8, "ZETA1l3m3", 0)
1508DEFINE_LOOKUP_FUNC(PhenomXCPZETA2l3m3, REAL8, "ZETA2l3m3", 0)
1509
1510/* ISDEFAULT FUNCTIONS */
1511
1512DEFINE_ISDEFAULT_FUNC(Lmax, INT4, "lmax", 0)
1513DEFINE_ISDEFAULT_FUNC(ModesChoice, INT4, "modes", LAL_SIM_INSPIRAL_MODES_CHOICE_ALL)
1514DEFINE_ISDEFAULT_FUNC(FrameAxis, INT4, "axis", LAL_SIM_INSPIRAL_FRAME_AXIS_ORBITAL_L)
1515DEFINE_ISDEFAULT_FUNC(Sideband, INT4, "sideband", 0)
1516DEFINE_ISDEFAULT_FUNC(NumRelData, String, "numreldata", NULL)
1517
1518int XLALSimInspiralWaveformParamsModeArrayIsDefault(LALDict *params)
1519{
1520 return XLALSimInspiralWaveformParamsLookupModeArray(params) == NULL;
1521}
1522
1523int XLALSimInspiralWaveformParamsModeArrayJframeIsDefault(LALDict *params)
1524{
1525 return XLALSimInspiralWaveformParamsLookupModeArrayJframe(params) == NULL;
1526}
1527
1528DEFINE_ISDEFAULT_FUNC(PNPhaseOrder, INT4, "phaseO", -1)
1529DEFINE_ISDEFAULT_FUNC(PNAmplitudeOrder, INT4, "ampO", -1)
1530DEFINE_ISDEFAULT_FUNC(PNEccentricityOrder, INT4, "eccO", -1)
1531DEFINE_ISDEFAULT_FUNC(PNSpinOrder, INT4, "spinO", -1)
1532DEFINE_ISDEFAULT_FUNC(PNTidalOrder, INT4, "tideO", -1)
1533DEFINE_ISDEFAULT_FUNC(GETides, INT4, "GEtideO", LAL_SIM_INSPIRAL_GETIDES_GSF23)
1534DEFINE_ISDEFAULT_FUNC(GMTides, INT4, "GMtideO", LAL_SIM_INSPIRAL_GMTIDES_PN)
1535
1536DEFINE_ISDEFAULT_FUNC(TidalLambda1, REAL8, "lambda1", 0)
1537DEFINE_ISDEFAULT_FUNC(TidalLambda2, REAL8, "lambda2", 0)
1538DEFINE_ISDEFAULT_FUNC(TidalOctupolarLambda1, REAL8, "TidalOctupolarLambda1", 0)
1539DEFINE_ISDEFAULT_FUNC(TidalOctupolarLambda2, REAL8, "TidalOctupolarLambda2", 0)
1540DEFINE_ISDEFAULT_FUNC(TidalHexadecapolarLambda1, REAL8, "TidalHexadecapolarLambda1", 0)
1541DEFINE_ISDEFAULT_FUNC(TidalHexadecapolarLambda2, REAL8, "TidalHexadecapolarLambda2", 0)
1542DEFINE_ISDEFAULT_FUNC(TidalQuadrupolarFMode1, REAL8, "TidalQuadrupolarFMode1", 0)
1543DEFINE_ISDEFAULT_FUNC(TidalQuadrupolarFMode2, REAL8, "TidalQuadrupolarFMode2", 0)
1544DEFINE_ISDEFAULT_FUNC(TidalOctupolarFMode1, REAL8, "TidalOctupolarFMode1", 0)
1545DEFINE_ISDEFAULT_FUNC(TidalOctupolarFMode2, REAL8, "TidalOctupolarFMode2", 0)
1546/* Note: some approximants like SEOBNRv2T/SEOBNRv4T will by default compute dQuadMon1, dQuadMon2 */
1547/* from TidalLambda1, TidalLambda2 using universal relations, rather than using the default value 0 */
1548DEFINE_ISDEFAULT_FUNC(dQuadMon1, REAL8, "dQuadMon1", 0)
1549DEFINE_ISDEFAULT_FUNC(dQuadMon2, REAL8, "dQuadMon2", 0)
1550DEFINE_ISDEFAULT_FUNC(Redshift, REAL8, "redshift", 0)
1551DEFINE_ISDEFAULT_FUNC(EccentricityFreq, REAL8, "f_ecc", LAL_DEFAULT_F_ECC)
1552
1553DEFINE_ISDEFAULT_FUNC(NonGRPhi1, REAL8, "phi1", 0)
1554DEFINE_ISDEFAULT_FUNC(NonGRPhi2, REAL8, "phi2", 0)
1555DEFINE_ISDEFAULT_FUNC(NonGRPhi3, REAL8, "phi3", 0)
1556DEFINE_ISDEFAULT_FUNC(NonGRPhi4, REAL8, "phi4", 0)
1557DEFINE_ISDEFAULT_FUNC(NonGRDChiMinus2, REAL8, "dchiMinus2", 0)
1558DEFINE_ISDEFAULT_FUNC(NonGRDChiMinus1, REAL8, "dchiMinus1", 0)
1559DEFINE_ISDEFAULT_FUNC(NonGRDChi0, REAL8, "dchi0", 0)
1560DEFINE_ISDEFAULT_FUNC(NonGRDChi1, REAL8, "dchi1", 0)
1561DEFINE_ISDEFAULT_FUNC(NonGRDChi2, REAL8, "dchi2", 0)
1562DEFINE_ISDEFAULT_FUNC(NonGRDChi3, REAL8, "dchi3", 0)
1563DEFINE_ISDEFAULT_FUNC(NonGRDChi3S, REAL8, "dchi3S", 0)
1564DEFINE_ISDEFAULT_FUNC(NonGRDChi3NS, REAL8, "dchi3NS", 0)
1565DEFINE_ISDEFAULT_FUNC(NonGRDChi4, REAL8, "dchi4", 0)
1566DEFINE_ISDEFAULT_FUNC(NonGRDChi4S, REAL8, "dchi4S", 0)
1567DEFINE_ISDEFAULT_FUNC(NonGRDChi4NS, REAL8, "dchi4NS", 0)
1568DEFINE_ISDEFAULT_FUNC(NonGRDChi5, REAL8, "dchi5", 0)
1569DEFINE_ISDEFAULT_FUNC(NonGRDChi5S, REAL8, "dchi5S", 0)
1570DEFINE_ISDEFAULT_FUNC(NonGRDChi5NS, REAL8, "dchi5NS", 0)
1571DEFINE_ISDEFAULT_FUNC(NonGRDChi5L, REAL8, "dchi5l", 0)
1572DEFINE_ISDEFAULT_FUNC(NonGRDChi5LS, REAL8, "dchi5lS", 0)
1573DEFINE_ISDEFAULT_FUNC(NonGRDChi5LNS, REAL8, "dchi5lNS", 0)
1574DEFINE_ISDEFAULT_FUNC(NonGRDChi6, REAL8, "dchi6", 0)
1575DEFINE_ISDEFAULT_FUNC(NonGRDChi6S, REAL8, "dchi6S", 0)
1576DEFINE_ISDEFAULT_FUNC(NonGRDChi6NS, REAL8, "dchi6NS", 0)
1577DEFINE_ISDEFAULT_FUNC(NonGRDChi6L, REAL8, "dchi6l", 0)
1578DEFINE_ISDEFAULT_FUNC(NonGRDChi7, REAL8, "dchi7", 0)
1579DEFINE_ISDEFAULT_FUNC(NonGRDChi7S, REAL8, "dchi7S", 0)
1580DEFINE_ISDEFAULT_FUNC(NonGRDChi7NS, REAL8, "dchi7NS", 0)
1581DEFINE_ISDEFAULT_FUNC(NonGRDXi1, REAL8, "dxi1", 0)
1582DEFINE_ISDEFAULT_FUNC(NonGRDXi2, REAL8, "dxi2", 0)
1583DEFINE_ISDEFAULT_FUNC(NonGRDXi3, REAL8, "dxi3", 0)
1584DEFINE_ISDEFAULT_FUNC(NonGRDXi4, REAL8, "dxi4", 0)
1585DEFINE_ISDEFAULT_FUNC(NonGRDXi5, REAL8, "dxi5", 0)
1586DEFINE_ISDEFAULT_FUNC(NonGRDXi6, REAL8, "dxi6", 0)
1587DEFINE_ISDEFAULT_FUNC(NonGRDSigma1, REAL8, "dsigma1", 0)
1588DEFINE_ISDEFAULT_FUNC(NonGRDSigma2, REAL8, "dsigma2", 0)
1589DEFINE_ISDEFAULT_FUNC(NonGRDSigma3, REAL8, "dsigma3", 0)
1590DEFINE_ISDEFAULT_FUNC(NonGRDSigma4, REAL8, "dsigma4", 0)
1591DEFINE_ISDEFAULT_FUNC(NonGRDAlpha1, REAL8, "dalpha1", 0)
1592DEFINE_ISDEFAULT_FUNC(NonGRDAlpha2, REAL8, "dalpha2", 0)
1593DEFINE_ISDEFAULT_FUNC(NonGRDAlpha3, REAL8, "dalpha3", 0)
1594DEFINE_ISDEFAULT_FUNC(NonGRDAlpha4, REAL8, "dalpha4", 0)
1595DEFINE_ISDEFAULT_FUNC(NonGRDAlpha5, REAL8, "dalpha5", 0)
1596DEFINE_ISDEFAULT_FUNC(NonGRDBeta1, REAL8, "dbeta1", 0)
1597DEFINE_ISDEFAULT_FUNC(NonGRDBeta2, REAL8, "dbeta2", 0)
1598DEFINE_ISDEFAULT_FUNC(NonGRDBeta3, REAL8, "dbeta3", 0)
1599DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE, REAL8, "alphaPPE", 0)
1600DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE, REAL8, "betaPPE", 0)
1601DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE0, REAL8, "alphaPPE0", 0)
1602DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE0, REAL8, "betaPPE0", 0)
1603DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE1, REAL8, "alphaPPE1", 0)
1604DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE1, REAL8, "betaPPE1", 0)
1605DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE2, REAL8, "alphaPPE2", 0)
1606DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE2, REAL8, "betaPPE2", 0)
1607DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE3, REAL8, "alphaPPE3", 0)
1608DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE3, REAL8, "betaPPE3", 0)
1609DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE4, REAL8, "alphaPPE4", 0)
1610DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE4, REAL8, "betaPPE4", 0)
1611DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE5, REAL8, "alphaPPE5", 0)
1612DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE5, REAL8, "betaPPE5", 0)
1613DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE6, REAL8, "alphaPPE6", 0)
1614DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE6, REAL8, "betaPPE6", 0)
1615DEFINE_ISDEFAULT_FUNC(NonGRAlphaPPE7, REAL8, "alphaPPE7", 0)
1616DEFINE_ISDEFAULT_FUNC(NonGRBetaPPE7, REAL8, "betaPPE7", 0)
1617DEFINE_ISDEFAULT_FUNC(EnableLIV, INT4, "liv", 0)
1618DEFINE_ISDEFAULT_FUNC(NonGRLIVLogLambdaEff, REAL8, "log10lambda_eff", 100)
1619DEFINE_ISDEFAULT_FUNC(NonGRLIVASign, REAL8, "LIV_A_sign", 1)
1620DEFINE_ISDEFAULT_FUNC(NonGRLIVAlpha, REAL8, "nonGR_alpha", 0)
1621DEFINE_ISDEFAULT_FUNC(NonGRDChikappaS, REAL8, "dchikappaS", 0)
1622DEFINE_ISDEFAULT_FUNC(NonGRDChikappaA, REAL8, "dchikappaA", 0)
1623
1624/* PhenomX TGR Coefficients */
1625DEFINE_ISDEFAULT_FUNC(NonGRDC1, REAL8, "nongr_dc1", 0)
1626DEFINE_ISDEFAULT_FUNC(NonGRDC2, REAL8, "nongr_dc2", 0)
1627DEFINE_ISDEFAULT_FUNC(NonGRDC4, REAL8, "nongr_dc4", 0)
1628DEFINE_ISDEFAULT_FUNC(NonGRDCL, REAL8, "nongr_dcl", 0)
1629DEFINE_ISDEFAULT_FUNC(NonGRDB1, REAL8, "nongr_db1", 0)
1630DEFINE_ISDEFAULT_FUNC(NonGRDB2, REAL8, "nongr_db2", 0)
1631DEFINE_ISDEFAULT_FUNC(NonGRDB3, REAL8, "nongr_db3", 0)
1632DEFINE_ISDEFAULT_FUNC(NonGRDB4, REAL8, "nongr_db4", 0)
1633DEFINE_ISDEFAULT_FUNC(NonGRParameterization, INT4, "tgr_parameterization", 0)
1634
1635/* SEOBNRv4P */
1636DEFINE_ISDEFAULT_FUNC(EOBChooseNumOrAnalHamDer, INT4, "EOBChooseNumOrAnalHamDer", 1)
1637DEFINE_ISDEFAULT_FUNC(EOBEllMaxForNyquistCheck, INT4, "EOBEllMaxForNyquistCheck", 5)
1638
1639/* IMRPhenomX Parameters */
1640DEFINE_ISDEFAULT_FUNC(PhenomXInspiralPhaseVersion, INT4, "InsPhaseVersion", 104)
1641DEFINE_ISDEFAULT_FUNC(PhenomXInspiralAmpVersion, INT4, "InsAmpVersion", 103)
1642DEFINE_ISDEFAULT_FUNC(PhenomXIntermediatePhaseVersion, INT4, "IntPhaseVersion", 105)
1643DEFINE_ISDEFAULT_FUNC(PhenomXIntermediateAmpVersion, INT4, "IntAmpVersion", 104)
1644DEFINE_ISDEFAULT_FUNC(PhenomXRingdownPhaseVersion, INT4, "RDPhaseVersion", 105)
1645DEFINE_ISDEFAULT_FUNC(PhenomXRingdownAmpVersion, INT4, "RDAmpVersion", 103)
1646DEFINE_ISDEFAULT_FUNC(PhenomXPrecVersion, INT4, "PrecVersion", 300)
1647DEFINE_ISDEFAULT_FUNC(PhenomXReturnCoPrec, INT4, "ReturnCoPrec", 0)
1648DEFINE_ISDEFAULT_FUNC(PhenomXPExpansionOrder, INT4, "ExpansionOrder", 5)
1649DEFINE_ISDEFAULT_FUNC(PhenomXPConvention, INT4, "Convention", 1)
1650DEFINE_ISDEFAULT_FUNC(PhenomXPFinalSpinMod, INT4, "FinalSpinMod", 4)
1651DEFINE_ISDEFAULT_FUNC(PhenomXPTransPrecessionMethod, INT4, "TransPrecessionMethod", 1)
1652DEFINE_ISDEFAULT_FUNC(PhenomXPSpinTaylorVersion, String, "SpinTaylorVersion", NULL)
1653DEFINE_ISDEFAULT_FUNC(PhenomXPSpinTaylorCoarseFactor, INT4, "SpinTaylorCoarseFactor",10);
1654
1655/* IMRPhenomX_NRTidal Parameters */
1656DEFINE_ISDEFAULT_FUNC(PhenomXTidalFlag, INT4, "PhenXTidal", 0)
1657
1658/* IMRPhenomXHM Parameters */
1659DEFINE_ISDEFAULT_FUNC(PhenomXHMReleaseVersion, INT4, "PhenomXHMReleaseVersion", 122022)
1660DEFINE_ISDEFAULT_FUNC(PhenomXHMInspiralPhaseVersion, INT4, "InsPhaseHMVersion", 122019)
1661DEFINE_ISDEFAULT_FUNC(PhenomXHMIntermediatePhaseVersion, INT4, "IntPhaseHMVersion", 122019)
1662DEFINE_ISDEFAULT_FUNC(PhenomXHMRingdownPhaseVersion, INT4, "RDPhaseHMVersion", 122019)
1663DEFINE_ISDEFAULT_FUNC(PhenomXHMInspiralAmpVersion, INT4, "InsAmpHMVersion", 3)
1664DEFINE_ISDEFAULT_FUNC(PhenomXHMIntermediateAmpVersion, INT4, "IntAmpHMVersion", 2)
1665DEFINE_ISDEFAULT_FUNC(PhenomXHMRingdownAmpVersion, INT4, "RDAmpHMVersion", 0)
1666DEFINE_ISDEFAULT_FUNC(PhenomXHMInspiralAmpFitsVersion, INT4, "InsAmpFitsVersion", 122018)
1667DEFINE_ISDEFAULT_FUNC(PhenomXHMIntermediateAmpFitsVersion, INT4, "IntAmpFitsVersion", 122018)
1668DEFINE_ISDEFAULT_FUNC(PhenomXHMRingdownAmpFitsVersion, INT4, "RDAmpFitsVersion", 122018)
1669DEFINE_ISDEFAULT_FUNC(PhenomXHMInspiralAmpFreqsVersion, INT4, "InsAmpFreqsVersion", 122018)
1670DEFINE_ISDEFAULT_FUNC(PhenomXHMIntermediateAmpFreqsVersion, INT4, "IntAmpFreqsVersion", 122018)
1671DEFINE_ISDEFAULT_FUNC(PhenomXHMRingdownAmpFreqsVersion, INT4, "RDAmpFreqsVersion", 122018)
1672DEFINE_ISDEFAULT_FUNC(PhenomXHMPhaseRef21, REAL8, "PhaseRef21", 0.)
1673DEFINE_ISDEFAULT_FUNC(PhenomXHMThresholdMband, REAL8, "ThresholdMband", 0.001)
1674DEFINE_ISDEFAULT_FUNC(PhenomXHMAmpInterpolMB, INT4, "AmpInterpol", 1)
1675DEFINE_ISDEFAULT_FUNC(DOmega220, REAL8, "domega220", 0)
1676DEFINE_ISDEFAULT_FUNC(DTau220, REAL8, "dtau220", 0)
1677DEFINE_ISDEFAULT_FUNC(DOmega210, REAL8, "domega210", 0)
1678DEFINE_ISDEFAULT_FUNC(DTau210, REAL8, "dtau210", 0)
1679DEFINE_ISDEFAULT_FUNC(DOmega330, REAL8, "domega330", 0)
1680DEFINE_ISDEFAULT_FUNC(DTau330, REAL8, "dtau330", 0)
1681DEFINE_ISDEFAULT_FUNC(DOmega440, REAL8, "domega440", 0)
1682DEFINE_ISDEFAULT_FUNC(DTau440, REAL8, "dtau440", 0)
1683DEFINE_ISDEFAULT_FUNC(DOmega550, REAL8, "domega550", 0)
1684DEFINE_ISDEFAULT_FUNC(DTau550, REAL8, "dtau550", 0)
1685
1686/* IMRPhenomXPHM */
1687DEFINE_ISDEFAULT_FUNC(PhenomXPHMMBandVersion, INT4, "MBandPrecVersion", 0)
1688DEFINE_ISDEFAULT_FUNC(PhenomXPHMThresholdMband, REAL8, "PrecThresholdMband", 0.001)
1689DEFINE_ISDEFAULT_FUNC(PhenomXPHMUseModes, INT4, "UseModes", 0)
1690DEFINE_ISDEFAULT_FUNC(PhenomXPHMModesL0Frame, INT4, "ModesL0Frame", 0)
1691DEFINE_ISDEFAULT_FUNC(PhenomXPHMPrecModes, INT4, "PrecModes", 0)
1692DEFINE_ISDEFAULT_FUNC(PhenomXPHMTwistPhenomHM, INT4, "TwistPhenomHM", 0)
1693
1694/* IMRPhenomTHM Parameters */
1695DEFINE_ISDEFAULT_FUNC(PhenomTHMInspiralVersion, INT4, "InspiralVersion", 0)
1696DEFINE_ISDEFAULT_FUNC(PhenomTPHMMergerVersion, INT4, "MergerVersion", 1)
1697
1698/* IMRPhenomX_PNR Parameters */
1699DEFINE_ISDEFAULT_FUNC(PhenomXPNRUseTunedAngles, INT4, "PNRUseTunedAngles", 0)
1700DEFINE_ISDEFAULT_FUNC(PhenomXPNRUseTunedCoprec, INT4, "PNRUseTunedCoprec", 0)
1701DEFINE_ISDEFAULT_FUNC(PhenomXPNRUseTunedCoprec33, INT4, "PNRUseTunedCoprec33", 0)
1702// Option to only be used when actively tuning PNR Coprec relative to XHM wherein the non-precessing final spin is used
1703DEFINE_ISDEFAULT_FUNC(PhenomXPNRUseInputCoprecDeviations, INT4, "PNRUseInputCoprecDeviations", 0)
1704// Dev option for forcing 22 phase derivative inspiral values to align with XHM at a low ref frequency
1705DEFINE_ISDEFAULT_FUNC(PhenomXPNRForceXHMAlignment, INT4, "PNRForceXHMAlignment", 0)
1706/* Toggle output of XAS phase for debugging purposes */
1707DEFINE_ISDEFAULT_FUNC(PhenomXOnlyReturnPhase, INT4, "PhenomXOnlyReturnPhase", 0)
1708DEFINE_ISDEFAULT_FUNC(PhenomXPNRInterpTolerance, REAL8, "PNRInterpTolerance", 0.01)
1709/* IMRPhenomX_PNR_Asymmetry Parameters */
1710DEFINE_ISDEFAULT_FUNC(PhenomXAntisymmetricWaveform, INT4, "AntisymmetricWaveform", 0)
1711
1712/* IMRPhenomXCP Parameters */
1713DEFINE_ISDEFAULT_FUNC(PhenomXCPMU1, REAL8, "MU1", 0)
1714DEFINE_ISDEFAULT_FUNC(PhenomXCPMU2, REAL8, "MU2", 0)
1715DEFINE_ISDEFAULT_FUNC(PhenomXCPMU3, REAL8, "MU3", 0)
1716DEFINE_ISDEFAULT_FUNC(PhenomXCPMU4, REAL8, "MU4", 0)
1717DEFINE_ISDEFAULT_FUNC(PhenomXCPNU0, REAL8, "NU0", 0)
1718DEFINE_ISDEFAULT_FUNC(PhenomXCPNU4, REAL8, "NU4", 0)
1719DEFINE_ISDEFAULT_FUNC(PhenomXCPNU5, REAL8, "NU5", 0)
1720DEFINE_ISDEFAULT_FUNC(PhenomXCPNU6, REAL8, "NU6", 0)
1721DEFINE_ISDEFAULT_FUNC(PhenomXCPZETA1, REAL8, "ZETA1", 0)
1722DEFINE_ISDEFAULT_FUNC(PhenomXCPZETA2, REAL8, "ZETA2", 0)
1723/* l=3, m=3 */
1724DEFINE_ISDEFAULT_FUNC(PhenomXCPMU1l3m3, REAL8, "MU1l3m3", 0)
1725DEFINE_ISDEFAULT_FUNC(PhenomXCPMU2l3m3, REAL8, "MU2l3m3", 0)
1726DEFINE_ISDEFAULT_FUNC(PhenomXCPMU3l3m3, REAL8, "MU3l3m3", 0)
1727DEFINE_ISDEFAULT_FUNC(PhenomXCPMU4l3m3, REAL8, "MU4l3m3", 0)
1728DEFINE_ISDEFAULT_FUNC(PhenomXCPNU0l3m3, REAL8, "NU0l3m3", 0)
1729DEFINE_ISDEFAULT_FUNC(PhenomXCPNU4l3m3, REAL8, "NU4l3m3", 0)
1730DEFINE_ISDEFAULT_FUNC(PhenomXCPNU5l3m3, REAL8, "NU5l3m3", 0)
1731DEFINE_ISDEFAULT_FUNC(PhenomXCPNU6l3m3, REAL8, "NU6l3m3", 0)
1732DEFINE_ISDEFAULT_FUNC(PhenomXCPZETA1l3m3, REAL8, "ZETA1l3m3", 0)
1733DEFINE_ISDEFAULT_FUNC(PhenomXCPZETA2l3m3, REAL8, "ZETA2l3m3", 0)
1734
1735
1736/** Insert common waveform parameters into LALDict */
1737LALDict* XLALSimInspiralParamsDict(const REAL8 m1, const REAL8 m2, const REAL8 S1x, const REAL8 S1y, const REAL8 S1z, const REAL8 S2x, const REAL8 S2y, const REAL8 S2z, const REAL8 distance, const REAL8 inclination, const REAL8 phiRef, const REAL8 longAscNodes, const REAL8 eccentricity, const REAL8 f_ref, LALDict *LALparams)
1738
1739{
1740 LALDict* params = XLALDictDuplicate(LALparams);
1741
1742 { XLALSimInspiralWaveformParamsInsertMass1(params, m1);
1743 XLALSimInspiralWaveformParamsInsertMass2(params, m2);
1744 XLALSimInspiralWaveformParamsInsertSpin1x(params, S1x);
1745 XLALSimInspiralWaveformParamsInsertSpin1y(params, S1y);
1746 XLALSimInspiralWaveformParamsInsertSpin1z(params, S1z);
1747 XLALSimInspiralWaveformParamsInsertSpin2x(params, S2x);
1748 XLALSimInspiralWaveformParamsInsertSpin2y(params, S2y);
1749 XLALSimInspiralWaveformParamsInsertSpin2z(params, S2z);
1750
1751 XLALSimInspiralWaveformParamsInsertDistance(params, distance);
1752 XLALSimInspiralWaveformParamsInsertInclination(params, inclination);
1753 XLALSimInspiralWaveformParamsInsertRefPhase(params, phiRef);
1754 XLALSimInspiralWaveformParamsInsertLongAscNodes(params, longAscNodes);
1755 XLALSimInspiralWaveformParamsInsertEccentricity(params, eccentricity);
1756 XLALSimInspiralWaveformParamsInsertF22Ref(params, f_ref);
1757
1758}
1759
1760
1761
1762 return params;
1763}
1764
1765#undef String
cosh
double cosh(double)
acosh
double acosh(double)
XLALDictContains
int XLALDictContains(const LALDict *dict, const char *key)
XLALDictLookup
LALDictEntry * XLALDictLookup(const LALDict *dict, const char *key)
XLALDictDuplicate
LALDict * XLALDictDuplicate(const LALDict *orig)
XLALDictInsertValue
int XLALDictInsertValue(LALDict *dict, const char *key, const LALValue *value)
XLALDictEntryGetValue
const LALValue * XLALDictEntryGetValue(const LALDictEntry *entry)
XLALDictLookupREAL8Value
REAL8 XLALDictLookupREAL8Value(const LALDict *dict, const char *key)
c
#define c
Definition: LALSimInspiralHGimri.c:35
XLALSimInspiralWaveformParamsLookupMass1
REAL8 XLALSimInspiralWaveformParamsLookupMass1(LALDict *params)
Compute mass1 from any possible combination of 2 mass parameters inserted in the LALDict.
Definition: LALSimInspiralWaveformParams.c:470
XLALSimInspiralWaveformParamsLookupSpin1phi
REAL8 XLALSimInspiralWaveformParamsLookupSpin1phi(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1168
XLALSimInspiralCheckKnownREAL8Key
int XLALSimInspiralCheckKnownREAL8Key(const char *key)
Check if the key belong to the know waveform params defined in LALSimInspiralWaveformParams_common....
Definition: LALSimInspiralWaveformParams.c:72
XLALSimInspiralWaveformParamsLookupMass2
REAL8 XLALSimInspiralWaveformParamsLookupMass2(LALDict *params)
Compute mass2 from any possible combination of 2 mass parameters inserted in the LALDict.
Definition: LALSimInspiralWaveformParams.c:651
XLALSimInspiralWaveformParamsLookupMassRatio
REAL8 XLALSimInspiralWaveformParamsLookupMassRatio(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:849
XLALSimInspiralGetPolarSpin_tiltFromCartesian
REAL8 XLALSimInspiralGetPolarSpin_tiltFromCartesian(REAL8 spinx, REAL8 spiny, REAL8 spinz)
Definition: LALSimInspiralWaveformParams.c:972
XLALSimInspiralWaveformParamsModeArrayIsDefault
int XLALSimInspiralWaveformParamsModeArrayIsDefault(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1518
XLALSimInspiralWaveformParamsLookupSpin1tilt
REAL8 XLALSimInspiralWaveformParamsLookupSpin1tilt(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1146
XLALSimInspiralWaveformParamsInsertModeArrayJframeFromModeString
int XLALSimInspiralWaveformParamsInsertModeArrayJframeFromModeString(LALDict *params, const char *modestr)
Definition: LALSimInspiralWaveformParams.c:190
XLALSimInspiralWaveformParamsLookupModeArrayJframe
LALValue * XLALSimInspiralWaveformParamsLookupModeArrayJframe(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1279
XLALSimInspiralWaveformParamsLookupSpin2y
REAL8 XLALSimInspiralWaveformParamsLookupSpin2y(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1081
XLALSimInspiralWaveformParamsLookupSpin2norm
REAL8 XLALSimInspiralWaveformParamsLookupSpin2norm(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1188
XLALSimInspiralWaveformParamsLookupModeArray
LALValue * XLALSimInspiralWaveformParamsLookupModeArray(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1267
XLALSimInspiralGetCartesianSpinZFromPolar
REAL8 XLALSimInspiralGetCartesianSpinZFromPolar(REAL8 spin_norm, REAL8 spin_tilt)
Definition: LALSimInspiralWaveformParams.c:958
XLALSimInspiralGetCartesianSpinXFromPolar
REAL8 XLALSimInspiralGetCartesianSpinXFromPolar(REAL8 spin_norm, REAL8 spin_tilt, REAL8 spin_phi)
Definition: LALSimInspiralWaveformParams.c:943
XLALSimInspiralWaveformParamsLookupMassDifference
REAL8 XLALSimInspiralWaveformParamsLookupMassDifference(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:903
XLALSimInspiralWaveformParamsInsertModeArray
int XLALSimInspiralWaveformParamsInsertModeArray(LALDict *params, LALValue *value)
Definition: LALSimInspiralWaveformParams.c:172
XLALSimInspiralGetPolarSpin_normFromCartesian
REAL8 XLALSimInspiralGetPolarSpin_normFromCartesian(REAL8 spinx, REAL8 spiny, REAL8 spinz)
Definition: LALSimInspiralWaveformParams.c:965
XLALSimInspiralWaveformParamsLookupTotalMass
REAL8 XLALSimInspiralWaveformParamsLookupTotalMass(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:831
XLALSimInspiralGetCartesianSpinYFromPolar
REAL8 XLALSimInspiralGetCartesianSpinYFromPolar(REAL8 spin_norm, REAL8 spin_tilt, REAL8 spin_phi)
Definition: LALSimInspiralWaveformParams.c:951
XLALSimInspiralWaveformParamsLookupSpin2x
REAL8 XLALSimInspiralWaveformParamsLookupSpin2x(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1058
XLALSimInspiralWaveformParamsLookupSpin2tilt
REAL8 XLALSimInspiralWaveformParamsLookupSpin2tilt(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1209
XLALSimInspiralWaveformParamsLookupSymMassRatio
REAL8 XLALSimInspiralWaveformParamsLookupSymMassRatio(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:867
XLALSimInspiralGetMassRatioFromSymMassRatio
REAL8 XLALSimInspiralGetMassRatioFromSymMassRatio(REAL8 sym_mass_ratio)
Definition: LALSimInspiralWaveformParams.c:425
XLALSimInspiralWaveformParamsLookupSpin2phi
REAL8 XLALSimInspiralWaveformParamsLookupSpin2phi(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1230
XLALSimInspiralGetMassRatioFromChirpMassComponentMass1
REAL8 XLALSimInspiralGetMassRatioFromChirpMassComponentMass1(REAL8 chirp_mass, REAL8 component_mass)
Definition: LALSimInspiralWaveformParams.c:446
XLALSimInspiralWaveformParamsLookupSpin1x
REAL8 XLALSimInspiralWaveformParamsLookupSpin1x(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:992
XLALSimInspiralWaveformParamsLookupSpin2z
REAL8 XLALSimInspiralWaveformParamsLookupSpin2z(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1104
XLALSimInspiralGetPolarSpin_phiFromCartesian
REAL8 XLALSimInspiralGetPolarSpin_phiFromCartesian(REAL8 spiny, REAL8 spinz)
Definition: LALSimInspiralWaveformParams.c:979
XLALSimInspiralWaveformParamsInsertModeArrayJframe
int XLALSimInspiralWaveformParamsInsertModeArrayJframe(LALDict *params, LALValue *value)
Definition: LALSimInspiralWaveformParams.c:177
UNREVIEWED_CODE_WARNING
#define UNREVIEWED_CODE_WARNING
Definition: LALSimInspiralWaveformParams.c:16
XLALSimInspiralWaveformParamsInsertModeArrayFromModeString
int XLALSimInspiralWaveformParamsInsertModeArrayFromModeString(LALDict *params, const char *modestr)
Definition: LALSimInspiralWaveformParams.c:182
XLALSimInspiralWaveformParamsLookupReducedMass
REAL8 XLALSimInspiralWaveformParamsLookupReducedMass(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:920
XLALSimInspiralWaveformParamsLookupSpin1z
REAL8 XLALSimInspiralWaveformParamsLookupSpin1z(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1038
XLALSimInspiralWaveformParamsModeArrayJframeIsDefault
int XLALSimInspiralWaveformParamsModeArrayJframeIsDefault(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1523
String
#define String
Definition: LALSimInspiralWaveformParams.c:62
XLALSimInspiralWaveformParamsLookupChirpMass
REAL8 XLALSimInspiralWaveformParamsLookupChirpMass(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:885
XLALSimInspiralWaveformParamsLookupSpin1norm
REAL8 XLALSimInspiralWaveformParamsLookupSpin1norm(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1125
DEFINE_LOOKUP_FUNC
#define DEFINE_LOOKUP_FUNC(NAME, TYPE, KEY, DEFAULT)
Definition: LALSimInspiralWaveformParams.c:30
XLALSimInspiralGetMassRatioFromChirpMassComponentMass2
REAL8 XLALSimInspiralGetMassRatioFromChirpMassComponentMass2(REAL8 chirp_mass, REAL8 component_mass)
Definition: LALSimInspiralWaveformParams.c:441
DEFINE_ISDEFAULT_FUNC
#define DEFINE_ISDEFAULT_FUNC(NAME, TYPE, KEY, DEFAULT)
Definition: LALSimInspiralWaveformParams.c:39
XLALSimInspiralCheckDeterminationOfMasses
int XLALSimInspiralCheckDeterminationOfMasses(LALDict *params)
Check if the mass paramters inserted in the LALDict allow to determine the two mass components mass1,...
Definition: LALSimInspiralWaveformParams.c:86
DEFINE_INSERT_FUNC
#define DEFINE_INSERT_FUNC(NAME, TYPE, KEY, DEFAULT)
Definition: LALSimInspiralWaveformParams.c:24
XLALSimInspiralParamsDict
LALDict * XLALSimInspiralParamsDict(const REAL8 m1, const REAL8 m2, const REAL8 S1x, const REAL8 S1y, const REAL8 S1z, const REAL8 S2x, const REAL8 S2y, const REAL8 S2z, const REAL8 distance, const REAL8 inclination, const REAL8 phiRef, const REAL8 longAscNodes, const REAL8 eccentricity, const REAL8 f_ref, LALDict *LALparams)
Insert common waveform parameters into LALDict.
Definition: LALSimInspiralWaveformParams.c:1737
XLALSimInspiralWaveformParamsLookupSpin1y
REAL8 XLALSimInspiralWaveformParamsLookupSpin1y(LALDict *params)
Definition: LALSimInspiralWaveformParams.c:1015
XLALSimInspiralWaveformParamsInsertSpin1z
int XLALSimInspiralWaveformParamsInsertSpin1z(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertMass1
int XLALSimInspiralWaveformParamsInsertMass1(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertF22Ref
int XLALSimInspiralWaveformParamsInsertF22Ref(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertLongAscNodes
int XLALSimInspiralWaveformParamsInsertLongAscNodes(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertSpin2z
int XLALSimInspiralWaveformParamsInsertSpin2z(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertRefPhase
int XLALSimInspiralWaveformParamsInsertRefPhase(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertSpin1y
int XLALSimInspiralWaveformParamsInsertSpin1y(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertEccentricity
int XLALSimInspiralWaveformParamsInsertEccentricity(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertInclination
int XLALSimInspiralWaveformParamsInsertInclination(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertSpin2x
int XLALSimInspiralWaveformParamsInsertSpin2x(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertSpin2y
int XLALSimInspiralWaveformParamsInsertSpin2y(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertSpin1x
int XLALSimInspiralWaveformParamsInsertSpin1x(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertMass2
int XLALSimInspiralWaveformParamsInsertMass2(LALDict *params, REAL8 value)
XLALSimInspiralWaveformParamsInsertDistance
int XLALSimInspiralWaveformParamsInsertDistance(LALDict *params, REAL8 value)
LALSimInspiralWaveformParams_common.c
lalSimInspiralREAL8WaveformParams
static struct @1 lalSimInspiralREAL8WaveformParams[]
name
const char * name
Definition: LALSimInspiralWaveformParams_common.c:6
XLALValueDuplicate
LALValue * XLALValueDuplicate(const LALValue *value)
i
double i
Definition: bh_ringdown.c:118
w
const double w
Definition: exact_derivatives-HrealHeader.c:106
XLAL_NUM_ELEM
#define XLAL_NUM_ELEM(x)
REAL8
double REAL8
UINT2
uint16_t UINT2
INT4
int32_t INT4
LAL_DEFAULT_F_ECC
#define LAL_DEFAULT_F_ECC
Definition: LALSimInspiral.h:222
LAL_SIM_INSPIRAL_MODES_CHOICE_ALL
@ LAL_SIM_INSPIRAL_MODES_CHOICE_ALL
Include all available modes.
Definition: LALSimInspiralWaveformFlags.h:140
LAL_SIM_INSPIRAL_GETIDES_GSF23
@ LAL_SIM_INSPIRAL_GETIDES_GSF23
Definition: LALSimInspiralWaveformFlags.h:94
LAL_SIM_INSPIRAL_FRAME_AXIS_ORBITAL_L
@ LAL_SIM_INSPIRAL_FRAME_AXIS_ORBITAL_L
Set z-axis along the initial orbital angular momentum.
Definition: LALSimInspiralWaveformFlags.h:113
LAL_SIM_INSPIRAL_GMTIDES_PN
@ LAL_SIM_INSPIRAL_GMTIDES_PN
Definition: LALSimInspiralWaveformFlags.h:100
Eccentricity
@ Eccentricity
UNDOCUMENTED.
Definition: LALSimInspiral.h:310
XLALSimInspiralModeArrayFromModeString
LALValue * XLALSimInspiralModeArrayFromModeString(const char *modestr)
Definition: LALSimInspiralWaveformFlags.c:544
XLAL_ERROR_REAL8
#define XLAL_ERROR_REAL8(...)
XLAL_ERROR
#define XLAL_ERROR(...)
XLAL_CHECK
#define XLAL_CHECK(assertion,...)
XLAL_PRINT_WARNING
#define XLAL_PRINT_WARNING(...)
XLAL_SUCCESS
XLAL_SUCCESS
XLAL_EFUNC
XLAL_EFUNC
XLAL_EDOM
XLAL_EDOM
XLAL_EINVAL
XLAL_EINVAL
XLAL_FAILURE
XLAL_FAILURE
status
string status
x
x
params
Definition: burst.c:245
deltaT
double deltaT
Definition: unicorn.c:24
f_max
double f_max
Definition: unicorn.c:23