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