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