def test_CDSD_calc_vs_ref(warnings=True, verbose=True, *args, **kwargs):
''' Test partition functions calculated with CDSD energy levels against
hardcoded values '''
from radis.misc.config import getDatabankEntries
iso = 1
try:
energies = getDatabankEntries('CDSD-HITEMP-PC')['levels']
levelsfmt = getDatabankEntries('CDSD-HITEMP-PC')['levelsfmt']
Qf = PartFuncCO2_CDSDcalc(energy_levels=energies[iso],
isotope=iso,
use_cached=True,
levelsfmt=levelsfmt)
assert np.isclose(Qf.at(300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at(3000), 114689.88454184022, rtol=0.001)
assert np.isclose(Qf.at_noneq(300, 300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at_noneq(3000, 3000),
114689.88454184022,
rtol=0.001)
assert np.isclose(Qf.at_noneq(3000,
3000,
overpopulation={'(0,1)': 3},
returnQvibQrot=True)[0],
120053.34252537244,
rtol=0.001)
if verbose:
printm('Tested Q_CDSD values are correct : OK')
return True
except DatabankNotFound as err:
assert IgnoreMissingDatabase(err, __file__, warnings)
def test_CDSD_calc_vs_ref(warnings=True, verbose=True, *args, **kwargs):
"""Test partition functions calculated with CDSD energy levels against
hardcoded values"""
from radis.misc.config import getDatabankEntries
iso = 1
energies = getDatabankEntries("CDSD-HITEMP-PC")["levels"]
levelsfmt = getDatabankEntries("CDSD-HITEMP-PC")["levelsfmt"]
Qf = PartFuncCO2_CDSDcalc(
energy_levels=energies[iso],
isotope=iso,
use_cached=True,
levelsfmt=levelsfmt,
)
assert np.isclose(Qf.at(300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at(3000), 114689.88454184022, rtol=0.001)
assert np.isclose(Qf.at_noneq(300, 300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at_noneq(3000, 3000), 114689.88454184022, rtol=0.001)
assert np.isclose(
Qf.at_noneq(3000,
3000,
overpopulation={"(0,1)": 3},
returnQvibQrot=True)[0],
120053.34252537244,
rtol=0.001,
)
if verbose:
printm("Tested Q_CDSD values are correct : OK")
def test_CDSD_calc_vs_tab(verbose=True, warnings=True, *args, **kwargs):
""" Test 1: compare calculated PartFunc to the tabulated one """
from radis.misc.config import getDatabankEntries
iso = 1
database = "CDSD-HITEMP-PC"
# Compare tab to hardcoded
parfunc = getDatabankEntries(database)["parfunc"]
Qf = PartFuncCO2_CDSDtab(iso, parfunc)
assert np.isclose(Qf.at(300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at(3000), 114689.88454184022, rtol=0.001)
if verbose:
printm("Tested CDSD tabulated is correct: OK")
# Compare tab to calculated
energies = getDatabankEntries(database)["levels"]
levelsfmt = getDatabankEntries(database)["levelsfmt"]
Qfc = PartFuncCO2_CDSDcalc(energies[iso],
levelsfmt=levelsfmt,
isotope=iso,
use_cached=True)
assert np.isclose(Qf.at(300), Qfc.at(300), rtol=0.001)
assert np.isclose(Qf.at(3000), Qfc.at(3000), rtol=0.001)
if verbose:
printm("Tested CDSD Q_calc vs Q_tab give same output: OK")
return True
def test_reduced_CDSD_calc_noneq(verbose=True, warnings=True, *args, **kwargs):
""" Compare calculated partition function at equilibrium and nonequilibrium
using the CDSD-format """
from radis.misc.config import getDatabankEntries
iso = 1
database = "HITEMP-CO2-HAMIL-TEST"
# Compare tab to calculated
energies = getDatabankEntries(database)["levels"]
levelsfmt = getDatabankEntries(database)["levelsfmt"]
Qfc = PartFuncCO2_CDSDcalc(
energies[iso],
levelsfmt=levelsfmt,
isotope=iso,
use_cached=True,
verbose=verbose,
)
assert np.isclose(Qfc.at(300),
Qfc.at_noneq_3Tvib((300, 300, 300), 300),
rtol=0.001)
if verbose:
printm(
"Tested CDSD Q_calc at equilibrium and nonequilibrium give same output: OK"
)
def test_CDSD_calc_vs_tab(verbose=True, warnings=True, *args, **kwargs):
''' Test 1: compare calculated PartFunc to the tabulated one '''
from radis.misc.config import getDatabankEntries
try:
iso = 1
database = 'CDSD-HITEMP-PC'
# Compare tab to hardcoded
parfunc = getDatabankEntries(database)['parfunc']
Qf = PartFuncCO2_CDSDtab(iso, parfunc)
assert np.isclose(Qf.at(300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at(3000), 114689.88454184022, rtol=0.001)
if verbose:
printm('Tested CDSD tabulated is correct: OK')
# Compare tab to calculated
energies = getDatabankEntries(database)['levels']
levelsfmt = getDatabankEntries(database)['levelsfmt']
Qfc = PartFuncCO2_CDSDcalc(energies[iso], levelsfmt=levelsfmt, isotope=iso, use_cached=True)
assert np.isclose(Qf.at(300), Qfc.at(300), rtol=0.001)
assert np.isclose(Qf.at(3000), Qfc.at(3000), rtol=0.001)
if verbose:
printm('Tested CDSD Q_calc vs Q_tab give same output: OK')
return True
except DatabankNotFound as err:
assert IgnoreMissingDatabase(err, __file__, warnings)
def test_recompute_Q_from_QvibQrot_CDSD_PC(verbose=True,
warnings=True,
*args,
**kwargs):
'''
Calculate vibrational and rotational partition functions:
- in CDSD with (p,c) convention for vibrational levels
- under nonequilibrium
Recompute total partition function, and compare
Test if partition function can be recomputed correctly from vibrational
populations and rotational partition function (note that we are in a coupled
case so partition function is not simply the product of Qvib, Qrot)
'''
from radis.misc.config import getDatabankEntries
iso = 1
try:
energies = getDatabankEntries('CDSD-HITEMP-PC')['levels']
levelsfmt = getDatabankEntries('CDSD-HITEMP-PC')['levelsfmt']
Tvib = 1500
Trot = 300
Qf = PartFuncCO2_CDSDcalc(energies[iso],
isotope=iso,
use_cached=True,
levelsfmt=levelsfmt)
Q = Qf.at_noneq(Tvib, Trot)
_, Qvib, dfQrot = Qf.at_noneq(Tvib, Trot, returnQvibQrot=True)
if verbose:
printm('Q', Q)
if verbose:
printm('Qvib', Qvib)
# 1) Test Q vs Q recomputed from Qrot, Qvib
# Recompute Qtot
df = dfQrot
Q2 = ((df.gvib * exp(-df.Evib * hc_k / Tvib)) * df.Qrot).sum()
# Todo: non Boltzmann case
assert np.isclose(Q, Q2)
if verbose:
printm('Tested Q vs recomputed from (Qvib, Qrot) are the same: OK')
return True
except DatabankNotFound as err:
assert IgnoreMissingDatabase(err, __file__, warnings)
def build_test_databases(verbose=True):
''' Build test databases and add them in ~/.radis. Generate the file if it
doesnt exist
In particular:
- HITRAN-CO2-TEST: CO2, HITRAN 2016, 4165-4200 nm
- HITRAN-CO-TEST: CO, HITRAN 2016, 2000-2300 cm-1
These test databases are used to run the different test routines. They can
obviously be used by Users to run simulations, but we suggest Users to download
their own line databases files and add them to ~/.radis so they have more control
on it
'''
# Get list of databases
try:
dbnames = getDatabankList()
except FileNotFoundError:
dbnames = []
# %% Add test databases
def add_to_parser(config, name, dic):
for k, v in dic.items():
config[name][k] = v
if verbose: print("Adding '{0}' database in ~/.radis".format(name))
for dbname, dbentries in TEST_DATABASES.items():
if dbname in dbnames: # Check entries are correct
# for k
diff = diffDatabankEntries(getDatabankEntries(dbname),
dbentries,
verbose=False)
if diff is not None:
raise ValueError('{0}'.format(diff)+\
'\nIn ~/.radis\n----------\n{0}'.format(getDatabankEntries(dbname))+\
'\n\nExpected\n---------\n{0}\n\n'.format(dbentries)+\
'Test Database {0} doesnt match expected '.format(dbname)+\
'entries for key `{0}`. See comparison above. '.format(diff)+\
'To regenerate test databases just delete the {0} '.format(dbname)+\
'entry in your ~/.radis')
else: # add them (create ~/.radis file if doesnt exist yet)
addDatabankEntries(dbname, dbentries)
return
def test_reduced_CDSD_calc_noneq(verbose=True, warnings=True, *args, **kwargs):
"""Compare calculated partition function at equilibrium and nonequilibrium
using the CDSD-format
Examples
--------
assert Qfc.at(300) != Qfc.at_noneq_3Tvib((300, 300, 300), 300)
After redefining Evib so that Evib + Erot = E:
assert np.isclose(Qfc.at(300), Qfc.at_noneq(300, 300), rtol=0.001)
assert np.isclose(Qfc.at(300), Qfc.at_noneq_3Tvib((300, 300, 300), 300), rtol=0.001)
"""
from radis.misc.config import getDatabankEntries
from radis.test.utils import define_Evib_as_sum_of_Evibi
iso = 1
database = "HITEMP-CO2-HAMIL-TEST"
# Compare tab to calculated
energies = getDatabankEntries(database)["levels"]
levelsfmt = getDatabankEntries(database)["levelsfmt"]
Qfc = PartFuncCO2_CDSDcalc(
energies[iso],
levelsfmt=levelsfmt,
isotope=iso,
use_cached=True,
verbose=verbose,
)
# Note that partition functions are not equal because some of the energy
# goes in coupling terms in the Hamiltonian formulation
assert Qfc.at(300) != Qfc.at_noneq_3Tvib((300, 300, 300), 300)
# Below we redefine Evib so that Evib + Erot = E
define_Evib_as_sum_of_Evibi(Qfc.df)
# New Test:
assert np.isclose(Qfc.at(300), Qfc.at_noneq(300, 300), rtol=0.001)
assert np.isclose(Qfc.at(300),
Qfc.at_noneq_3Tvib((300, 300, 300), 300),
rtol=0.001)
def test_local_hdf5_lines_loading(*args, **kwargs):
"""
We use the OH HITEMP line database to test :py:func:`~radis.io.hitemp.fetch_hitemp`
and :py:func:`~radis.io.hdf5.hdf2df`
- Partial loading (only specific wavenumbers)
- Only certain isotopes
- Only certain columns
"""
fetch_hitemp("OH") # to initialize the database
path = getDatabankEntries("HITEMP-OH")["path"]
# Initialize the database
fetch_hitemp("OH")
path = getDatabankEntries("HITEMP-OH")["path"][0]
df = hdf2df(path)
wmin, wmax = df.wav.min(), df.wav.max()
assert wmin < 2300 # needed for next test to be valid
assert wmax > 2500 # needed for next test to be valid
assert len(df.columns) > 5 # many columns loaded by default
assert len(df.iso.unique()) > 1
# Test loading only certain columns
df = hdf2df(path, columns=["wav", "int"])
assert len(df.columns) == 2 and "wav" in df.columns and "int" in df.columns
# Test loading only certain isotopes
df = hdf2df(path, isotope="2")
assert df.iso.unique() == 2
# Test partial loading of wavenumbers
df = hdf2df(path, load_wavenum_min=2300, load_wavenum_max=2500)
assert df.wav.min() >= 2300
assert df.wav.max() <= 2500
# Test with only one
assert hdf2df(path, load_wavenum_min=2300).wav.min() >= 2300
# Test with the other
assert hdf2df(path, load_wavenum_max=2500).wav.max() <= 2500
def test_reduced_CDSD_calc_vs_tab(verbose=True,
warnings=True,
*args,
**kwargs):
"""Test 1: compare calculated PartFunc to the tabulated one
Version where we use the reduced set of CO2 levels (< 3000 cm-1)"""
from radis.misc.config import getDatabankEntries
iso = 1
database = "HITEMP-CO2-HAMIL-TEST"
# Compare tab to hardcoded
parfunc = getDatabankEntries(database)["parfunc"]
Qf = PartFuncCO2_CDSDtab(iso, parfunc)
assert np.isclose(Qf.at(300), 291.0447781984652, rtol=0.001)
assert np.isclose(Qf.at(3000), 114689.88454184022, rtol=0.001)
if verbose:
printm("Tested CDSD tabulated is correct: OK")
# Compare tab to calculated
energies = getDatabankEntries(database)["levels"]
levelsfmt = getDatabankEntries(database)["levelsfmt"]
Qfc = PartFuncCO2_CDSDcalc(
energies[iso],
levelsfmt=levelsfmt,
isotope=iso,
use_cached=True,
verbose=verbose,
)
assert np.isclose(
Qf.at(300), Qfc.at(300), rtol=0.01
) # reduced rtol to accommodate for the reduced set of levels in the test set
# assert np.isclose(Qf.at(3000), Qfc.at(3000), rtol=0.001) # of course doesnt work with the reduced set of levels in the test set
if verbose:
printm("Tested CDSD Q_calc vs Q_tab give same output: OK")
def setup_test_line_databases(verbose=True):
"""Build :py:data:`~radis.test.utils.TEST_DATABASES` and add them in ~/.radis.
Generate the file if it doesnt exist
In particular:
- HITRAN-CO2-TEST: CO2, HITRAN 2016, 4165-4200 nm
- HITRAN-CO-TEST: CO, HITRAN 2016, 2000-2300 cm-1
- HITEMP-CO2-TEST: CO2, HITEMP-2010, 2283.7-2285.1 cm-1, 3 isotopes
- HITEMP-CO2-HAMIL-TEST: same as previous, with (some) energy levels computed
from Tashkun effective Hamiltonian.
These test databases are used to run the different test routines. They can
obviously be used by Users to run simulations, but we suggest Users to download
their own line databases files and add them to ~/.radis so they have more control
on it
Examples
--------
Initialize the Line databases::
from radis import setup_test_line_databases
setup_test_line_databases()
Plot a CO2 spectrum at high temperature::
from radis import calc_spectrum
calc_spectrum(2284,
2285,
Tgas=2000,
pressure=1,
molecule='CO2',
isotope=1
databank='HITEMP-CO2-TEST').plot()
Note that 'HITEMP-CO2-TEST' is defined on 2283.7-2285.1 cm-1 only, as
can be shown by reading the Database information:
from radis.misc.config import printDatabankEntries
printDatabankEntries('HITEMP-CO2-TEST')
>>> HITEMP-CO2-TEST
>>> -------
>>> info : HITEMP-2010, CO2, 3 main isotope (CO2-626, 636, 628), 2283.7-2285.1 cm-1
>>> path : ['/USER/PATH/TO\\radis\\radis\\test\\files\\cdsd_hitemp_09_fragment.txt']
>>> format : cdsd-hitemp
>>> parfuncfmt : hapi
>>> levelsfmt : radis
See Also
--------
:ref:`Configuration file <label_lbl_config_file>`,
:py:func:`~radis.misc.config.getDatabankList`,
:py:func:`~radis.misc.config.printDatabankEntries`
"""
# TODO: generate large band databases for the main species (let's say CO2,
# H2O and CH4) and main isotopes by fetching the HITRAN 2016 database.
# Get list of databases
try:
dbnames = getDatabankList()
except FileNotFoundError:
dbnames = []
# %% Add test databases
def add_to_parser(config, name, dic):
for k, v in dic.items():
config[name][k] = v
if verbose:
print("Adding '{0}' database in ~/.radis".format(name))
for dbname, dbentries in TEST_DATABASES.items():
if dbname in dbnames: # Check entries are correct
# for k
diff = diffDatabankEntries(getDatabankEntries(dbname),
dbentries,
verbose=False)
if diff is not None:
raise ValueError(
"{0}".format(diff) +
"\nIn ~/.radis\n----------\n{0}".format(
getDatabankEntries(dbname)) +
"\n\nExpected\n---------\n{0}\n\n".format(dbentries) +
"Test Database {0} doesnt match expected ".format(dbname) +
"entries for key `{0}`. See comparison above. ".format(
diff) +
"To regenerate test databases just delete the {0} ".format(
dbname) + "entry in your ~/.radis")
else: # add them (create ~/.radis file if doesnt exist yet)
addDatabankEntries(dbname, dbentries)
return
def setup_test_line_databases(verbose=True):
''' Build :py:data:`~radis.test.utils.TEST_DATABASES` and add them in ~/.radis.
Generate the file if it doesnt exist
In particular:
- HITRAN-CO2-TEST: CO2, HITRAN 2016, 4165-4200 nm
- HITRAN-CO-TEST: CO, HITRAN 2016, 2000-2300 cm-1
- HITEMP-CO2-TEST: CO2, HITEMP-2010, 2283.7-2285.1 cm-1, 3 isotopes
These test databases are used to run the different test routines. They can
obviously be used by Users to run simulations, but we suggest Users to download
their own line databases files and add them to ~/.radis so they have more control
on it
See Also
--------
:ref:`Configuration file <label_lbl_config_file>`
'''
# TODO: generate large band databases for the main species (let's say CO2,
# H2O and CH4) and main isotopes by fetching the HITRAN 2016 database.
# Get list of databases
try:
dbnames = getDatabankList()
except FileNotFoundError:
dbnames = []
# %% Add test databases
def add_to_parser(config, name, dic):
for k, v in dic.items():
config[name][k] = v
if verbose:
print("Adding '{0}' database in ~/.radis".format(name))
for dbname, dbentries in TEST_DATABASES.items():
if dbname in dbnames: # Check entries are correct
# for k
diff = diffDatabankEntries(getDatabankEntries(dbname),
dbentries,
verbose=False)
if diff is not None:
raise ValueError(
'{0}'.format(diff) +
'\nIn ~/.radis\n----------\n{0}'.format(
getDatabankEntries(dbname)) +
'\n\nExpected\n---------\n{0}\n\n'.format(dbentries) +
'Test Database {0} doesnt match expected '.format(dbname) +
'entries for key `{0}`. See comparison above. '.format(
diff) +
'To regenerate test databases just delete the {0} '.format(
dbname) + 'entry in your ~/.radis')
else: # add them (create ~/.radis file if doesnt exist yet)
addDatabankEntries(dbname, dbentries)
return
def register_database(databank_name, path_list, molecule, wmin, wmax,
download_date, urlname, verbose):
"""Add to registered databases in RADIS config file.
If database exists, assert it has the same entries.
Parameters
----------
databank_name: str
name of the database in :ref:`~/.radis config file <label_lbl_config_file>`
Other Parameters
----------------
verbose: bool
Returns
-------
None:
adds to :ref:`~/.radis <label_lbl_config_file>` with all the input
parameters. Also adds ::
format : "hdf5"
parfuncfmt : "hapi" # TIPS-2017 for equilibrium partition functions
And if the molecule is in :py:attr:`~radis.db.MOLECULES_LIST_NONEQUILIBRIUM`::
levelsfmt : "radis" # use RADIS spectroscopic constants for rovibrational energies (nonequilibrium)
"""
dict_entries = {
"info":
f"HITEMP {molecule} lines ({wmin:.1f}-{wmax:.1f} cm-1) with TIPS-2017 (through HAPI) for partition functions",
"path": path_list,
"format": "hdf5",
"parfuncfmt": "hapi",
"wavenumber_min": f"{wmin}",
"wavenumber_max": f"{wmax}",
"download_date": download_date,
"download_url": urlname,
}
if molecule in MOLECULES_LIST_NONEQUILIBRIUM:
dict_entries[
"info"] += " and RADIS spectroscopic constants for rovibrational energies (nonequilibrium)"
dict_entries["levelsfmt"] = "radis"
# Register database in ~/.radis to be able to use it with load_databank()
try:
addDatabankEntries(databank_name, dict_entries)
except DatabaseAlreadyExists as err:
# Check that the existing database had the same entries
try:
from radis.misc.config import getDatabankEntries
for k, v in getDatabankEntries(databank_name).items():
if k == "download_date":
continue
assert dict_entries[k] == v
# TODO @dev : replace once we have configfile as JSON (https://github.com/radis/radis/issues/167)
except AssertionError:
raise DatabaseAlreadyExists(
f"{databank_name} already exists in your ~/.radis config file. "
+
"Remove it from your config file, or choose a different name "
+
"for the downloaded database with `fetch_hitemp(databank_name=...)`"
) from err
else: # no other error raised
if verbose:
print(
f"{databank_name} already registered in ~/.radis config file, with the same parameters."
)
def test_all_calc_methods_CO2pcN(verbose=True,
plot=False,
warnings=True,
rtol=1e-3,
*args,
**kwargs):
"""Test same spectrum for 3 different calculation variants (equilibrium,
non-equilibrium, per band and recombine
Uses CO2 Levels database where the energy partitioning is done as follow:
2 nonequilibrium modes
Evib is the minimum of a "p,c,N" group
Erot = E - Evib
This corresponds to the levelsfmt = 'cdsd-pcN' in
:data:`~radis.lbl.loader.KNOWN_LVLFORMAT`
"""
from radis.misc.config import getDatabankEntries
from radis.test.utils import (
define_Evib_as_min_of_polyad,
discard_lines_with_na_levels,
setup_test_line_databases,
)
if plot: # Make sure matplotlib is interactive so that test are not stuck in pytest
import matplotlib.pyplot as plt
plt.ion()
#%%
Tgas = 500
iso = 1
sf = SpectrumFactory(
wavenum_min=2284,
wavenum_max=2285,
broadening_max_width=5, # TODO @EP: crashes with 0.3?
mole_fraction=1,
path_length=0.025,
cutoff=1e-25,
molecule="CO2",
isotope=iso,
db_use_cached=True,
lvl_use_cached=True,
verbose=verbose,
)
sf.warnings["MissingSelfBroadeningWarning"] = "ignore"
sf.warnings["NegativeEnergiesWarning"] = "ignore"
sf.warnings["HighTemperatureWarning"] = "ignore"
# Preparation:
setup_test_line_databases()
# Generate a Levels database with p,c,N energy partitioning
# ... copy "HITEMP-CO2-HAMIL-TEST" info
database_kwargs = getDatabankEntries("HITEMP-CO2-HAMIL-TEST")
# ... adapt it to 'cdsd-pcN' mode
del database_kwargs["info"]
database_kwargs["levelsfmt"] = "cdsd-pcN"
# ... load the new database
sf.load_databank(**database_kwargs)
# Now, define Evib:
Q_calc = sf.parsum_calc["CO2"][1]["X"]
Q_calc.df = define_Evib_as_min_of_polyad(Q_calc.df, keys=["p", "c", "N"])
# With this Evib definition, clean the Lines database from where Evib is not defined
# (because Levels does not exist in the reduced, test Level Database)
discard_lines_with_na_levels(sf)
# %%---------------------
# Ready, let's start the tests:
s_bands = sf.non_eq_bands(Tvib=Tgas, Trot=Tgas)
lvl = LevelsList(sf.parsum_calc["CO2"][iso]["X"], s_bands,
sf.params.levelsfmt)
s_bd = lvl.non_eq_spectrum(Tvib=Tgas, Trot=Tgas)
s_nq = sf.non_eq_spectrum(Tvib=Tgas, Trot=Tgas)
s_eq = sf.eq_spectrum(Tgas=Tgas)
#
if plot:
fig = plt.figure(fig_prefix + "Compare all calc methods")
s_bd.plot(nfig=fig.number, color="b", lw=5, label="from bands code")
s_nq.plot(nfig=fig.number, lw=3, label="non eq code")
s_eq.plot(nfig=fig.number, lw=2, color="r", label="equilibrum code")
plt.legend()
assert np.isclose(s_bd.get_integral("abscoeff"),
s_nq.get_integral("abscoeff"),
rtol=rtol)
assert np.isclose(s_bd.get_integral("abscoeff"),
s_eq.get_integral("abscoeff"),
rtol=rtol)
assert np.isclose(s_nq.get_integral("abscoeff"),
s_eq.get_integral("abscoeff"),
rtol=rtol)
# TODO @EP: assertion fail in emission. This is due to the slight shift
# in intensity also observed in the Planck test (test_base.py::test_optically_thick_limit_1iso()).
# assert np.isclose(s_bd.get_power(), s_nq.get_power(), rtol=rtol)
# assert np.isclose(s_bd.get_power(), s_eq.get_power(), rtol=rtol)
# assert np.isclose(s_nq.get_power(), s_eq.get_power(), rtol=rtol)
return True
