xcoll 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

xcoll/__init__.py

@@ -11,7 +11,7 @@ from .beam_elements import BlackAbsorber, BlackCrystal, TransparentCollimator, T
 from .scattering_routines.everest import materials, Material, CrystalMaterial
 from .colldb import CollimatorDatabase
 from .interaction_record import InteractionRecord
-from .rf_sweep import RFSweep
+from .rf_sweep import RFSweep, prepare_rf_sweep
 from .lossmap import LossMap, MultiLossMap
 
 

xcoll/general.py

@@ -12,5 +12,5 @@ citation = "F.F. Van der Veken, et al.: Recent Developments with the New Tools f
 # ======================
 # Do not change
 # ======================
-__version__ = '0.6.1'
+__version__ = '0.6.3'
 # ======================

xcoll/prebuild_kernels/__init__.py

@@ -0,0 +1,7 @@
+# copyright ############################### #
+# This file is part of the Xcoll package.   #
+# Copyright (c) CERN, 2025.                 #
+# ######################################### #
+
+from .elements import DEFAULT_XCOLL_ELEMENTS
+from .element_inits import XCOLL_ELEMENTS_INIT_DEFAULTS

xcoll/prebuild_kernels/element_inits.py

@@ -0,0 +1,6 @@
+# copyright ############################### #
+# This file is part of the Xcoll package.   #
+# Copyright (c) CERN, 2025.                 #
+# ######################################### #
+
+XCOLL_ELEMENTS_INIT_DEFAULTS = {}

xcoll/prebuild_kernels/elements.py

@@ -0,0 +1,20 @@
+# copyright ############################### #
+# This file is part of the Xcoll package.   #
+# Copyright (c) CERN, 2025.                 #
+# ######################################### #
+
+from ..beam_elements import *
+
+
+DEFAULT_XCOLL_ELEMENTS = [
+    BlackAbsorber,
+    BlackCrystal,
+    TransparentCollimator,
+    TransparentCrystal,
+    EverestBlock,
+    EverestCollimator,
+    EverestCrystal,
+    BlowUp,
+    # ParticleStatsMonitor,
+    EmittanceMonitor
+]

xcoll/rf_sweep.py

@@ -1,197 +1,182 @@
 # copyright ############################### #
 # This file is part of the Xcoll package.   #
-# Copyright (c) CERN, 2024.                 #
+# Copyright (c) CERN, 2025.                 #
 # ######################################### #
 
 import numpy as np
 import scipy.constants as sc
-from time import perf_counter
 
 import xtrack as xt
-from xtrack.progress_indicator import progress
 
-class RFSweep:
 
-    def __init__(self, line):
-        self.line = line
-        self._get_base_frequency()
-        self._install_zeta_shift()
-        self.reset()
-
-    def _get_base_frequency(self):
-        self.cavities = self.line.get_elements_of_type(xt.Cavity)[1]
-        freq = np.unique([round(self.line[cav].frequency, 9) for cav in self.cavities])
-        if len(freq) > 1:
-            raise NotImplementedError(f"Cannot sweep multiple cavities with different frequencies!")
-        elif abs(freq[0]) < 1e-9 :
-            raise ValueError(f"Cavity frequency not set!")
-        self.f_RF = freq[0]
-        phi = np.unique(np.array([self.line[cav].lag for cav in self.cavities])*np.pi/180.)
-        if len(phi) > 1:
-            raise NotImplementedError(f"Cannot sweep multiple cavities with different phases!")
-        self.phi = phi[0]
-        self.V = np.array([self.line[cav].voltage for cav in self.cavities]).sum()
-        self.L = self.line.get_length()
+def prepare_rf_sweep(line, cavities=None, sweep=None, sweep_per_turn=None, num_turns=None):
+    rf_sweep = RFSweep(line=line, cavities=cavities)
+    rf_sweep.prepare(sweep=sweep, sweep_per_turn=sweep_per_turn, num_turns=num_turns)
 
-    def _install_zeta_shift(self):
-        if 'rf_sweep' in self.line.element_names:
-            print(f"Found existing RF sweep in line.")
-        else:
-            s_cav = min([self.line.get_s_position(cav) for cav in self.cavities])
-            if self.line.tracker is not None:
-                self.line.unfreeze()
-                line_was_built = True
-            else:
-                line_was_built = False
-            self.line.insert_element(element=xt.ZetaShift(dzeta=0), name='rf_sweep', at_s=s_cav)
-            if line_was_built:
-                self.line.build_tracker()
+
+class RFSweep:
+    def __init__(self, line, cavities=None):
+        self.line = line
+        if line._var_management is None:
+            raise ValueError("Line must have a `var_management` to use RFSweep!" \
+                           + "Do not use `optimize_for_tracking` as it will "
+                           + "disable expressions, which are needed for RFSweep.")
+        self.env = line.env
+        self.cavities = cavities
+        self.env['rf_sweep_df'] = 0
 
     @property
     def current_sweep_value(self):
-        dzeta = self.line['rf_sweep'].dzeta
-        return round(self.f_RF * dzeta/(self.L-dzeta), 6)
-
-
-    def info(self, sweep=0, num_turns=0):
-        if abs(sweep) > 1e-9:
-            existing_sweep = self.current_sweep_value
-
-            beta0 = self.line.particle_ref.beta0[0]
-            E = self.line.particle_ref.energy0[0]
-            q = self.line.particle_ref.q0
-            h = self.f_RF * self.L / beta0 / sc.c
-            tw = self.line.twiss()
-            eta = tw.slip_factor
-
-            bucket_height = np.sqrt(abs(q*self.V*beta0**2 / (np.pi*h*eta*E) * (
-                                2*np.cos(self.phi) + (2*self.phi-np.pi)*np.sin(self.phi)
-                            )))
-            delta_shift = -sweep / self.f_RF / eta
-            bucket_shift = delta_shift / bucket_height / 2
-            if num_turns > 0:
-                rf_shift_per_turn = sweep / num_turns
-                print(f"The current frequency is {self.f_RF + existing_sweep}Hz, adding {rf_shift_per_turn}Hz "
-                    + f"per turn until {self.f_RF + existing_sweep + sweep} (for {num_turns} turns).")
-            print(f"This sweep will move the center of the bucket with \u0394\u03B4 = "
-                + f"{delta_shift} ({bucket_shift} buckets).")
-            if num_turns > 0 and num_turns < 3*bucket_shift/tw.qs:
-                print(f"Warning: This is a very fast sweep, moving ~{round(bucket_shift, 2)} buckets in "
-                    + f"~{round(num_turns*tw.qs, 2)} synchrotron oscillations (on average). If the "
-                    + f"bucket moves faster than a particle can follow, that particle will move out of "
-                    + f"the bucket and remain uncaptured.")
-
-
-    def track(self, sweep=0, particles=None, num_turns=0, verbose=True, *args, **kwargs):
-
-        # Was there a previous sweep?
-        # If yes, we do not overwrite it but continue from there
-        existing_sweep = self.current_sweep_value
+        return self.env['rf_sweep_df']
+
+    def prepare(self, sweep=None, sweep_per_turn=None, num_turns=None):
+        if sweep_per_turn is not None:
+            if np.isclose(sweep_per_turn, 0):
+                raise ValueError("Variable `sweep_per_turn` must be non-zero!")
+            if sweep is not None:
+                raise ValueError("Provide either `sweep` or `sweep_per_turn`, not both.")
+            if num_turns is not None:
+                raise ValueError("Variable `num_turns` cannot be set when using `sweep_per_turn`.")
+            self.sweep_per_turn = sweep_per_turn
+        elif sweep is not None:
+            if np.isclose(sweep, 0):
+                raise ValueError("Variable `sweep` must be non-zero!")
+            if num_turns is None:
+                num_turns = int(abs(sweep))
+            if num_turns <= 0:
+                raise ValueError("When using `sweep`, `num_turns` must be a positive integer.")
+            self.sweep_per_turn = sweep / num_turns
+        else:
+            raise ValueError("Either `sweep` or `sweep_per_turn` must be provided.")
+        self._get_cavity_data(self.sweep_per_turn)
+        self._install_zeta_shift()
+        self.tw = self.line.twiss()
+        self.reset() # Initialize rf_sweep_df
+        self.env['rf_sweep'].dzeta = f"{self.L} * rf_sweep_df / ({self.f_RF} + rf_sweep_df)"
+        for cavs in self.cavities:
+            for cav in cavs['names']:
+                scale_factor = int(np.round(cavs['freq'] / self.f_RF))
+                if scale_factor == 1:
+                    self.env.ref[cav].frequency += self.env.ref["rf_sweep_df"]
+                else:
+                    self.env.ref[cav].frequency += scale_factor * self.env.ref["rf_sweep_df"]
+        self.line.enable_time_dependent_vars = True
+        print("Enabled time-dependent variables in the line.")
 
-        # Just set the new RF frequency, no tracking
-        if num_turns == 0:
-            sweep += existing_sweep
-            if verbose:
-                print(f"The current frequency is {self.f_RF + existing_sweep}Hz, moving to {self.f_RF + sweep}Hz."
-                     + "No tracking performed.")
-            self.line['rf_sweep'].dzeta = self.L * sweep / (self.f_RF + sweep)
 
-        # Sweep and track
+    def reset(self):
+        if self.sweep_per_turn is None:
+            raise ValueError("RFSweep not prepared. Call `prepare` first.")
+        t_turn = self.tw.T_rev0
+        current_time = self.env['t_turn_s']
+        if current_time == 0:
+            self.env['rf_sweep_df'] = f"(t_turn_s + {t_turn}) / {t_turn} * {self.sweep_per_turn}"
         else:
-            if self.line.tracker is None:
-                raise ValueError("Need to build tracker first!")
-            if particles is None:
-                raise ValueError("Need particles to track!")
-            time = kwargs.pop('time', False)
-            with_progress = kwargs.pop('with_progress', False)
-            rf_shift_per_turn = sweep / num_turns
-
-            # This is taken from xtrack.tracker.Tracker._track
-            if time:
-                t0 = perf_counter()
-            if with_progress:
-                if self.line.tracker.enable_pipeline_hold:
-                    raise ValueError("Progress indicator is not supported with pipeline hold")
-                if num_turns < 2:
-                    raise ValueError('Tracking with progress indicator is only '
-                                    'possible over more than one turn.')
-                if with_progress is True:
-                    batch_size = scaling = 100
-                else:
-                    batch_size = int(with_progress)
-                    scaling = with_progress if batch_size > 1 else None
-                if kwargs.get('turn_by_turn_monitor') is True:
-                    ele_start = kwargs.get('ele_start') or 0
-                    ele_stop = kwargs.get('ele_stop')
-                    if ele_stop is None:
-                        ele_stop = len(self.line)
-                    if ele_start >= ele_stop:
-                        # we need an additional turn and space in the monitor for
-                        # the incomplete turn
-                        num_turns += 1
-                    _, monitor, _, _ = self.line.tracker._get_monitor(particles, True, num_turns)
-                    kwargs['turn_by_turn_monitor'] = monitor
-
-                for ii in progress(
-                        range(0, num_turns, batch_size),
-                        desc='Tracking',
-                        unit_scale=scaling,
-                ):
-                    one_turn_kwargs = kwargs.copy()
-                    is_first_batch = ii == 0
-                    is_last_batch = ii + batch_size >= num_turns
-
-                    if is_first_batch and is_last_batch:
-                        # This is the only batch, we track as normal
-                        pass
-                    elif is_first_batch:
-                        # Not the last batch, so track until the last element
-                        one_turn_kwargs['ele_stop'] = None
-                        one_turn_kwargs['num_turns'] = batch_size
-                    elif is_last_batch:
-                        # Not the first batch, so track from the first element
-                        one_turn_kwargs['ele_start'] = None
-                        remaining_turns = num_turns % batch_size
-                        if remaining_turns == 0:
-                            remaining_turns = batch_size
-                        one_turn_kwargs['num_turns'] = remaining_turns
-                        one_turn_kwargs['_reset_log'] = False
-                    elif not is_first_batch and not is_last_batch:
-                        # A 'middle batch', track from first to last element
-                        one_turn_kwargs['num_turns'] = batch_size
-                        one_turn_kwargs['ele_start'] = None
-                        one_turn_kwargs['ele_stop'] = None
-                        one_turn_kwargs['_reset_log'] = False
-                    self._tracking_func(particles, rf_shift_per_turn, **one_turn_kwargs)
-                    if not np.any(particles.state == 1):
-                        break
+            self.env['rf_sweep_df'] = f"(t_turn_s - {current_time} + {t_turn}) / {t_turn} * {self.sweep_per_turn}"
 
-            else:
-                self._tracking_func(particles, rf_shift_per_turn, num_turns=num_turns, *args, **kwargs)
 
-            if not np.any(particles.state == 1):
-                print(f"All particles lost at turn {particles.at_turn.max()}, stopped sweep at "
-                    + f"{self.current_sweep_value}Hz.")
+    def info(self, sweep=None, num_turns=None):
+        if sweep is not None:
+            raise DeprecationWarning("The `sweep` argument is deprecated.")
+        if num_turns is not None:
+            raise DeprecationWarning("The `num_turns` argument is deprecated.")
+        if self.sweep_per_turn is None:
+            raise ValueError("RFSweep not prepared. Call `prepare` first.")
+        existing_sweep = self.current_sweep_value
 
-            if time:
-                t1 = perf_counter()
-                self.line.tracker._context.synchronize()
-                self.line.tracker.time_last_track = t1 - t0
-            else:
-                self.line.tracker.time_last_track = None
+        beta0 = self.line.particle_ref.beta0[0]
+        E = self.line.particle_ref.energy0[0]
+        q = self.line.particle_ref.q0
+        h = self.f_RF * self.L / beta0 / sc.c
+        eta = self.tw.slip_factor
+
+        bucket_height = np.sqrt(abs(q*self.V*beta0**2 / (np.pi*h*eta*E) * (
+                            2*np.cos(self.phi) + (2*self.phi-np.pi)*np.sin(self.phi)
+                        )))
+        delta_shift = -self.sweep_per_turn / self.f_RF / eta
+        bucket_turns = bucket_height * 2 / abs(delta_shift)
+        print(f"The current frequency is {self.f_RF + existing_sweep}Hz, adding "
+            + f"{self.sweep_per_turn}Hz per turn.")
+        print(f"This sweep will move the center of the bucket with \u0394\u03B4 = "
+            + f"{delta_shift} per turn.")
+        print(f"This implies one bucket shift every {bucket_turns} turns.")
+        if self.tw.qs * bucket_turns < 3:
+            print(f"Warning: This is a very fast sweep, moving ~1 bucket in "
+                + f"~{round(self.tw.qs * bucket_turns, 2)} synchrotron oscillations "
+                + f"(on average). If the bucket moves faster than a particle "
+                + f"can follow, that particle will move out of the bucket and "
+                + f"remain uncaptured.")
+
+
+    # For backward compatibility
+    def track(self, sweep=0, particles=None, num_turns=0, verbose=True, *args, **kwargs):
+        self.prepare(sweep, num_turns)
+        self.line.track(particles=particles, *args, **kwargs)
 
 
-    def reset(self):
-        self.line['rf_sweep'].dzeta = 0
+    def _get_cavity_data(self, sweep):
+        tt = self.line.get_table()
+        tt_c = tt.rows[[nn for nn, ttt in zip(tt.name, tt.element_type)
+                        if 'Cavity' in ttt and 'CrabCavity' not in ttt]]
+        mask = tt_c.parent_name == None  # Unsliced cavities
+        if self.cavities is None:
+            self.cavities = np.unique(list(tt_c.name[mask]) + list(tt_c.parent_name[~mask]))
+        else:
+            if isinstance(self.cavities, str):
+                self.cavities = [self.cavities]
+            for cav in self.cavities:
+                if cav not in self.env.elements:
+                    raise ValueError(f"Cavity `{cav}` not found in environment!")
+        if len(self.cavities) == 0:
+            raise ValueError("No cavities found in the line!")
+        freq = np.array([self.env[cav].frequency for cav in self.cavities])
+        volt = np.array([self.env[cav].voltage for cav in self.cavities])
+        lag  = np.array([self.env[cav].lag for cav in self.cavities])
+        s_pos = []
+        name_first_in_line = []
+        for cav in self.cavities:
+            if cav in tt_c.name:
+                s_pos.append(tt_c.rows[cav].s_start[0])
+                name_first_in_line.append(cav)
+            elif cav in tt_c.parent_name:
+                s_pos.append(tt_c.rows[tt_c.parent_name == cav].s_start.min())
+                name_first_in_line.append(tt_c.rows[tt_c.parent_name == cav].name[0])
+            else:
+                raise ValueError(f"Cavity `{cav}` not found in the line!")
+        idx  = np.argsort(freq)
+        boundaries = np.where(~np.isclose(freq[idx][1:], freq[idx][:-1],
+                                          rtol=1e-8, atol=1e-12)
+                              )[0] + 1
+        groups = []
+        for gidx in np.split(idx, boundaries):
+            groups.append({
+                'names': self.cavities[gidx],
+                'freq': np.mean(freq[gidx]),
+                'voltage': volt[gidx].sum(),
+                's_pos': np.array(s_pos)[gidx],
+                'lag': lag[gidx],
+                'name_first_in_line': np.array(name_first_in_line)[gidx],
+            })
+        self.cavities = sorted(groups, key=lambda g: (g['voltage'], g['freq']), reverse=True)
+        if np.isclose(self.cavities[0]['voltage'], 0):
+            raise ValueError("No active cavity found!")
+        self.f_RF = self.cavities[0]['freq']
+        self.phi = np.deg2rad(self.cavities[0]['lag'].mean())
+        self.V = self.cavities[0]['voltage']
+        self.L = self.line.get_length()
+        if len(self.cavities) > 1:
+            print("Found multiple cavities with different frequencies:")
+            for g in self.cavities:
+                print(f"{g['freq']}Hz  at {g['voltage']}V: {g['names']}")
+            print(r"The sweep ($\Delta f$ = " + f"{sweep}Hz per turn) will be "
+                + f"performed with respect to the highest voltage cavity at "
+                + f"{self.f_RF}Hz. The other cavities will be shifted "
+                + f"accordingly.")
 
 
-    def _tracking_func(self, particles, rf_shift_per_turn, num_turns=1, *args, **kwargs):
-        existing_sweep = self.current_sweep_value
-        for i in range(num_turns):
-            sweep = existing_sweep + i*rf_shift_per_turn
-            self.line['rf_sweep'].dzeta = self.L * sweep / (self.f_RF + sweep)
-#             for cav in cavities:
-#                 self.line[cav].frequency = freq + sweep
-            self.line.track(particles, num_turns=1, *args, **kwargs)
-            if not np.any(particles.state == 1):
-                break
+    def _install_zeta_shift(self):
+        if 'rf_sweep' not in self.env.elements:
+            idx = np.argsort(self.cavities[0]['s_pos'])
+            first_cavity = self.cavities[0]['name_first_in_line'][idx[0]]
+            self.env.elements['rf_sweep'] = xt.ZetaShift(dzeta=0)
+            self.line.insert('rf_sweep', at=f'{first_cavity}@start')

{xcoll-0.6.1.dist-info → xcoll-0.6.3.dist-info}/METADATA

@@ -1,28 +1,33 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: xcoll
-Version: 0.6.1
+Version: 0.6.3
 Summary: Xsuite collimation package
-Home-page: https://github.com/xsuite/xcoll
-License: Apache 2.0
+License: Apache-2.0
 Author: Frederik F. Van der Veken
 Author-email: frederik@cern.ch
-Requires-Python: >=3.8
-Classifier: License :: Other/Proprietary License
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: tests
 Requires-Dist: numpy (>=1.0)
 Requires-Dist: pandas (>=1.4)
-Requires-Dist: ruamel-yaml (>=0.17.31,<0.18.0) ; extra == "tests"
-Requires-Dist: xdeps (>=0.10.5)
-Requires-Dist: xobjects (>=0.5.0)
-Requires-Dist: xpart (>=0.23.0)
-Requires-Dist: xtrack (>=0.84.6)
+Requires-Dist: pytest ; extra == "tests"
+Requires-Dist: pytest-html ; extra == "tests"
+Requires-Dist: pytest-xdist ; extra == "tests"
+Requires-Dist: ruamel-yaml (>=0.17.31,<0.18.15)
+Requires-Dist: xdeps (>=0.10.6)
+Requires-Dist: xobjects (>=0.5.2)
+Requires-Dist: xpart (>=0.23.1)
+Requires-Dist: xtrack (>=0.89.3)
+Project-URL: Bug Tracker, https://github.com/xsuite/xsuite/issues
+Project-URL: Documentation, https://xsuite.readthedocs.io/
+Project-URL: Homepage, https://github.com/xsuite/xcoll
 Project-URL: Repository, https://github.com/xsuite/xcoll
+Project-URL: download, https://pypi.python.org/pypi/xcoll
 Description-Content-Type: text/markdown
 
 # xcoll

xcoll-0.6.3.dist-info/RECORD

@@ -0,0 +1,65 @@
+xcoll/__init__.py,sha256=7qEja96thydS08Q1IVdLeeT3VslAZ1OQbGzXJ96euVE,872
+xcoll/beam_elements/__init__.py,sha256=qu2-LefWfEKZHfALGqZo97DTrwdZVh7Sp97V-3XokJU,1189
+xcoll/beam_elements/absorber.py,sha256=Gw1l1ng1MqF0dRTk7YhkiPAoinS5xsTASMxMDWGsmTw,2842
+xcoll/beam_elements/base.py,sha256=mjnzLbZ-GC56N56Eq5r5oQB8cLmeaqR5oEH1-FnS_H4,57816
+xcoll/beam_elements/blowup.py,sha256=0jfuxaIwXsEY4e6DlzGmv29OY7DGRKhbb2L-qKJwImQ,8079
+xcoll/beam_elements/elements_src/black_absorber.h,sha256=AXs_bNLaK8xBl8IeLJvGz7AfFaasruPMtYz8lbRtqG4,4705
+xcoll/beam_elements/elements_src/black_crystal.h,sha256=ZlLkJec4_naeoS3jEx-vQVAKBI0dInzMZq06pzKQOn0,4355
+xcoll/beam_elements/elements_src/blowup.h,sha256=YlTt7YxswLM0ZjPuEjuE7xzjQ3hMt6FX9V3MbqVYmN4,1564
+xcoll/beam_elements/elements_src/emittance_monitor.h,sha256=vlHzQFoUjKQHWBmzpaSzRbILtxSWqEasMtxHC-FFoAc,7078
+xcoll/beam_elements/elements_src/everest_block.h,sha256=ITSzfiqwm8ZNIkAj_odQkAjKhPcdT8b0AUlq_uxtsqI,6562
+xcoll/beam_elements/elements_src/everest_collimator.h,sha256=fkD5GazVv2zlmqyb6s9zVNMq6baXeFb_pf7gg9TKjNc,9787
+xcoll/beam_elements/elements_src/everest_crystal.h,sha256=LISp_9NEWMIi5GvZ3LwPfeSbmsbXvHWcTqxW6eCCsiE,11951
+xcoll/beam_elements/elements_src/transparent_collimator.h,sha256=pA_Fxx85N87iSbpHSjR2OSOx6JN9e38T1pOUKrC7zxs,4610
+xcoll/beam_elements/elements_src/transparent_crystal.h,sha256=DGX4uL0hpm4njOypoPuEWtMzYxnL9jQkf2ZrGaS0alI,4128
+xcoll/beam_elements/everest.py,sha256=iJva_S0OQnmG-qj7rIAiUCssu5WL_Qs5P_n6Qx-IWzo,9080
+xcoll/beam_elements/monitor.py,sha256=baMYT_PNya8KX35ReeMwk5Cm04ePUqiDF_s69L5GTX0,16968
+xcoll/beam_elements/transparent.py,sha256=AZOWfH3dvsetL6DjQGejUgX7T18e_3omIIffG_1gwc0,2894
+xcoll/colldb.py,sha256=WaJC6gkDNVvxo65OhucTM6Fwo6pgRFHNnBnHSkiX7AQ,31054
+xcoll/general.py,sha256=4ksyfjB_QTQ5LHe22beup0CS-e0tu2HDyDX7yuwZxDM,534
+xcoll/headers/checks.h,sha256=qdXsOTBOK1MwW6bdFF93j4yE648mcDtEv5rGN1w9sfk,1582
+xcoll/headers/particle_states.py,sha256=N8ehLtg99358I4RGCJ3sjuKCk2LVdGqgVx2xGoHrRdM,1959
+xcoll/initial_distribution.py,sha256=CHhqeCVjVOyaBWhfy2sDgLwIgtXZoqcTW-su-M2YByE,10989
+xcoll/interaction_record/__init__.py,sha256=UFoLiKa-z2oX7YoszP-7Vgdt1nM6kT382v1CaIu8_u0,50
+xcoll/interaction_record/interaction_record.py,sha256=cCjfVCYUJaV0Y-pCljA2_u8GLyhHt7zNjbSXkE7cRO4,13299
+xcoll/interaction_record/interaction_record_src/interaction_record.h,sha256=0rNagnfSGc2i1jauOMIcDbj9QFic9dV_MOyqVx1kw5Q,6067
+xcoll/interaction_record/interaction_types.py,sha256=XTeg2dcImMpqhTqzkJKh6JYam2v9gUMhED-dDKLsilk,2894
+xcoll/line_tools.py,sha256=JBySkKKZ-RGumqAZF_8PSQ3OV0M87P78NeQgbXAdFc4,16699
+xcoll/lossmap.py,sha256=HLdhej9tUjk36T5BulVWurJtfiNa61L_1X7-8kT6JoQ,28407
+xcoll/plot.py,sha256=27fYdXstPg3o8XyeBlPuD2yz0GR3dKkNWy4kO2BD9WA,4071
+xcoll/prebuild_kernels/__init__.py,sha256=HITO-StW6e3GujTvLzEFz2Y8bMDGnavVttwixVPgA-M,286
+xcoll/prebuild_kernels/element_inits.py,sha256=9Qm34JXN7F08inWzXP6g6DU57ypRbyqHYwPK9Oc9BC4,219
+xcoll/prebuild_kernels/elements.py,sha256=7P5cxZgjfeNmUNuDer372KgtjmhH39Kk1wReyKMhqig,456
+xcoll/rf_sweep.py,sha256=Rrx4SmvKq4cmrfCU_Cetqmzp8c_uVa_QpXU4_rt4k_U,8611
+xcoll/scattering_routines/engine.py,sha256=1VCBEZLMd5orFo3sZqK51NrqbqELBVrbsz6bB2SXsFQ,22962
+xcoll/scattering_routines/environment.py,sha256=xZ8A7XfvSfpe8vYbM5oD5qbcp8Tuag5qWAI6VqgGUlA,12033
+xcoll/scattering_routines/everest/__init__.py,sha256=7lkkeZ1liBjXVHCuRpgzZI6ohzHVMj5uJBO792147XY,286
+xcoll/scattering_routines/everest/amorphous.h,sha256=8v_5P94LDxeLp1xI2nvwdbEPJNDY6LTB1CwXv4AwjZs,11806
+xcoll/scattering_routines/everest/channelling.h,sha256=WrYBcvGWP2Da47__AGbbKsT8yvZmHhVZd5F1gku--GU,10941
+xcoll/scattering_routines/everest/constants.h,sha256=_y9QqKAUSwPOkk8A4BF8ILNdDDJf66eINJwda8skwZM,1380
+xcoll/scattering_routines/everest/crystal_parameters.h,sha256=QtmSQM4qzVXfjdkxs0ns8utqtqZ_u-Ej_y6m7UOKITo,6001
+xcoll/scattering_routines/everest/everest.h,sha256=T9mESIy_oC86WJSsU7LY_A0iqHT2PKl5MmhnKQaGVSg,3200
+xcoll/scattering_routines/everest/everest.py,sha256=aKy5d7HGiqEphFZDZE4RnYbxh0j10Boc04EZ0By9WdM,1542
+xcoll/scattering_routines/everest/ionisation_loss.h,sha256=QIujj_qrKOY7L7CVFNSyexjlDJ94sfilvakhfWVfe44,6108
+xcoll/scattering_routines/everest/jaw.h,sha256=4Ml9FofWPkGlvw6oWNdbZQIYV4K1xhfbEkNwwfDcITc,2069
+xcoll/scattering_routines/everest/materials.py,sha256=pKQfrMNrqU3sitICTRjqfvwsvHrBDSUf3jfmOEE5Kls,10292
+xcoll/scattering_routines/everest/multiple_coulomb_scattering.h,sha256=oX_ZN32eLcZX3VdYn4kAnT5wMKVTe4fLudPgbX9w37Y,5434
+xcoll/scattering_routines/everest/nuclear_interaction.h,sha256=07yg9AD3jAfPetFVSY6cXT0iN5tBCrXXmYWvGMTaUDI,3892
+xcoll/scattering_routines/everest/properties.h,sha256=AJf7Q_iPsiXTavnguzsNozdoH4NYGdDvyqP3iXychKU,3845
+xcoll/scattering_routines/geometry/__init__.py,sha256=a2DFji3U6Msj-aJE2Dt5Il8FgesfICJHeK9yQj4zHa4,221
+xcoll/scattering_routines/geometry/collimator_geometry.h,sha256=0gHiSEALJtQdW0mUav7GmES4JCAvq-xmch_ZRPkCfUI,7819
+xcoll/scattering_routines/geometry/crystal_geometry.h,sha256=DHuQPMKq_Q0uK0WW2YRd7oxxhMwRPWtNUUn5fBW4Cxc,4968
+xcoll/scattering_routines/geometry/geometry.py,sha256=bF8v7aEP09E4_EMkN0KEJFU-PQrBSOB0Xv699VBUzRY,1102
+xcoll/scattering_routines/geometry/get_s.h,sha256=TWxZ-GjCcLrOV1wota7ltE53Nit0LQASoXmsqn-N0LQ,2947
+xcoll/scattering_routines/geometry/methods.h,sha256=I8ik46SgkCHHtZ99anbdb3ZC7A_5Q809fgpeWMajdkY,3747
+xcoll/scattering_routines/geometry/objects.h,sha256=A5ktGvVlSkC4hUsI_PQFsE80CuDwYbcioxKGRmEf2I0,5499
+xcoll/scattering_routines/geometry/rotation.h,sha256=lO3RaQBys9r0ROMjR8T8Rr7UsIEm-H9_C_70Nwz4MXY,701
+xcoll/scattering_routines/geometry/segments.h,sha256=7nKnnin2ByxkKyaYwGvFaqgLQg5uBba4CdLHL7L3iQs,7667
+xcoll/scattering_routines/geometry/sort.h,sha256=b1MkFO2ddzv1fWGeQzsLuz46qo2pKyRSXHjoAEVU7Ts,5763
+xcoll/xaux.py,sha256=mh4E_jhaUFm2LOKawJ0b6X4zuz8JiJhx6w7GcnRgIXQ,2291
+xcoll-0.6.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+xcoll-0.6.3.dist-info/METADATA,sha256=kTXBtG7uiFxoFbGbikFmNyER0Ee2f7-ASiqsEKmYqC8,2953
+xcoll-0.6.3.dist-info/NOTICE,sha256=6DO_E7WCdRKc42vUoVVBPGttvQi4mRt9fAcxj9u8zy8,74
+xcoll-0.6.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+xcoll-0.6.3.dist-info/entry_points.txt,sha256=fC9oojAU6WjKujnGBodo7ZcEeBGfSfeLPO5287echdY,26
+xcoll-0.6.3.dist-info/RECORD,,

{xcoll-0.6.1.dist-info → xcoll-0.6.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

xcoll-0.6.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[xobjects]
+include=xcoll
+

xcoll/__init__.py.orig

@@ -1,26 +0,0 @@
-# copyright ############################### #
-# This file is part of the Xcoll package.   #
-# Copyright (c) CERN, 2025.                 #
-# ######################################### #
-
-from .general import _pkg_root, __version__, citation
-
-<<<<<<< HEAD
-from .beam_elements import BlackAbsorber, BlackCrystal, EverestBlock, EverestCollimator, EverestCrystal, \
-                           Geant4Collimator, BlowUp, EmittanceMonitor, collimator_classes, crystal_classes, element_classes
-=======
-from .beam_elements import BlackAbsorber, BlackCrystal, TransparentCollimator, TransparentCrystal, \
-                           EverestBlock, EverestCollimator, EverestCrystal, BlowUp, EmittanceMonitor, \
-                           collimator_classes, crystal_classes, element_classes
->>>>>>> main
-from .scattering_routines.everest import materials, Material, CrystalMaterial
-from .scattering_routines.geant4 import Geant4Engine
-from .colldb import CollimatorDatabase
-from .interaction_record import InteractionRecord
-from .rf_sweep import RFSweep
-from .lossmap import LossMap, MultiLossMap
-
-
-# print("If you use Xcoll in your simulations, please cite us :-)")
-# print(citation)
-

xcoll/general.py.orig

@@ -1,20 +0,0 @@
-# copyright ############################### #
-# This file is part of the Xcoll package.   #
-# Copyright (c) CERN, 2024.                 #
-# ######################################### #
-
-from pathlib import Path
-
-_pkg_root = Path(__file__).parent.absolute()
-
-citation = "F.F. Van der Veken, et al.: Recent Developments with the New Tools for Collimation Simulations in Xsuite, Proceedings of HB2023, Geneva, Switzerland."
-
-# ======================
-# Do not change
-# ======================
-<<<<<<< HEAD
-__version__ = '0.5.11.dev0+geant4'
-=======
-__version__ = '0.6.0'
->>>>>>> main
-# ======================