def main():
sample = Hkl.Sample.new("toto")
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54, math.radians(90.),
math.radians(90.), math.radians(90.))
sample.lattice_set(lattice)
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
for key, factory in Hkl.factories().iteritems():
geometry = factory.create_new_geometry()
engines = factory.create_new_engine_list()
# here we set the detector arm with only positiv values for
# now tth or delta arm
for axis in geometry.axis_names_get():
if axis in ["tth", "delta"]:
tmp = geometry.axis_get(axis)
tmp.min_max_set(0, 180., Hkl.UnitEnum.USER)
geometry.axis_set(axis, tmp)
engines.init(geometry, detector, sample)
engines_names = [engine.name_get() for engine in engines.engines_get()]
if 'hkl' in engines_names:
plot_hkl_trajectory(key,
geometry,
engines,
hkl1=[0, 0, 1],
hkl2=[0, 1, 1],
n=100)
pp.close()
def test_geometry_api(self):
"""
enforce the geometry API
"""
# get the config for a given geometry and create the
# corresponding HklGeometry
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
sample = Hkl.Sample.new("toto")
# source access
wavelength = 1.
geometry.wavelength_set(wavelength, Hkl.UnitEnum.USER)
self.assertTrue(wavelength == geometry.wavelength_get(
Hkl.UnitEnum.USER)) # noqa
# set the geometry axes values
values_w = [0, 30, 0, 0, 0, 60]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
values_r = geometry.axis_values_get(Hkl.UnitEnum.USER)
# check that the read and write values of the geometry are
# almost equals
for r, w in zip(values_w, values_r):
self.assertAlmostEqual(r, w)
# check that we can access the axes
axis_names = geometry.axis_names_get()
for name in axis_names:
axis = geometry.axis_get(name)
axis.min_max_set(0, math.radians(180), Hkl.UnitEnum.USER)
v = axis.axis_v_get()
q = axis.quaternion_get()
geometry.axis_set(name, axis)
# check xxx_rotation_get
q = geometry.sample_rotation_get(sample)
m = q.to_matrix()
self.assertTrue(type(m) == Hkl.Matrix)
self.assertTrue(type(q) == Hkl.Quaternion)
q = geometry.detector_rotation_get(detector)
m = q.to_matrix()
self.assertTrue(type(m) == Hkl.Matrix)
self.assertTrue(type(q) == Hkl.Quaternion)
del sample
del detector
del geometry
def main():
sample = Hkl.Sample.new("toto")
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54,
math.radians(90.),
math.radians(90.),
math.radians(90.))
sample.lattice_set(lattice)
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
for key, factory in Hkl.factories().iteritems():
geometry = factory.create_new_geometry()
engines = factory.create_new_engine_list()
# here we set the detector arm with only positiv values for
# now tth or delta arm
for axis in geometry.axis_names_get():
if axis in ["tth", "delta"]:
tmp = geometry.axis_get(axis)
tmp.min_max_set(0, 180., Hkl.UnitEnum.USER)
geometry.axis_set(axis, tmp)
engines.init(geometry, detector, sample)
engines_names = [engine.name_get() for engine in engines.engines_get()]
if 'hkl' in engines_names:
plot_hkl_trajectory(key, geometry, engines,
hkl1=[0, 0, 1], hkl2=[0, 1, 1], n=100)
pp.close()
def test_petraIII(self):
# RUBh = kf - ki = (P ki - ki) = (P - I) ki
sample = new_sample(1.54, 1.54, 1.54,
90, 90, 90,
-90, 0, 0)
UB = hkl_matrix_to_numpy(sample.UB_get())
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
values_w = [0, 30, 0, 0, 0, 60] # mu, omega, chi, phi, gamma, delta
geometry = new_geometry("E6C", values_w)
# the hkl vector express in the laboratory basis.
hkl = [1, 1, 1]
R = hkl_matrix_to_numpy(geometry.sample_rotation_get(sample).to_matrix())
v = dot(dot(R, UB), hkl)
# compute kf
ki = [1, 0, 0]
P = hkl_matrix_to_numpy(geometry.detector_rotation_get(detector).to_matrix())
kf = dot(P, ki)
Q = kf - ki
# print v
self.assertTrue(True)
def test_quaternion_api(self):
"""
enforce the Vector api
"""
q = Hkl.Quaternion()
self.assertTrue(type(q) == Hkl.Quaternion)
self.assertTrue(type(q.data) == list)
self.assertTrue(4 == len(q.data))
del q
def test_detector_api(self):
"""
enforce the detector API
"""
# create an 0D HklDetector
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
self.assertTrue(type(detector) is Hkl.Detector)
del detector
def test_all():
detector = Hkl.Detector().factory_new(getattr(Hkl.DetectorType, '0D'))
# attache to the second holder
detector.idx = 1
# create the right diffractometer geometry
config = Hkl.Geometry.factory_get_config_from_type(Hkl.GeometryType.KAPPA6C)
geometry = Hkl.Geometry.factory_newv(config, [50. * math.pi / 180.])
geometry.source.wave_length = 1.54
# configure the sample
sample = Hkl.Sample.new("toto")
sample.set_lattice(1.54, 1.54, 1.54, 90., 90., 90.)
# create the Engines
engines = Hkl.engine_list_factory(config)
for engine in engines.engines:
print engine
def test_engine_api(self):
"""
enforce the HklEngine API
"""
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
values_w = [0., 30., 0., 0., 0., 60.]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
sample = Hkl.Sample.new("toto")
lattice = sample.lattice_get()
lattice.set(1.54, 1.54, 1.54, 90, 90, 90, Hkl.UnitEnum.USER)
sample.lattice_set(lattice)
# compute all the pseudo axes managed by all engines
engines = factory.create_new_engine_list()
engines.init(geometry, detector, sample)
engines.get()
# get the hkl engine and do a computation
hkl = engines.engine_get_by_name("hkl")
values = hkl.pseudo_axis_values_get(Hkl.UnitEnum.USER)
# check for all modes
for mode in hkl.modes_names_get():
self.assertTrue(type(mode) is str)
# set the hkl engine and get the results
for _ in range(100):
try:
solutions = hkl.pseudo_axis_values_set(values,
Hkl.UnitEnum.USER)
self.assertTrue(type(solutions) is Hkl.GeometryList)
for item in solutions.items():
self.assertTrue(type(item) is Hkl.GeometryListItem)
self.assertTrue(type(item.geometry_get()) is Hkl.Geometry)
values[1] += .01
except GLib.GError, err:
print values, err
def test_reflection_api(self):
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
values_w = [0., 30., 0., 0., 0., 60.]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
sample = Hkl.Sample.new("toto")
# add reflection
r1 = sample.add_reflection(geometry, detector, 1, 1, 1)
r2 = sample.add_reflection(geometry, detector, 1, 1, 1)
# get the hkl part
self.assertTrue(r2.hkl_get() == (1.0, 1.0, 1.0))
r2.hkl_set(1, 0, 1)
self.assertTrue(r2.hkl_get() == (1.0, 0.0, 1.0))
# get the flag part
flag = r1.flag_get()
r1.flag_set(flag)
# get the geometry part
g = r1.geometry_get()
r1.geometry_set(g)
# compute the angles
sample.get_reflection_measured_angle(r1, r2)
sample.get_reflection_theoretical_angle(r1, r2)
# remove all the reflections
reflections = sample.reflections_get()
for reflection in reflections:
sample.del_reflection(reflection)
del reflections
del sample
def get_diffractometer(hfile):
""" Construct a Diffractometer from a NeXus file """
node = get_nxclass(hfile, 'NXdiffractometer')
name = node.type[0][:-1]
ub = node.UB[:]
factory = Hkl.factories()[name]
geometry = factory.create_new_geometry()
# wavelength = get_nxclass(hfile, 'NXmonochromator').wavelength[0]
# geometry.wavelength_set(wavelength)
return Diffractometer(name, ub, geometry)
def test_geometry_api(self):
"""
enforce the geometry API
"""
# get the config for a given geometry and create the
# corresponding HklGeometry
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
sample = Hkl.Sample.new("toto")
# source access
wavelength = 1.
geometry.wavelength_set(wavelength, Hkl.UnitEnum.USER)
self.assertTrue(wavelength == geometry.wavelength_get(Hkl.UnitEnum.USER)) # noqa
# set the geometry axes values
values_w = [0, 30, 0, 0, 0, 60]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
values_r = geometry.axis_values_get(Hkl.UnitEnum.USER)
# check that the read and write values of the geometry are
# almost equals
for r, w in zip(values_w, values_r):
self.assertAlmostEqual(r, w)
# check that we can access the axes
axis_names = geometry.axis_names_get()
for name in axis_names:
axis = geometry.axis_get(name)
axis.min_max_set(0, math.radians(180), Hkl.UnitEnum.USER)
v = axis.axis_v_get()
q = axis.quaternion_get()
geometry.axis_set(name, axis)
# check xxx_rotation_get
q = geometry.sample_rotation_get(sample)
m = q.to_matrix()
self.assertTrue(type(m) == Hkl.Matrix)
self.assertTrue(type(q) == Hkl.Quaternion)
q = geometry.detector_rotation_get(detector)
m = q.to_matrix()
self.assertTrue(type(m) == Hkl.Matrix)
self.assertTrue(type(q) == Hkl.Quaternion)
del sample
del detector
del geometry
def test_vector_api(self):
"""
enforce the Vector api
"""
v = Hkl.Vector()
self.assertTrue(type(v) == Hkl.Vector)
self.assertTrue(type(v.data) == list)
self.assertTrue(3 == len(v.data))
self.assertTrue(v.data == [0.0, 0.0, 0.0])
v.init(1, 2, 3)
self.assertTrue(v.data == [1.0, 2.0, 3.0])
del v
def get_diffractometer(hfile):
""" Construct a Diffractometer from a NeXus file """
node = get_nxclass(hfile, 'NXdiffractometer')
name = node.type[0][:-1]
ub = node.UB[:]
factory = Hkl.factories()[name]
geometry = factory.create_new_geometry()
# wavelength = get_nxclass(hfile, 'NXmonochromator').wavelength[0]
# geometry.wavelength_set(wavelength)
return Diffractometer(name, ub, geometry)
def test_factory_api(self):
"""
enforce the Factory API
"""
# factories dict <name, Factory>
factories = Hkl.factories()
for key, factory in factories.iteritems():
self.assertTrue(type(key) == str)
self.assertTrue(type(factory) == Hkl.Factory)
# create all the geometry and engines
geometry = factory.create_new_geometry()
self.assertTrue(type(geometry) == Hkl.Geometry)
engines = factory.create_new_engine_list()
self.assertTrue(type(engines) == Hkl.EngineList)
del factories
def get_diffractometer(hfile):
""" Construct a Diffractometer from a NeXus file """
node = get_nxclass(hfile, 'NXdiffractometer')
name = node_as_string(node.type)
if name.endswith('\n'):
# remove the last "\n" char
name = name[:-1]
ub = node.UB[:]
factory = Hkl.factories()[name]
geometry = factory.create_new_geometry()
# wavelength = get_nxclass(hfile, 'NXmonochromator').wavelength[0]
# geometry.wavelength_set(wavelength)
return Diffractometer(name, ub, geometry)
def test_engine_list_api(self):
factories = Hkl.factories()
for key, factory in factories.items():
# print("diffractometer geometry factory = " + str(key))
engines = factory.create_new_engine_list()
# check the parameters
names = engines.parameters_names_get()
self.assertTrue(type(names) is list)
[self.assertTrue(type(_) is str) for _ in names]
# get/set the parameters
for name in names:
p = engines.parameter_get(name)
self.assertTrue(type(p) is Hkl.Parameter)
engines.parameter_set(name, p)
# check that we can get/set the parameters values
values = engines.parameters_values_get(Hkl.UnitEnum.USER)
[self.assertTrue(type(_) is float) for _ in values]
engines.parameters_values_set(values, Hkl.UnitEnum.USER)
DEFAULT_PACKAGE_LIST = "hkl hklpy gobject-introspection".split()
# 2018 CODATA recommended lattice parameter of silicon, Angstrom.
# see: https://physics.nist.gov/cgi-bin/cuu/Value?asil
SI_LATTICE_PARAMETER = 5.431020511
# also provide the reported uncertainty, in case anyone is interested
SI_LATTICE_PARAMETER_UNCERTAINTY = 0.000000089
def new_detector(dtype=0):
"""Create a new HKL-library detector"""
return libhkl.Detector.factory_new(libhkl.DetectorType(dtype))
if libhkl:
diffractometer_types = tuple(sorted(libhkl.factories().keys()))
UserUnits = libhkl.UnitEnum.USER
DefaultUnits = libhkl.UnitEnum.DEFAULT
# fmt: off
units = {"user": UserUnits, "default": DefaultUnits}
# fmt: on
else:
diffractometer_types = ()
units = {}
def to_numpy(mat):
"""Convert an hkl ``Matrix`` to a numpy ndarray
Parameters
def new_detector(dtype=0):
"""Create a new HKL-library detector"""
return libhkl.Detector.factory_new(libhkl.DetectorType(dtype))
def test_engine_api(self):
"""
enforce the HklEngine API
"""
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
values_w = [0., 30., 0., 0., 0., 60.]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
sample = Hkl.Sample.new("toto")
lattice = sample.lattice_get()
lattice.set(1.54, 1.54, 1.54, 90, 90, 90, Hkl.UnitEnum.USER)
sample.lattice_set(lattice)
# compute all the pseudo axes managed by all engines
engines = factory.create_new_engine_list()
engines.init(geometry, detector, sample)
engines.get()
# get the hkl engine and do a computation
hkl = engines.engine_get_by_name("hkl")
values = hkl.pseudo_axis_values_get(Hkl.UnitEnum.USER)
# check for all modes
for mode in hkl.modes_names_get():
self.assertTrue(type(mode) is str)
# set the hkl engine and get the results
for _ in range(100):
try:
solutions = hkl.pseudo_axis_values_set(values,
Hkl.UnitEnum.USER)
self.assertTrue(type(solutions) is Hkl.GeometryList)
for item in solutions.items():
self.assertTrue(type(item) is Hkl.GeometryListItem)
self.assertTrue(type(item.geometry_get()) is Hkl.Geometry)
values[1] += .01
except GLib.GError as err:
print(values, err)
# check that all the values computed are reachable
for engine in engines.engines_get():
self.assertTrue(type(engine) is Hkl.Engine)
self.assertTrue(type(engine.name_get()) is str)
self.assertTrue(type(engine.pseudo_axis_names_get()) is list)
self.assertTrue(type(engine.modes_names_get()) is list)
self.assertTrue(len(engine.modes_names_get()))
for mode in engine.modes_names_get():
self.assertTrue(type(mode) is str)
values = engine.pseudo_axis_values_get(Hkl.UnitEnum.USER)
self.assertTrue(type(values) is list)
for value in values:
self.assertTrue(type(value) is float)
# check that all engine parameters and axes are reachables
for engine in engines.engines_get():
for mode in engine.modes_names_get():
engine.current_mode_set(mode)
parameters = engine.parameters_names_get()
self.assertTrue(type(parameters) is list)
[self.assertTrue(type(_) is str) for _ in parameters]
# all together
values = engine.parameters_values_get(Hkl.UnitEnum.USER)
[self.assertTrue(type(_) is float) for _ in values]
engine.parameters_values_set(values, Hkl.UnitEnum.USER)
# one by one
for parameter in parameters:
p = engine.parameter_get(parameter)
self.assertTrue(type(p.description_get()) is str)
# check that parameters are writable.
values = engine.parameters_values_get(Hkl.UnitEnum.USER)
values = [1.] * len(values)
engine.parameters_values_set(values, Hkl.UnitEnum.USER)
[
self.assertTrue(ref == v) for ref, v in zip(
values, engine.parameters_values_get(
Hkl.UnitEnum.USER))
]
axes_r = engine.axis_names_get(Hkl.EngineAxisNamesGet.READ)
self.assertTrue(type(axes_r) is list)
[self.assertTrue(type(_) is str) for _ in axes_r]
axes_w = engine.axis_names_get(Hkl.EngineAxisNamesGet.WRITE)
self.assertTrue(type(axes_w) is list)
[self.assertTrue(type(_) is str) for _ in axes_w]
# check all the capabilities
for engine in engines.engines_get():
capabilities = engine.capabilities_get()
self.assertTrue(capabilities & Hkl.EngineCapabilities.READABLE)
if engine.name_get() not in ["incidence", "emergence"]:
self.assertTrue(capabilities & Hkl.EngineCapabilities.WRITABLE)
if engine.name_get() == "psi":
self.assertTrue(capabilities
& Hkl.EngineCapabilities.INITIALIZABLE)
# check initialized_get/set
for engine in engines.engines_get():
initialized = engine.initialized_get()
capabilities = engine.capabilities_get()
if capabilities & Hkl.EngineCapabilities.INITIALIZABLE:
engine.initialized_set(False)
self.assertTrue(False == engine.initialized_get())
engine.initialized_set(True)
self.assertTrue(True == engine.initialized_get())
# check all the dependencies
for engine in engines.engines_get():
dependencies = engine.dependencies_get()
self.assertTrue(dependencies & Hkl.EngineDependencies.AXES)
def from_numpy_to_hkl_vector(v):
V = Hkl.Vector()
V.init(v[0], v[1], v[2])
return V
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import math
import numpy
from gi.repository import GLib
from gi.repository import Hkl
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
detector.idx_set(1)
config = Hkl.geometry_factory_get_config_from_type(Hkl.GeometryType.KAPPA6C)
geometry = Hkl.Geometry.factory_newv(config, [math.radians(50.)])
delta = geometry.axes()[5]
# delta.parameter.range.min = 0
# values_w = [0., -60, 0., 90., 0., 60.]
values_w = [0., 120, 0., -90., 0., 60.]
geometry.set_axis_values_unit(values_w)
axis_names = [axis.name for axis in geometry.axes()]
sample = Hkl.Sample.new("toto")
lattice = sample.lattice_get()
lattice.set(1.54, 1.54, 1.54, math.radians(90.0), math.radians(90.0),
math.radians(90.))
sample.lattice_set(lattice)
def get_detector(hfile):
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
return Detector("imxpads140", detector)
GLib = None
print('[!!] Failed to import Hkl library; diffractometer support '
'disabled ({})'.format(ex),
file=sys.stderr)
logger = logging.getLogger(__name__)
def new_detector(dtype=0):
'''Create a new HKL-library detector'''
return hkl_module.Detector.factory_new(hkl_module.DetectorType(dtype))
if hkl_module:
diffractometer_types = tuple(sorted(hkl_module.factories().keys()))
UserUnits = hkl_module.UnitEnum.USER
DefaultUnits = hkl_module.UnitEnum.DEFAULT
units = {'user': UserUnits, 'default': DefaultUnits}
else:
diffractometer_types = ()
units = {}
def to_numpy(mat):
"""Convert an hkl ``Matrix`` to a numpy ndarray
Parameters
----------
mat : Hkl.Matrix
You should have received a copy of the GNU General Public License
along with the hkl library. If not, see <http://www.gnu.org/licenses/>.
Copyright (C) 2003-2012 Synchrotron SOLEIL
L'Orme des Merisiers Saint-Aubin
BP 48 91192 GIF-sur-YVETTE CEDEX
Authors: Picca Frédéric-Emmanuel <*****@*****.**>
"""
import math
from gi.repository import GLib
from gi.repository import Hkl
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
values_w = [0., 30., 0., 0., 0., 60.]
geometry.axis_values_set(values_w, Hkl.UnitEnum.USER)
axis_names = geometry.axis_names_get()
print geometry.name_get(), "diffractometer has", len(axis_names),\
"axes : ", axis_names
print values_w
sample = Hkl.Sample.new("toto")
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54,
math.radians(90.0),
math.radians(90.0),
math.radians(90.))
sample.lattice_set(lattice)
GLib = None
print('[!!] Failed to import Hkl library; diffractometer support '
'disabled ({})'.format(ex), file=sys.stderr)
logger = logging.getLogger(__name__)
def new_detector(dtype=0):
'''Create a new HKL-library detector'''
return hkl_module.Detector.factory_new(hkl_module.DetectorType(dtype))
if hkl_module:
diffractometer_types = tuple(sorted(hkl_module.factories().keys()))
UserUnits = hkl_module.UnitEnum.USER
DefaultUnits = hkl_module.UnitEnum.DEFAULT
units = {'user': UserUnits,
'default': DefaultUnits
}
else:
diffractometer_types = ()
units = {}
def to_numpy(mat):
"""Convert an hkl ``Matrix`` to a numpy ndarray
Parameters
def new_detector(dtype=0):
'''Create a new HKL-library detector'''
return hkl_module.Detector.factory_new(hkl_module.DetectorType(dtype))
# -*- coding: utf-8 -*-
import math
import numpy
from gi.repository import GLib
from gi.repository import Hkl
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
detector.idx_set(1)
config = Hkl.geometry_factory_get_config_from_type(
Hkl.GeometryType.KAPPA6C)
geometry = Hkl.Geometry.factory_newv(config, [math.radians(50.)])
delta = geometry.axes()[5]
# delta.parameter.range.min = 0
# values_w = [0., -60, 0., 90., 0., 60.]
values_w = [0., 120, 0., -90., 0., 60.]
geometry.set_axis_values_unit(values_w)
axis_names = [axis.name for axis in geometry.axes()]
sample = Hkl.Sample.new("toto")
lattice = sample.lattice_get()
lattice.set(1.54, 1.54, 1.54,
math.radians(90.0),
math.radians(90.0),
math.radians(90.))
sample.lattice_set(lattice)
def new_geometry(dtype, init_values):
factory = Hkl.factories()[dtype]
geometry = factory.create_new_geometry()
geometry.axis_values_set(init_values, Hkl.UnitEnum.USER)
return geometry
import math
import numpy
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from gi.repository import GLib
from gi.repository import Hkl
sample = Hkl.Sample.new("toto")
lattice = Hkl.Lattice.new(1.54, 1.54, 1.54, math.radians(90), math.radians(90),
math.radians(90))
sample.lattice_set(lattice)
detector = Hkl.Detector.factory_new(Hkl.DetectorType(0))
factory = Hkl.factories()['K6C']
geometry = factory.create_new_geometry()
axis_names = geometry.axis_names_get()
# set the initial position
geometry.axis_values_set([0, 120, 0, -90, 0, 60], Hkl.UnitEnum.USER)
# get all engines for a given configuration
engines = factory.create_new_engine_list()
# prepare the engines to work with the related geometry, detector and
# sample
engines.init(geometry, detector, sample)
def new_hkl_engines(dtype):
factory = Hkl.factories()[dtype]
engines = factory.create_new_engine_list()
return engines
