Loading [MathJax]/extensions/TeX/AMSsymbols.js
LALSimulation 6.2.0.1-3a66518
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
test_phenomX.py
Go to the documentation of this file.
1# -*- coding: utf-8 -*-
2#
3# Copyright (C) 2020 Cecilio García Quirós (adapted from test_phenomPv3HM.py of Sebastian Khan)
4#
5# This program is free software: you can redistribute it and/or modify
6# it under the terms of the GNU General Public License as published by
7# the Free Software Foundation, either version 3 of the License, or
8# (at your option) any later version.
9#
10# This program is distributed in the hope that it will be useful,
11# but WITHOUT ANY WARRANTY; without even the implied warranty of
12# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13# GNU General Public License for more details.
14#
15# You should have received a copy of the GNU General Public License
16# along with this program. If not, see <http: //www.gnu.org/licenses/>.
17
18"""Simple test to see if the PhenomX family models have changed: IMRPhenomXAS, IMRPhenomXHM, IMRPhenomXP, IMRPhenomXPHM, IMRPhenomXAS_NRTidalv2, IMRPhenomXP_NRTidalv2, and IMRPhenomXO4a.
19"""
20
21import sys
22import pytest
23import lal
24import lalsimulation
25import numpy as np
26
27# -- utility functions ---------------------
28
30 amp = np.abs(h)
31 phase = np.unwrap(np.angle(h))
32 return amp, phase
33
34def sum_sqr_diff(x, y):
35 return np.sqrt( np.sum( (x-y)**2 ) )
36
37
38def gen_test_data(spin1x, approximant, mode_array, lalparams = None, type='bbh', generic_spins=False,deltaF=1./4.,release=None):
39 """
40 compute the difference between two waveforms
41 and compare to expected value
42
43 type: should either be 'bbh' or 'bns'
44 generic_spins: Use generic spins (with in-plane spins scaled from spin1x, which must be at most ~0.69, and aligned spins hard-coded) if True;
45 otherwise the only potentially nonzero spin component is spin1x
46
47 """
48
49 if(lalparams == None):
50 lalparams = lal.CreateDict()
51
52 if(mode_array!=None):
53 ModeArray = lalsimulation.SimInspiralCreateModeArray()
54 for mode in mode_array:
55 lalsimulation.SimInspiralModeArrayActivateMode(ModeArray, mode[0], mode[1])
56 lalsimulation.SimInspiralWaveformParamsInsertModeArray(lalparams, ModeArray)
57
58 if release is not None:
59 lalsimulation.SimInspiralWaveformParamsInsertPhenomXHMReleaseVersion(lalparams, release)
60
61 if type == 'bbh':
62 m1_sel = 50*lal.MSUN_SI
63 m2_sel = 30*lal.MSUN_SI
64 m2_sel_prime = 20.*lal.MSUN_SI
65 f_max_sel = 512.
66 elif type == 'bns':
67 m1_sel = 1.6*lal.MSUN_SI
68 m2_sel = 1.4*lal.MSUN_SI
69 m2_sel_prime = 1.3*lal.MSUN_SI
70 f_max_sel = 2048.
71
72 lalsimulation.SimInspiralWaveformParamsInsertTidalLambda1(lalparams, 200.)
73 lalsimulation.SimInspiralWaveformParamsInsertTidalLambda2(lalparams, 300.)
74 else:
75 raise ValueError("Unknown binary type")
76
77 if generic_spins:
78 spin1y = 0.5*spin1x
79 spin1z = -0.3
80 spin2x = -0.9*spin1x
81 spin2y = 1.2*spin1x
82 spin2z = 0.2
83 else:
84 spin1y = 0.
85 spin1z = 0.
86 spin2x = 0.
87 spin2y = 0.
88 spin2z = 0.
89
90 common_pars=dict(
91 m1=m1_sel,
92 m2=m2_sel,
93 S1x=spin1x,
94 S1y=spin1y,
95 S1z=spin1z,
96 S2x=spin2x,
97 S2y=spin2y,
98 S2z=spin2z,
99 distance=1,
100 inclination=np.pi/3.,
101 phiRef=0.,
102 longAscNodes=0.,
103 eccentricity=0.,
104 meanPerAno=0.,
105 deltaF=deltaF,
106 f_min=30.,
107 f_max=f_max_sel,
108 f_ref=30.,
109 LALpars=lalparams,
110 approximant=approximant
111 )
112
113 pars1=common_pars.copy()
114
115 pars2=common_pars.copy()
116 pars2.update({"m2":m2_sel_prime})
117
118 hp1, hc1 = lalsimulation.SimInspiralChooseFDWaveform(**pars1)
119 hp2, hc2 = lalsimulation.SimInspiralChooseFDWaveform(**pars2)
120
121 # compute amp and phase
122 hp1_amp, hp1_phase = get_amp_phase(hp1.data.data)
123 hc1_amp, hc1_phase = get_amp_phase(hc1.data.data)
124
125 hp2_amp, hp2_phase = get_amp_phase(hp2.data.data)
126 hc2_amp, hc2_phase = get_amp_phase(hc2.data.data)
127
128 hp_amp_diff = sum_sqr_diff(hp1_amp, hp2_amp)
129 hp_phase_diff = sum_sqr_diff(hp1_phase, hp2_phase)
130
131 hc_amp_diff = sum_sqr_diff(hc1_amp, hc2_amp)
132 hc_phase_diff = sum_sqr_diff(hc1_phase, hc2_phase)
133
134 return hp_amp_diff, hp_phase_diff, hc_amp_diff, hc_phase_diff
135
136
137
138# -- test functions ---------------------
139
141 """
142 This test checks that IMRPhenomXAS hasn't changed.
143 It does this by generating two PhenomXAS waveforms and computing
144 their difference (according to their amplitude and phases)
145 and compares them to pre-computed values.
146
147 these pre-computed values were computed using the following line:
148
149 `expected_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXAS, None, generic_spins=True))`
150
151 """
152
153 expected_result = np.array([787.00663452, 165.89210208, 629.60530761, 165.89210208])
154
155 new_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXAS, None, generic_spins=True))
156
157 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXAS test failed")
158
160 """
161 This test checks that IMRPhenomXHM hasn't changed.
162 It does this by generating two PhenomXHM waveforms and computing
163 their difference (according to their amplitude and phases)
164 and compares them to pre-computed values.
165
166 these pre-computed values were computed using the following line:
167
168 `expected_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXHM, mode_array))`
169
170 where mode_array is [[2,2],[2,-2],[2,1],[2,-1],[3,3],[3,-3],[4,4],[4,-4]] or [[3,2],[3,-2]]
171
172 """
173
174
175 expected_result = np.array([1005.16009183, 169.88197475, 768.18401876, 169.12711241])
176
177 new_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXHM, [[2,2],[2,-2],[2,1],[2,-1],[3,3],[3,-3],[4,4],[4,-4]], release=122019))
178
179 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXHM (122019) no 32 mode test failed")
180
181 expected_result = np.array([ 32.17818789, 216.01992794, 4.02227349, 215.97103911])
182
183 new_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXHM, [[3,2],[3,-2]], release=122019))
184
185 # rtol with 32 mode needs to b more lenient
186 np.testing.assert_allclose(new_result, expected_result, rtol=3e-4, err_msg="IMRPhenomXHM (122019) 32 mode test failed")
187
188 expected_result = np.array([1005.01319319, 169.88945372, 768.34648494, 169.13261004])
189
190 new_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXHM, [[2,2],[2,-2],[2,1],[2,-1],[3,3],[3,-3],[4,4],[4,-4]]))
191
192 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXHM no 32 mode test failed")
193
194 expected_result = np.array([34.62153262, 218.09073730, 4.32769157, 218.09073730])
195
196 new_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXHM, [[3,2],[3,-2]]))
197
198 # rtol with 32 mode needs to b more lenient
199 np.testing.assert_allclose(new_result, expected_result, rtol=3.1e-4, err_msg="IMRPhenomXHM 32 mode test failed")
200
201def test_IMRPhenomXP():
202 """
203 This test checks that IMRPhenomXP hasn't changed.
204 It does this by generating two PhenomXP waveforms and computing
205 their difference (according to their amplitude and phases)
206 and compares them to pre-computed values.
207
208 these pre-computed values were computed using the following line:
209
210 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, generic_spins=False))`
211
212 """
213 lalDict = lal.CreateDict()
214 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 223)
215 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPFinalSpinMod(lalDict, 2)
216
217 expected_result = np.array([1070.22089507, 271.62095671, 533.04876588, 268.4520146])
218
219 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, generic_spins=False))
220
221 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXP test failed")
222
223
225 """
226 This test checks that IMRPhenomXP with the NNLO precession option (version 102) hasn't changed.
227 It does this by generating two PhenomXP waveforms and computing
228 their difference (according to their amplitude and phases)
229 and compares them to pre-computed values.
230
231 these pre-computed values were computed using the following code:
232
233 `lalDict = lal.CreateDict()`
234
235 `lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 102)`
236
237 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, lalparams=lalDict, generic_spins=False))`
238
239 """
240
241 lalDict = lal.CreateDict()
242 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 102)
243
244 expected_result = np.array([1235.47048998, 226.22617618, 1049.4091208, 225.46870308])
245
246 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, lalparams=lalDict, generic_spins=True))
247
248 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXP_NNLO test failed")
249
250
251
253 """
254 This test checks that IMRPhenomXP hasn't changed.
255 It does this by generating two PhenomXP waveforms and computing
256 their difference (according to their amplitude and phases)
257 and compares them to pre-computed values.
258
259 these pre-computed values were computed using the following line:
260
261 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, generic_spins=True))`
262
263 FIXME: This description needs to be corrected if this is kept.
264
265 """
266 lalDict = lal.CreateDict()
267 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 223)
268
269 expected_result = np.array([1468.09702243, 190.76614342, 972.51053189, 189.80404795])
270
271 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[2,2]], lalparams=lalDict, generic_spins=True))
272
273 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXP_MB test failed")
274
275
277 """
278 This test checks that IMRPhenomXP with the SpinTaylor precession option (version 310) hasn't changed.
279 It does this by generating two PhenomXP waveforms and computing
280 their difference (according to their amplitude and phases)
281 and compares them to pre-computed values.
282
283 these pre-computed values were computed using the following code:
284
285 `lalDict = lal.CreateDict()`
286
287 `lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 310)`
288
289 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, lalparams=lalDict, generic_spins=True))`
290
291 """
292
293 expected_result = np.array([1570.905974, 190.514064, 1107.696605, 195.697882])
294
295 lalDict = lal.CreateDict()
296
297 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 310)
298
299 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXP, None, lalparams=lalDict, generic_spins=True))
300
301 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXP test failed")
302
303
305 """
306 This test checks that IMRPhenomXPHM hasn't changed.
307 It does this by generating two PhenomXPHM waveforms and computing
308 their difference (according to their amplitude and phases)
309 and compares them to pre-computed values.
310
311 these pre-computed values were computed using the following line:
312
313 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, mode_array, generic_spins=True))`
314
315 where mode_array is [[2,2],[2,1],[3,3],[4,4]] or [[3,2]]
316
317 """
318
319
320 expected_result = np.array([1166.01091848, 334.5693217, 767.82099062, 326.09652364])
321
322 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[2,2],[2,1],[3,3],[4,4]], release=122019))
323
324 # rtol here needs to be more lenient to pass on builds with arm64 or MKL
325 np.testing.assert_allclose(new_result, expected_result, rtol=1e-5, err_msg="IMRPhenomXPHM (122019) no 32 mode test failed")
326
327
328 expected_result = np.array([68.9282789725476, 240.20999880535206, 25.111569754767224, 234.7465084316962])
329
330 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[3,2]], release=122019))
331
332 # rtol with 32 mode needs to b more lenient
333 np.testing.assert_allclose(new_result, expected_result, rtol=3e-4, err_msg="IMRPhenomXPHM (122019) 32 mode test failed")
334
335 expected_result = np.array([1166.77270896, 334.86014307, 768.93672645, 326.38518250])
336
337 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[2,2],[2,1],[3,3],[4,4]]))
338
339 # rtol here needs to be more lenient to pass on builds with arm64 or MKL
340 np.testing.assert_allclose(new_result, expected_result, rtol=1.3e-5, err_msg="IMRPhenomXPHM no 32 mode test failed")
341
342 expected_result = np.array([71.43504434, 242.82287296, 26.54528442, 237.35077401])
343
344 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[3,2]]))
345
346 # rtol with 32 mode needs to b more lenient
347 np.testing.assert_allclose(new_result, expected_result, rtol=3e-4, err_msg="IMRPhenomXPHM 32 mode test failed")
348
350 """
351 This test checks that IMRPhenomXO4a hasn't changed.
352 It does this by generating two IMRPhenomXO4a waveforms and computing
353
354 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXO4a))`
355
356 """
357
358 expected_result = np.array([1147.6076128830048, 202.16395516656954, 835.6550472580194, 322.56504443715437])
359
360 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXO4a, [[2,2],[2,1],[3,3],[4,4]]))
361
362 # rtol here needs to be more lenient to pass on builds with arm64 or MKL
363 np.testing.assert_allclose(new_result, expected_result, rtol=1e-5, err_msg="IMRPhenomXO4a no 32 mode test failed")
364
365
366 expected_result = np.array([48.56332295620956, 236.22060412141988, 21.61676721381083, 232.43479133460966])
367 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXO4a, [[3,2]]))
368
369 # rtol with 32 mode needs to be more lenient
370 np.testing.assert_allclose(new_result, expected_result, rtol=3e-3, err_msg="IMRPhenomXO4a 32 mode test failed")
371
373 """
374 This test checks that IMRPhenomXPHM with the SpinTaylor precession option (version 310) hasn't changed.
375 It does this by generating two PhenomXPHM waveforms and computing
376 their difference (according to their amplitude and phases)
377 and compares them to pre-computed values.
378
379 these pre-computed values were computed using the following code:
380
381 `lalDict = lal.CreateDict()`
382
383 `lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 310)`
384
385 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, mode_array, lalparams=lalDict, generic_spins=True))`
386
387 where mode_array is [[2,2],[2,1],[3,3],[4,4]] or [[3,2]]
388
389 """
390
391 expected_result = np.array([1688.30370786, 274.96949069, 1248.22149474, 279.10374629])
392
393 lalDict = lal.CreateDict()
394
395 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 310)
396
397 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[2,2],[2,1],[3,3],[4,4]], lalparams=lalDict, generic_spins=True,release=122019))
398
399 # rtol here needs to be more lenient to pass on builds with arm64 or MKL
400 np.testing.assert_allclose(new_result, expected_result, rtol=1e-5, err_msg="IMRPhenomXPHM no 32 mode test failed")
401
402
403 expected_result = np.array([12.68276953, 170.44495875, 42.97960664, 142.53609984])
404
405 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPHM, [[3,2]], lalparams=lalDict, generic_spins=True,release=122019))
406
407 # rtol with 32 mode needs to be more lenient
408 np.testing.assert_allclose(new_result, expected_result, rtol=5e-4, err_msg="IMRPhenomXPHM 32 mode test failed")
409
410
412 """
413 This test checks that IMRPhenomXAS_NRTidalv2 hasn't changed.
414 It does this by generating two IMRPhenomXAS_NRTidalv2 waveforms and computing
415 their difference (according to their amplitude and phases)
416 and compares them to pre-computed values.
417
418 these pre-computed values were computed using the following line:
419
420 `expected_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXAS_NRTidalv2, None, type="bns", generic_spins=True))`
421
422 """
423
424 expected_result = np.array([10.04639297, 561.5921041 ,8.03711438, 561.62725166])
425
426 new_result = np.array(gen_test_data(0., lalsimulation.IMRPhenomXAS_NRTidalv2, None, type='bns', generic_spins=True))
427
428 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXAS_NRTidalv2 test failed")
429
430
432 """
433 This test checks that IMRPhenomXP_NRTidalv2 hasn't changed.
434 It does this by generating two IMRPhenomXP_NRTidalv2 waveforms and computing
435 their difference (according to their amplitude and phases)
436 and compares them to pre-computed values.
437
438 these pre-computed values were computed using the following line:
439
440 `expected_result = np.array(gen_test_data(0.2, lalsimulation.IMRPhenomXP_NRTidalv2, None, type="bns", generic_spins=True))`
441
442 """
443
444 lalDict = lal.CreateDict()
445
446 expected_result = np.array([ 13.9202092 , 561.0238095 , 19.05392711, 550.93840153])
447
448 new_result = np.array(gen_test_data(0.2, lalsimulation.IMRPhenomXP_NRTidalv2, None, type='bns', lalparams=lalDict, generic_spins=True))
449 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXP_NRTidalv2 test failed")
450
451
453 """
454 This test checks that IMRPhenomXP_NRTidalv2 with the SpinTaylor precession (version 310) hasn't changed.
455 It does this by generating two IMRPhenomXP_NRTidalv2 waveforms and computing
456 their difference (according to their amplitude and phases)
457 and compares them to pre-computed values.
458
459 these pre-computed values were computed using the following code:
460
461 `lalDict = lal.CreateDict()`
462
463 `lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 310)`
464
465 `expected_result = np.array(gen_test_data(0.2, lalsimulation.IMRPhenomXP_NRTidalv2, None, lalparams=lalDict, type="bns", generic_spins=True))`
466
467 """
468
469 expected_result = np.array([11.92543681, 730.77807026, 13.69906426, 552.53065783])
470
471 lalDict = lal.CreateDict()
472
473 lalsimulation.SimInspiralWaveformParamsInsertPhenomXPrecVersion(lalDict, 310)
474
475 new_result = np.array(gen_test_data(0.2, lalsimulation.IMRPhenomXP_NRTidalv2, None, lalparams=lalDict, type='bns', generic_spins=True))
476
477 np.testing.assert_allclose(new_result, expected_result, rtol=1e-6, err_msg="IMRPhenomXP_NRTidalv2 test failed")
478
479
481 """
482 This test checks that IMRPhenomXO4a hasn't changed.
483 It does this by generating two IMRPhenomXO4a waveforms and computing
484
485 `expected_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXO4a))`
486
487 """
488
489 expected_result = np.array([1149.25272956272488, 201.90592114484070, 830.22645041272130, 321.89849276096191])
490
491 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPNR, [[2,2],[2,1],[3,3],[4,4]]))
492
493 # rtol here needs to be more lenient to pass on builds with arm64 or MKL
494 np.testing.assert_allclose(new_result, expected_result, rtol=1e-5, err_msg="IMRPhenomXPNR no 32 mode test failed")
495
496
497 expected_result = np.array([47.9973923614742546, 235.9677577246995384, 21.6471155649431743, 231.9826404417289041])
498
499 new_result = np.array(gen_test_data(0.5, lalsimulation.IMRPhenomXPNR, [[3,2]]))
500
501 # rtol with 32 mode needs to be more lenient
502 np.testing.assert_allclose(new_result, expected_result, rtol=3e-3, err_msg="IMRPhenomXPNR 32 mode test failed")
503
504# -- run the tests ------------------------------
505
506if __name__ == '__main__':
507 args = sys.argv[1:] or ["-v", "-rs", "--junit-xml=junit-phenomX.xml"]
508 sys.exit(pytest.main(args=[__file__] + args))
def test_IMRPhenomXPHM_SpinTaylor()
This test checks that IMRPhenomXPHM with the SpinTaylor precession option (version 310) hasn't change...
def test_IMRPhenomXPHM()
This test checks that IMRPhenomXPHM hasn't changed.
def test_IMRPhenomXP_MB()
This test checks that IMRPhenomXP hasn't changed.
def test_IMRPhenomXPNR()
This test checks that IMRPhenomXO4a hasn't changed.
def test_IMRPhenomXO4a()
This test checks that IMRPhenomXO4a hasn't changed.
def test_IMRPhenomXAS_NRTidalv2()
This test checks that IMRPhenomXAS_NRTidalv2 hasn't changed.
def test_IMRPhenomXP_NRTidalv2()
This test checks that IMRPhenomXP_NRTidalv2 hasn't changed.
def test_IMRPhenomXP_NNLO()
This test checks that IMRPhenomXP with the NNLO precession option (version 102) hasn't changed.
def test_IMRPhenomXP()
This test checks that IMRPhenomXP hasn't changed.
def sum_sqr_diff(x, y)
Definition: test_phenomX.py:34
def get_amp_phase(h)
Definition: test_phenomX.py:29
def test_IMRPhenomXP_NRTidalv2_SpinTaylor()
This test checks that IMRPhenomXP_NRTidalv2 with the SpinTaylor precession (version 310) hasn't chang...
def test_IMRPhenomXP_SpinTaylor()
This test checks that IMRPhenomXP with the SpinTaylor precession option (version 310) hasn't changed.
def test_IMRPhenomXAS()
This test checks that IMRPhenomXAS hasn't changed.
def test_IMRPhenomXHM()
This test checks that IMRPhenomXHM hasn't changed.
def gen_test_data(spin1x, approximant, mode_array, lalparams=None, type='bbh', generic_spins=False, deltaF=1./4., release=None)
compute the difference between two waveforms and compare to expected value
Definition: test_phenomX.py:47