From 2a55cd0dce04918fa033475be1e92083b35a9c18 Mon Sep 17 00:00:00 2001 From: Frederik Van der Veken Date: Fri, 1 Mar 2024 21:38:54 +0100 Subject: [PATCH 1/8] Two fixes: 1) the variable 'prebuilt_kernels_path' was not passed correctly to BeamElement.compile_kernels, making it fail (as it was then passed to xo.Struct that doesn't know the variable), and 2) the PerParticlePyMethod did not have this flag at all, making it skip prebuilt kernels. --- xtrack/base_element.py | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/xtrack/base_element.py b/xtrack/base_element.py index b73153c8f..280efdc89 100644 --- a/xtrack/base_element.py +++ b/xtrack/base_element.py @@ -290,28 +290,25 @@ def compile_kernels(self, extra_classes=(), *args, **kwargs): local_particle_src=Particles.gen_local_particle_api())) context = self._context cls = type(self) + prebuilt_kernels_path = kwargs.pop('prebuilt_kernels_path') if context.allow_prebuilt_kernels: - import xtrack as xt - from xtrack.prebuild_kernels import ( - get_suitable_kernel, - XT_PREBUILT_KERNELS_LOCATION - ) + from xtrack.prebuild_kernels import get_suitable_kernel # Default config is empty (all flags default to not defined, which # enables most behaviours). In the future this has to be looked at # whenever a new flag is needed. _default_config = {} _print_state = Print.suppress - # Print.suppress = True + Print.suppress = True classes = (cls._XoStruct,) + tuple(extra_classes) kernel_info = get_suitable_kernel( _default_config, classes ) - # Print.suppress = _print_state + Print.suppress = _print_state if kernel_info: module_name, _ = kernel_info kernels = context.kernels_from_file( module_name=module_name, - containing_dir=XT_PREBUILT_KERNELS_LOCATION, + containing_dir=prebuilt_kernels_path, kernel_descriptions=self._kernels, ) context.kernels.update(kernels) @@ -372,20 +369,24 @@ def _arr2ctx(self, arr): class PerParticlePyMethod: - def __init__(self, kernel_name, element, additional_arg_names): + def __init__(self, kernel_name, element, additional_arg_names, prebuilt_kernels_path=None): self.kernel_name = kernel_name self.element = element self.additional_arg_names = additional_arg_names + self.prebuilt_kernels_path = prebuilt_kernels_path def __call__(self, particles, increment_at_element=False, **kwargs): - print(f'===> Calling PerParticlePyMethod {self.kernel_name}') instance = self.element context = instance.context - if self.kernel_name not in context.kernels: - instance.compile_kernels() + only_if_needed = kwargs.pop('only_if_needed', True) + BeamElement.compile_kernels( + instance, + prebuilt_kernels_path=self.prebuilt_kernels_path, + only_if_needed=only_if_needed, - kernel = context.kernels[self.kernel_name] + ) + kernel = getattr(context.kernels, self.kernel_name) if hasattr(self.element, 'io_buffer') and self.element.io_buffer is not None: io_buffer_arr = self.element.io_buffer.buffer @@ -407,9 +408,11 @@ def __init__(self, kernel_name, additional_arg_names): self.additional_arg_names = additional_arg_names def __get__(self, instance, owner): + kernels_path = getattr(owner, 'prebuilt_kernels_path', None) return PerParticlePyMethod(kernel_name=self.kernel_name, element=instance, - additional_arg_names=self.additional_arg_names) + additional_arg_names=self.additional_arg_names, + prebuilt_kernels_path=kernels_path) class PyMethod: @@ -457,3 +460,4 @@ def __get__(self, instance, owner): element=instance, additional_arg_names=self.additional_arg_names, prebuilt_kernels_path=kernels_path) + From 7978fa891a3ffe2676088b56a131273091a347ae Mon Sep 17 00:00:00 2001 From: Frederik Van der Veken Date: Fri, 1 Mar 2024 21:42:56 +0100 Subject: [PATCH 2/8] Fix: When looking for a suitable kernel, an empty config would not find anything. Now it defaults to the default config of a Line. --- xtrack/prebuild_kernels.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/xtrack/prebuild_kernels.py b/xtrack/prebuild_kernels.py index 222555daf..56112e3f0 100644 --- a/xtrack/prebuild_kernels.py +++ b/xtrack/prebuild_kernels.py @@ -206,6 +206,10 @@ def get_suitable_kernel( requested_class_names = [cls for cls in requested_class_names if cls != 'Particles' and cls != 'ParticlesBase'] + # Get a default config + if config == {}: + config = xt.Line().config + for module_name, kernel_metadata in enumerate_kernels(): if verbose: _print(f"==> Considering the precompiled kernel `{module_name}`...") From 9019ac1c8c87b369ce662c1527449fe363ac3a3a Mon Sep 17 00:00:00 2001 From: Frederik Van der Veken Date: Fri, 1 Mar 2024 22:32:11 +0100 Subject: [PATCH 3/8] Added Particles._init_random_number_generator to prebuilt kernels --- xtrack/base_element.py | 7 +++---- xtrack/particles/particles.py | 26 +++++++++++++++++++++----- xtrack/random/random_generators.py | 3 --- 3 files changed, 24 insertions(+), 12 deletions(-) diff --git a/xtrack/base_element.py b/xtrack/base_element.py index 280efdc89..9367ba07c 100644 --- a/xtrack/base_element.py +++ b/xtrack/base_element.py @@ -377,7 +377,7 @@ def __init__(self, kernel_name, element, additional_arg_names, prebuilt_kernels_ def __call__(self, particles, increment_at_element=False, **kwargs): instance = self.element - context = instance.context + context = instance._context only_if_needed = kwargs.pop('only_if_needed', True) BeamElement.compile_kernels( @@ -386,12 +386,11 @@ def __call__(self, particles, increment_at_element=False, **kwargs): only_if_needed=only_if_needed, ) - kernel = getattr(context.kernels, self.kernel_name) + kernel = context.kernels[self.kernel_name] if hasattr(self.element, 'io_buffer') and self.element.io_buffer is not None: io_buffer_arr = self.element.io_buffer.buffer else: - context = kernel.context io_buffer_arr = context.zeros(1, dtype=np.int8) # dummy kernel.description.n_threads = particles._capacity @@ -434,7 +433,7 @@ def __call__(self, **kwargs): only_if_needed=only_if_needed, ) - kernel = getattr(context.kernels, self.kernel_name) + kernel = context.kernels[self.kernel_name] el_var_name = None for arg in instance._kernels[self.kernel_name].args: diff --git a/xtrack/particles/particles.py b/xtrack/particles/particles.py index e56dce4f0..a3e263480 100644 --- a/xtrack/particles/particles.py +++ b/xtrack/particles/particles.py @@ -4,17 +4,18 @@ # ######################################### # import numpy as np -import xobjects as xo - from pathlib import Path -from .constants import PROTON_MASS_EV - from scipy.constants import e as qe from scipy.constants import c as clight from scipy.constants import epsilon_0 +import xobjects as xo +from xobjects.general import Print from xobjects import BypassLinked +from xtrack.prebuild_kernels import XT_PREBUILT_KERNELS_LOCATION + +from .constants import PROTON_MASS_EV LAST_INVALID_STATE = -999999999 @@ -98,6 +99,7 @@ class Particles(xo.HybridClass): _kernels = { 'Particles_initialize_rand_gen': xo.Kernel( + c_name="Particles_initialize_rand_gen", args=[ xo.Arg(xo.ThisClass, name='particles'), xo.Arg(xo.UInt32, pointer=True, name='seeds'), @@ -995,6 +997,21 @@ def _init_random_number_generator(self, seeds=None): Initialize state of the random number generator (possibility to providing a seed for each particle). """ + context = self._buffer.context + if context.allow_prebuilt_kernels: + from xtrack.prebuild_kernels import get_suitable_kernel + _print_state = Print.suppress + Print.suppress = True + kernel_info = get_suitable_kernel({}, (self.__class__._XoStruct,)) + Print.suppress = _print_state + if kernel_info: + module_name, _ = kernel_info + kernels = context.kernels_from_file( + module_name=module_name, + containing_dir=XT_PREBUILT_KERNELS_LOCATION, + kernel_descriptions=self._kernels, + ) + context.kernels.update(kernels) self.compile_kernels(only_if_needed=True) if seeds is None: @@ -1005,7 +1022,6 @@ def _init_random_number_generator(self, seeds=None): if not hasattr(seeds, 'dtype') or seeds.dtype != np.uint32: seeds = np.array(seeds, dtype=np.uint32) - context = self._buffer.context seeds_dev = context.nparray_to_context_array(seeds) kernel = context.kernels['Particles_initialize_rand_gen'] kernel(particles=self, seeds=seeds_dev, n_init=self._capacity) diff --git a/xtrack/random/random_generators.py b/xtrack/random/random_generators.py index e3492b0d5..ac71a9bc6 100644 --- a/xtrack/random/random_generators.py +++ b/xtrack/random/random_generators.py @@ -21,9 +21,6 @@ class RandomUniform(BeamElement): allow_track = False _extra_c_sources = [ - # The base (bitwise) rng is in xtrack, as this is where the - # seeds are stored. This is needed to avoid circular imports - # in xtrack.Particles _pkg_root.joinpath('particles', 'rng_src', 'base_rng.h'), _pkg_root.joinpath('random', 'random_src', 'uniform.h') ] From eea41f0ad6b997058aa4ef9f34b0f2283294fd46 Mon Sep 17 00:00:00 2001 From: Frederik Van der Veken Date: Fri, 1 Mar 2024 23:13:01 +0100 Subject: [PATCH 4/8] Added flag 'needs_rng' to BeamElement such that elements can define they need a random generator (like EverestCollimator). This removes the need for the user to call Particles._init_random_number_generator() which feels a bit hacky. --- xtrack/base_element.py | 5 +++++ xtrack/tracker.py | 3 +++ 2 files changed, 8 insertions(+) diff --git a/xtrack/base_element.py b/xtrack/base_element.py index 9367ba07c..9f2c8700f 100644 --- a/xtrack/base_element.py +++ b/xtrack/base_element.py @@ -273,6 +273,8 @@ class BeamElement(xo.HybridClass, metaclass=MetaBeamElement): allow_backtrack = False skip_in_loss_location_refinement = False prebuilt_kernels_path = XT_PREBUILT_KERNELS_LOCATION + needs_rng = False + def __init__(self, *args, **kwargs): xo.HybridClass.__init__(self, *args, **kwargs) @@ -327,6 +329,9 @@ def track(self, particles=None, increment_at_element=False): elif particles is None: raise RuntimeError("Please provide particles to track!") + if self.needs_rng and not particles._has_valid_rng_state(): + particles._init_random_number_generator() + context = self._buffer.context if self._track_kernel_name not in context.kernels: diff --git a/xtrack/tracker.py b/xtrack/tracker.py index 09d0c924a..72fff5f08 100644 --- a/xtrack/tracker.py +++ b/xtrack/tracker.py @@ -120,6 +120,9 @@ def __init__( _buffer=_buffer) line._freeze() + if np.any([hasattr(ee, 'needs_rng') and ee.needs_rng for ee in line.elements]): + line._needs_rng = True + _buffer = tracker_data_base._buffer # Make a "marker" element to increase at_element From 28660de7e91853f930635f502fb13549be89889b Mon Sep 17 00:00:00 2001 From: Frederik Van der Veken Date: Fri, 1 Mar 2024 23:23:07 +0100 Subject: [PATCH 5/8] Default value for prebuilt_kernels_path --- xtrack/base_element.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/xtrack/base_element.py b/xtrack/base_element.py index 9f2c8700f..c317fcb41 100644 --- a/xtrack/base_element.py +++ b/xtrack/base_element.py @@ -292,7 +292,8 @@ def compile_kernels(self, extra_classes=(), *args, **kwargs): local_particle_src=Particles.gen_local_particle_api())) context = self._context cls = type(self) - prebuilt_kernels_path = kwargs.pop('prebuilt_kernels_path') + prebuilt_kernels_path = kwargs.pop('prebuilt_kernels_path', + XT_PREBUILT_KERNELS_LOCATION) if context.allow_prebuilt_kernels: from xtrack.prebuild_kernels import get_suitable_kernel # Default config is empty (all flags default to not defined, which From a8b800eaa0a30981f44145e516dd652f4fb5232c Mon Sep 17 00:00:00 2001 From: Frederik Van der Veken Date: Sat, 2 Mar 2024 01:08:13 +0100 Subject: [PATCH 6/8] Providing prebuilt kernels for empty configs. --- xtrack/prebuild_kernels.py | 4 -- xtrack/prebuilt_kernels/kernel_definitions.py | 50 ++++++++++++------- 2 files changed, 31 insertions(+), 23 deletions(-) diff --git a/xtrack/prebuild_kernels.py b/xtrack/prebuild_kernels.py index 56112e3f0..222555daf 100644 --- a/xtrack/prebuild_kernels.py +++ b/xtrack/prebuild_kernels.py @@ -206,10 +206,6 @@ def get_suitable_kernel( requested_class_names = [cls for cls in requested_class_names if cls != 'Particles' and cls != 'ParticlesBase'] - # Get a default config - if config == {}: - config = xt.Line().config - for module_name, kernel_metadata in enumerate_kernels(): if verbose: _print(f"==> Considering the precompiled kernel `{module_name}`...") diff --git a/xtrack/prebuilt_kernels/kernel_definitions.py b/xtrack/prebuilt_kernels/kernel_definitions.py index ba2b6e511..d32257c21 100644 --- a/xtrack/prebuilt_kernels/kernel_definitions.py +++ b/xtrack/prebuilt_kernels/kernel_definitions.py @@ -71,12 +71,16 @@ # These will be enumerated in order of appearance in the dict, so in this case # (for optimization purposes) the order is important. kernel_definitions = { + 'default_only_xtrack_no_config': { + 'config': {}, + 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS, + }, 'default_only_xtrack': { 'config': BASE_CONFIG, 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS, }, 'only_xtrack_non_tracking_kernels': { - 'config': BASE_CONFIG, + 'config': {}, 'classes': [], 'extra_classes': NON_TRACKING_ELEMENTS }, @@ -122,6 +126,7 @@ } } + try: import xfields as xf DEFAULT_BB3D_ELEMENTS = [ @@ -134,48 +139,55 @@ 'config': BASE_CONFIG, 'classes': [*DEFAULT_BB3D_ELEMENTS, LineSegmentMap], } + kernel_definitions['default_bb3d_no_config'] = { + 'config': {}, + 'classes': [*DEFAULT_BB3D_ELEMENTS, LineSegmentMap], + } except ImportError: LOGGER.warning('Xfields not installed, skipping BB3D elements') + try: import xcoll as xc + DEFAULT_XCOLL_ELEMENTS = [ + *ONLY_XTRACK_ELEMENTS, + *NO_SYNRAD_ELEMENTS, + xc.BlackAbsorber, + xc.EverestBlock, + xc.EverestCollimator, + xc.EverestCrystal + ] + kernel_definitions['default_xcoll'] = { 'config': BASE_CONFIG, - 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS \ - + [xc.BlackAbsorber, xc.EverestBlock, \ - xc.EverestCollimator, xc.EverestCrystal] + 'classes': DEFAULT_XCOLL_ELEMENTS + } + kernel_definitions['default_xcoll_no_config'] = { + 'config': {}, + 'classes': DEFAULT_XCOLL_ELEMENTS } kernel_definitions['default_xcoll_frozen_longitudinal'] = { 'config': {**BASE_CONFIG, **FREEZE_LONGITUDINAL}, - 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS \ - + [xc.BlackAbsorber, xc.EverestBlock, \ - xc.EverestCollimator, xc.EverestCrystal] + 'classes': DEFAULT_XCOLL_ELEMENTS } kernel_definitions['default_xcoll_frozen_energy'] = { 'config': {**BASE_CONFIG, **FREEZE_ENERGY}, - 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS \ - + [xc.BlackAbsorber, xc.EverestBlock, \ - xc.EverestCollimator, xc.EverestCrystal] + 'classes': DEFAULT_XCOLL_ELEMENTS } kernel_definitions['default_xcoll_backtrack'] = { 'config': {**BASE_CONFIG, 'XSUITE_BACKTRACK': True}, - 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS \ - + [xc.BlackAbsorber, xc.EverestBlock, \ - xc.EverestCollimator, xc.EverestCrystal] + 'classes': DEFAULT_XCOLL_ELEMENTS } kernel_definitions['default_xcoll_backtrack_no_limit'] = { 'config': {**{k: v for k,v in BASE_CONFIG.items() if k != 'XTRACK_GLOBAL_XY_LIMIT'}, 'XSUITE_BACKTRACK': True}, - 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS \ - + [xc.BlackAbsorber, xc.EverestBlock, \ - xc.EverestCollimator, xc.EverestCrystal] + 'classes': DEFAULT_XCOLL_ELEMENTS } kernel_definitions['default_xcoll_backtrack_frozen_energy'] = { 'config': {**BASE_CONFIG, **FREEZE_ENERGY, 'XSUITE_BACKTRACK': True}, - 'classes': ONLY_XTRACK_ELEMENTS + NO_SYNRAD_ELEMENTS \ - + [xc.BlackAbsorber, xc.EverestBlock, \ - xc.EverestCollimator, xc.EverestCrystal] + 'classes': DEFAULT_XCOLL_ELEMENTS } except ImportError: LOGGER.warning('Xcoll not installed, skipping collimator elements') + From f561b36b40922cba7cac592abc6998d1e6709f92 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Szymon=20=C5=81opaciuk?= Date: Mon, 4 Mar 2024 10:40:22 +0100 Subject: [PATCH 7/8] Add test for prebuilt per-element kernels --- tests/test_prebuild_kernels.py | 53 ++++++++++++++++++++++++++++++++-- 1 file changed, 51 insertions(+), 2 deletions(-) diff --git a/tests/test_prebuild_kernels.py b/tests/test_prebuild_kernels.py index 53e6f2885..432182abc 100644 --- a/tests/test_prebuild_kernels.py +++ b/tests/test_prebuild_kernels.py @@ -7,7 +7,6 @@ import cffi import xobjects as xo -import xpart as xp import xtrack as xt from xtrack.prebuild_kernels import regenerate_kernels @@ -61,9 +60,59 @@ def test_prebuild_kernels(mocker, tmp_path, temp_context_default_func): # Build the tracker on a fresh context, so that the kernel comes from a file line.build_tracker(_context=xo.ContextCpu()) - p = xp.Particles(p0c=1e9, px=3e-6) + p = xt.Particles(p0c=1e9, px=3e-6) line.track(p) assert p.x == 6e-6 assert p.y == 0.0 cffi_compile.assert_not_called() + + +def test_per_element_prebuild_kernels(mocker, tmp_path, temp_context_default_func): + # Set up the temporary kernels directory + kernel_definitions = { + "test_module": { + "config": {}, + "classes": [ + xt.Drift, + xt.Cavity, + xt.XYShift, + ] + }, + } + + patch_defs = 'xtrack.prebuilt_kernels.kernel_definitions.kernel_definitions' + mocker.patch(patch_defs, kernel_definitions) + + mocker.patch('xtrack.prebuild_kernels.XT_PREBUILT_KERNELS_LOCATION', + tmp_path) + mocker.patch('xtrack.tracker.XT_PREBUILT_KERNELS_LOCATION', tmp_path) + mocker.patch('xtrack.base_element.XT_PREBUILT_KERNELS_LOCATION', tmp_path) + + # Try regenerating the kernels + regenerate_kernels() + + # Check if the expected files were created + so_file_exists = False + for path in tmp_path.iterdir(): + if not path.name.startswith('test_module.'): + continue + if path.suffix not in ('.so', '.dll', '.dylib', '.pyd'): + continue + so_file_exists = True + assert so_file_exists + + assert (tmp_path / 'test_module.c').exists() + assert (tmp_path / 'test_module.json').exists() + + # Test that reloading the kernel works + cffi_compile = mocker.patch.object(cffi.FFI, 'compile') + + drift = xt.Drift(length=2.0) + + p = xt.Particles(p0c=1e9, px=3e-6) + drift.track(p) + + assert p.x == 6e-6 + assert p.y == 0.0 + cffi_compile.assert_not_called() From 9a3b98f71d8af57bdb87269f63a38e8341f7d31a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Szymon=20=C5=81opaciuk?= Date: Mon, 4 Mar 2024 11:11:48 +0100 Subject: [PATCH 8/8] Test per-particle & per-element kernels, remove BeamElement.prebuilt_kernels_path --- tests/test_prebuild_kernels.py | 14 ++++++++++++++ xtrack/base_element.py | 34 ++++++++-------------------------- 2 files changed, 22 insertions(+), 26 deletions(-) diff --git a/tests/test_prebuild_kernels.py b/tests/test_prebuild_kernels.py index 432182abc..d605e08f6 100644 --- a/tests/test_prebuild_kernels.py +++ b/tests/test_prebuild_kernels.py @@ -79,6 +79,13 @@ def test_per_element_prebuild_kernels(mocker, tmp_path, temp_context_default_fun xt.XYShift, ] }, + "test_module_rand": { + "config": {}, + "classes": [], + "extra_classes": [ + xt.RandomNormal, + ] + }, } patch_defs = 'xtrack.prebuilt_kernels.kernel_definitions.kernel_definitions' @@ -88,6 +95,7 @@ def test_per_element_prebuild_kernels(mocker, tmp_path, temp_context_default_fun tmp_path) mocker.patch('xtrack.tracker.XT_PREBUILT_KERNELS_LOCATION', tmp_path) mocker.patch('xtrack.base_element.XT_PREBUILT_KERNELS_LOCATION', tmp_path) + mocker.patch('xtrack.particles.particles.XT_PREBUILT_KERNELS_LOCATION', tmp_path) # Try regenerating the kernels regenerate_kernels() @@ -115,4 +123,10 @@ def test_per_element_prebuild_kernels(mocker, tmp_path, temp_context_default_fun assert p.x == 6e-6 assert p.y == 0.0 + + rng = xt.RandomNormal() + n_samples = 100 + samples = rng.generate(n_samples=n_samples, n_seeds=n_samples) + assert len(samples) == n_samples + cffi_compile.assert_not_called() diff --git a/xtrack/base_element.py b/xtrack/base_element.py index c317fcb41..8bf0911f4 100644 --- a/xtrack/base_element.py +++ b/xtrack/base_element.py @@ -272,7 +272,6 @@ class BeamElement(xo.HybridClass, metaclass=MetaBeamElement): has_backtrack = False allow_backtrack = False skip_in_loss_location_refinement = False - prebuilt_kernels_path = XT_PREBUILT_KERNELS_LOCATION needs_rng = False @@ -292,8 +291,7 @@ def compile_kernels(self, extra_classes=(), *args, **kwargs): local_particle_src=Particles.gen_local_particle_api())) context = self._context cls = type(self) - prebuilt_kernels_path = kwargs.pop('prebuilt_kernels_path', - XT_PREBUILT_KERNELS_LOCATION) + if context.allow_prebuilt_kernels: from xtrack.prebuild_kernels import get_suitable_kernel # Default config is empty (all flags default to not defined, which @@ -311,7 +309,7 @@ def compile_kernels(self, extra_classes=(), *args, **kwargs): module_name, _ = kernel_info kernels = context.kernels_from_file( module_name=module_name, - containing_dir=prebuilt_kernels_path, + containing_dir=XT_PREBUILT_KERNELS_LOCATION, kernel_descriptions=self._kernels, ) context.kernels.update(kernels) @@ -375,23 +373,17 @@ def _arr2ctx(self, arr): class PerParticlePyMethod: - def __init__(self, kernel_name, element, additional_arg_names, prebuilt_kernels_path=None): + def __init__(self, kernel_name, element, additional_arg_names): self.kernel_name = kernel_name self.element = element self.additional_arg_names = additional_arg_names - self.prebuilt_kernels_path = prebuilt_kernels_path def __call__(self, particles, increment_at_element=False, **kwargs): instance = self.element context = instance._context only_if_needed = kwargs.pop('only_if_needed', True) - BeamElement.compile_kernels( - instance, - prebuilt_kernels_path=self.prebuilt_kernels_path, - only_if_needed=only_if_needed, - - ) + BeamElement.compile_kernels(instance, only_if_needed=only_if_needed) kernel = context.kernels[self.kernel_name] if hasattr(self.element, 'io_buffer') and self.element.io_buffer is not None: @@ -413,32 +405,24 @@ def __init__(self, kernel_name, additional_arg_names): self.additional_arg_names = additional_arg_names def __get__(self, instance, owner): - kernels_path = getattr(owner, 'prebuilt_kernels_path', None) return PerParticlePyMethod(kernel_name=self.kernel_name, element=instance, - additional_arg_names=self.additional_arg_names, - prebuilt_kernels_path=kernels_path) + additional_arg_names=self.additional_arg_names) class PyMethod: - def __init__(self, kernel_name, element, additional_arg_names, prebuilt_kernels_path=None): + def __init__(self, kernel_name, element, additional_arg_names): self.kernel_name = kernel_name self.element = element self.additional_arg_names = additional_arg_names - self.prebuilt_kernels_path = prebuilt_kernels_path def __call__(self, **kwargs): instance = self.element context = instance._context only_if_needed = kwargs.pop('only_if_needed', True) - BeamElement.compile_kernels( - instance, - prebuilt_kernels_path=self.prebuilt_kernels_path, - only_if_needed=only_if_needed, - - ) + BeamElement.compile_kernels(instance, only_if_needed=only_if_needed) kernel = context.kernels[self.kernel_name] el_var_name = None @@ -460,9 +444,7 @@ def __init__(self, kernel_name, additional_arg_names): self.additional_arg_names = additional_arg_names def __get__(self, instance, owner): - kernels_path = getattr(owner, 'prebuilt_kernels_path', None) return PyMethod(kernel_name=self.kernel_name, element=instance, - additional_arg_names=self.additional_arg_names, - prebuilt_kernels_path=kernels_path) + additional_arg_names=self.additional_arg_names)