xcoll 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

xcoll/__init__.py

@@ -5,7 +5,8 @@
 
 from .general import _pkg_root, __version__, citation
 
-from .beam_elements import BlackAbsorber, BlackCrystal, EverestBlock, EverestCollimator, EverestCrystal, element_classes
+from .beam_elements import BlackAbsorber, BlackCrystal, EverestBlock, EverestCollimator, EverestCrystal, \
+                           BlowUp, EmittanceMonitor, collimator_classes, crystal_classes, element_classes
 from .install import install_elements
 from .line_tools import assign_optics_to_collimators, open_collimators, send_to_parking, enable_scattering, disable_scattering
 from .scattering_routines.everest import materials, Material, CrystalMaterial

xcoll/beam_elements/__init__.py

@@ -6,6 +6,8 @@
 from .base import BaseBlock, BaseCollimator, BaseCrystal
 from .absorber import BlackAbsorber, BlackCrystal
 from .everest import EverestBlock, EverestCollimator, EverestCrystal
+from .blowup import BlowUp
+from .monitor import EmittanceMonitor
 
 block_classes = tuple(v for v in globals().values()
                       if isinstance(v, type) and issubclass(v, BaseBlock) and v != BaseBlock)
@@ -15,4 +17,8 @@ collimator_classes = tuple(v for v in globals().values()
                            and v != BaseCollimator and v != BaseCrystal)
 crystal_classes = tuple(v for v in globals().values()
                         if isinstance(v, type) and issubclass(v, BaseCrystal) and v != BaseCrystal)
-element_classes = block_classes + collimator_classes
+
+element_classes = block_classes + collimator_classes + (BlowUp, EmittanceMonitor)
+
+_all_collimator_classes = collimator_classes
+_all_crystal_classes    = crystal_classes

xcoll/beam_elements/absorber.py

@@ -23,7 +23,7 @@ class BlackAbsorber(BaseCollimator):
     _depends_on = [BaseCollimator, XcollGeometry]
 
     _extra_c_sources = [
-        _pkg_root.joinpath('beam_elements','collimators_src','black_absorber.h')
+        _pkg_root.joinpath('beam_elements','elements_src','black_absorber.h')
     ]
 
     _skip_in_to_dict       = BaseCollimator._skip_in_to_dict
@@ -54,7 +54,7 @@ class BlackCrystal(BaseCrystal):
     _depends_on = [BaseCrystal, XcollGeometry]
 
     _extra_c_sources = [
-        _pkg_root.joinpath('beam_elements','collimators_src','black_crystal.h')
+        _pkg_root.joinpath('beam_elements','elements_src','black_crystal.h')
     ]
 
     _skip_in_to_dict       = BaseCrystal._skip_in_to_dict

xcoll/beam_elements/base.py

@@ -10,7 +10,6 @@ import xtrack as xt
 
 from ..interaction_record import InteractionRecord
 from ..general import _pkg_root
-from ..scattering_routines.geometry import XcollGeometry
 
 
 OPEN_JAW = 3.
@@ -46,10 +45,9 @@ class InvalidXcoll(xt.BeamElement):
 
 class BaseBlock(xt.BeamElement):
     _xofields = {
-        'length':             xo.Float64,
-        'active':             xo.Int8,
-        'record_touches':     xo.Int8,
-        'record_scatterings': xo.Int8
+        'length':                xo.Float64,
+        'active':                xo.Int8,
+        '_record_interactions':  xo.Int8
     }
 
     isthick = True
@@ -57,6 +55,9 @@ class BaseBlock(xt.BeamElement):
     behaves_like_drift = True
     skip_in_loss_location_refinement = True
 
+    _skip_in_to_dict  = ['_record_interactions']
+    _store_in_to_dict = ['record_impacts', 'record_exits', 'record_scatterings']
+
     _depends_on = [InvalidXcoll]
 
     _internal_record_class = InteractionRecord
@@ -68,14 +69,61 @@ class BaseBlock(xt.BeamElement):
         instance = super().__new__(cls)
         return instance
 
+    def __init__(self, **kwargs):
+        if '_xobject' not in kwargs:
+            kwargs.setdefault('active', True)
+        super().__init__(**kwargs)
+
     def enable_scattering(self):
         if hasattr(self, '_tracking'):
+            if hasattr(self, 'optics') and self.optics is None and \
+            (hasattr(self, '_gap_L_set_manually') and self._gap_L_set_manually() \
+            or hasattr(self, '_gap_R_set_manually') and self._gap_R_set_manually()):
+                raise ValueError("Gap set but optics not yet assigned! "
+                               + "Cannot enable scattering.")
             self._tracking = True
 
     def disable_scattering(self):
         if hasattr(self, '_tracking'):
             self._tracking = False
 
+    @property
+    def record_impacts(self):
+        return bool(self._record_interactions % 2)
+
+    @record_impacts.setter
+    def record_impacts(self, val):
+        if val and not self.record_impacts:
+            self._record_interactions += 1
+        elif not val and self.record_impacts:
+            self._record_interactions -= 1
+
+    @property
+    def record_exits(self):
+        return bool((self._record_interactions >> 1) % 2)
+
+    @record_exits.setter
+    def record_exits(self, val):
+        if val and not self.record_exits:
+            self._record_interactions += 2
+        elif not val and self.record_exits:
+            self._record_interactions -= 2
+
+    @property
+    def record_scatterings(self):
+        return bool((self._record_interactions >> 2) % 2)
+
+    @record_scatterings.setter
+    def record_scatterings(self, val):
+        if val and not self.record_scatterings:
+            self._record_interactions += 4
+        elif not val and self.record_scatterings:
+            self._record_interactions -= 4
+
+    def _verify_consistency(self):
+        assert isinstance(self.active, bool) or self.active in [0, 1]
+        assert self._record_interactions in list(range(8))
+
     def get_backtrack_element(self, _context=None, _buffer=None, _offset=None):
         return InvalidXcoll(length=-self.length,
                               _context=_context, _buffer=_buffer, _offset=_offset)
@@ -119,8 +167,8 @@ class BaseCollimator(BaseBlock):
     skip_in_loss_location_refinement = BaseBlock.skip_in_loss_location_refinement
     allow_double_sided = True
 
-    _skip_in_to_dict  = [f for f in _xofields if f.startswith('_')]
-    _store_in_to_dict = ['angle', 'jaw', 'tilt', 'gap', 'side', 'align', 'emittance']
+    _skip_in_to_dict  = [*BaseBlock._skip_in_to_dict, *[f for f in _xofields if f.startswith('_')]]
+    _store_in_to_dict = [*BaseBlock._store_in_to_dict, 'angle', 'jaw', 'tilt', 'gap', 'side', 'align', 'emittance']
 
     _depends_on = [BaseBlock]
 
@@ -203,9 +251,6 @@ class BaseCollimator(BaseBlock):
             # Set others
             to_assign['align'] = kwargs.pop('align', 'upstream')
             to_assign['emittance'] = kwargs.pop('emittance', None)
-            kwargs.setdefault('active', True)
-            kwargs.setdefault('record_touches', False)
-            kwargs.setdefault('record_scatterings', False)
 
         super().__init__(**kwargs)
         # Careful: non-xofields are not passed correctly between copy's / to_dict. This messes with flags etc..
@@ -259,7 +304,7 @@ class BaseCollimator(BaseBlock):
 
     @property
     def angle_R(self):
-        return round(np.rad2deg(np.arctan2(self._sin_zL, self._cos_zL)), 10)
+        return round(np.rad2deg(np.arctan2(self._sin_zR, self._cos_zR)), 10)
 
     @angle_R.setter
     def angle_R(self, angle_R):
@@ -336,7 +381,7 @@ class BaseCollimator(BaseBlock):
         diff = val - (self._jaw_LU + self._jaw_LD) / 2
         self._jaw_LU += diff
         self._jaw_LD += diff
-        self._update_gaps()
+        self._update_gaps(only_L=True)
 
     @property
     def jaw_R(self):
@@ -351,11 +396,11 @@ class BaseCollimator(BaseBlock):
             print("Warning: Ignored value for jaw_R (left-sided collimator).")
         if val is None:
             val = -OPEN_JAW
-            self._gap_R = OPEN_GAP
+            self._gap_R = -OPEN_GAP
         diff = val - (self._jaw_RU + self._jaw_RD) / 2
         self._jaw_RU += diff
         self._jaw_RD += diff
-        self._update_gaps()
+        self._update_gaps(only_R=True)
 
     @property
     def jaw_LU(self):
@@ -372,7 +417,7 @@ class BaseCollimator(BaseBlock):
             raise ValueError("Cannot set corner to None! Use open_jaws() or set jaw_L to None.")
         self._jaw_LU = val
         self._update_tilts()   # Extra, to update tilts which are also in C for efficiency
-        self._update_gaps()
+        self._update_gaps(only_L=True)
 
     @property
     def jaw_LD(self):
@@ -389,7 +434,7 @@ class BaseCollimator(BaseBlock):
             raise ValueError("Cannot set corner to None! Use open_jaws() or set jaw_L to None.")
         self._jaw_LD = val
         self._update_tilts()   # Extra, to update tilts which are also in C for efficiency
-        self._update_gaps()
+        self._update_gaps(only_L=True)
 
     @property
     def jaw_RU(self):
@@ -406,7 +451,7 @@ class BaseCollimator(BaseBlock):
             raise ValueError("Cannot set corner to None! Use open_jaws() or set jaw_R to None.")
         self._jaw_RU = val
         self._update_tilts()   # Extra, to update tilts which are also in C for efficiency
-        self._update_gaps()
+        self._update_gaps(only_R=True)
 
     @property
     def jaw_RD(self):
@@ -423,7 +468,23 @@ class BaseCollimator(BaseBlock):
             raise ValueError("Cannot set corner to None! Use open_jaws() or set jaw_R to None.")
         self._jaw_RD = val
         self._update_tilts()   # Extra, to update tilts which are also in C for efficiency
-        self._update_gaps()
+        self._update_gaps(only_R=True)
+
+    @property
+    def jaw_s_LU(self):
+        return self.length/2 * (1 - self._cos_yL)
+
+    @property
+    def jaw_s_LD(self):
+        return self.length/2 * (1 + self._cos_yL)
+
+    @property
+    def jaw_s_RU(self):
+        return self.length/2 * (1 - self._cos_yR)
+
+    @property
+    def jaw_s_RD(self):
+        return self.length/2 * (1 + self._cos_yR)
 
     def open_jaws(self, keep_tilts=False):
         self.jaw_L = None
@@ -441,12 +502,12 @@ class BaseCollimator(BaseBlock):
             self._cos_yR = np.sqrt(1 - self._sin_yR**2)
             self._tan_yR = self._sin_yR / self._cos_yR
 
-    def _update_gaps(self):
+    def _update_gaps(self, only_L=False, only_R=False):
         # If we had set a value for the gap manually, this needs to be updated
         # as well after setting the jaw
-        if self._gap_L_set_manually():
+        if self._gap_L_set_manually() and not only_R:
             self._gap_L = self.gap_L
-        if self._gap_R_set_manually():
+        if self._gap_R_set_manually() and not only_L:
             self._gap_R = self.gap_R
 
 
@@ -536,8 +597,8 @@ class BaseCollimator(BaseBlock):
 
     def assign_optics(self, *, nemitt_x=None, nemitt_y=None, beta_gamma_rel=None, name=None, twiss=None,
                       twiss_upstream=None, twiss_downstream=None):
-        from xcoll import element_classes
-        if not isinstance(self, element_classes):
+        from xcoll.beam_elements import _all_collimator_classes
+        if not isinstance(self, _all_collimator_classes):
             raise ValueError("Please install collimator before assigning optics.")
         if nemitt_x is None:
             if self.nemitt_x is None:
@@ -587,8 +648,8 @@ class BaseCollimator(BaseBlock):
     @nemitt_x.setter
     def nemitt_x(self, val):
         if val is None:
-            self._nemitt_x = 0
-        if val <= 0:
+            val = 0
+        elif val <= 0:
             raise ValueError(f"The field `nemitt_x` should be positive, but got {val}.")
         self._nemitt_x = val
         self._apply_optics()
@@ -602,12 +663,11 @@ class BaseCollimator(BaseBlock):
     @nemitt_y.setter
     def nemitt_y(self, val):
         if val is None:
-            self._nemitt_y = 0
-        else:
-            if val <= 0:
-                raise ValueError(f"The field `nemitt_y` should be positive, but got {val}.")
-            self._nemitt_y = val
-            self._apply_optics()
+            val = 0
+        elif val <= 0:
+            raise ValueError(f"The field `nemitt_y` should be positive, but got {val}.")
+        self._nemitt_y = val
+        self._apply_optics()
 
     @property
     def emittance(self):
@@ -645,7 +705,7 @@ class BaseCollimator(BaseBlock):
                 sigma_L = np.sqrt((sigma_x*self._cos_zL)**2 + (sigma_y*self._sin_zL)**2)
                 sigma_R = np.sqrt((sigma_x*self._cos_zR)**2 + (sigma_y*self._sin_zR)**2)
                 return [sigma_L, sigma_R], [sigma_x, sigma_y]
-            else:
+            else:  # crystal
                 sigma = np.sqrt((sigma_x*self._cos_z)**2 + (sigma_y*self._sin_z)**2)
                 return sigma, [sigma_x, sigma_y]
 
@@ -658,7 +718,7 @@ class BaseCollimator(BaseBlock):
                 co_L = x*self._cos_zL + y*self._sin_zL
                 co_R = x*self._cos_zR + y*self._sin_zR
                 return [co_L, co_R], [x, y]
-            else:
+            else:  # crystal
                 co = x*self._cos_z + y*self._sin_z
                 return co, [x, y]
 
@@ -755,10 +815,10 @@ class BaseCollimator(BaseBlock):
         if val is None:
             val = OPEN_GAP
             self.jaw_L = None
-        if val <= 0:
+        elif val <= 0:
             raise ValueError(f"The field `gap_L` should be positive, but got {val}.")
         self._gap_L = val
-        self._apply_optics()
+        self._apply_optics(only_L=True)
 
     @property
     def gap_R(self):
@@ -775,10 +835,10 @@ class BaseCollimator(BaseBlock):
         if val is None:
             val = -OPEN_GAP
             self.jaw_R = None
-        if val >= 0:
+        elif val >= 0:
             raise ValueError(f"The field `gap_R` should be negative, but got {val}.")
         self._gap_R = val
-        self._apply_optics()
+        self._apply_optics(only_R=True)
 
     @property
     def gap_LU(self):
@@ -806,12 +866,12 @@ class BaseCollimator(BaseBlock):
     def _gap_R_set_manually(self):
         return not np.isclose(self._gap_R, -OPEN_GAP)
 
-    def _apply_optics(self):
+    def _apply_optics(self, only_L=False, only_R=False):
         if self.optics_ready():
             # Only if we have set a value for the gap manually, this needs to be updated
-            if self._gap_L_set_manually():
+            if self._gap_L_set_manually() and not only_R:
                 self.jaw_L = self._gap_L * self.sigma[0][0] + self.co[0][0]
-            if self._gap_R_set_manually():
+            if self._gap_R_set_manually() and not only_L:
                 self.jaw_R = self._gap_R * self.sigma[0][1] + self.co[0][1]
 
 
@@ -862,17 +922,8 @@ class BaseCollimator(BaseBlock):
     # Methods
     # =======
 
-    def enable_scattering(self):
-        if hasattr(self, '_tracking'):
-            if self.optics is None:
-                raise ValueError("Optics not assigned! Cannot enable scattering.")
-            self._tracking = True
-
-    def disable_scattering(self):
-        if hasattr(self, '_tracking'):
-            self._tracking = False
-
     def _verify_consistency(self):
+        BaseBlock._verify_consistency(self)
         # Verify angles
         if abs(self.angle_L - self.angle_R) >= 90.:
             raise ValueError("Angles of both jaws differ more than 90 degrees!")
@@ -908,9 +959,6 @@ class BaseCollimator(BaseBlock):
         # Verify bools
         assert self._side in [-1, 1, 0]
         assert isinstance(self._jaws_parallel, bool) or self._jaws_parallel in [0, 1]
-        assert isinstance(self.active, bool) or self.active in [0, 1]
-        assert isinstance(self.record_touches, bool) or self.record_touches in [0, 1]
-        assert isinstance(self.record_scatterings, bool) or self.record_scatterings in [0, 1]
 
     def jaw_func(self, pos):
         positions = ['LU', 'RU', 'LD', 'RD']
@@ -964,8 +1012,8 @@ class BaseCrystal(BaseBlock):
     skip_in_loss_location_refinement = BaseBlock.skip_in_loss_location_refinement
     allow_double_sided = False
 
-    _skip_in_to_dict  = [f for f in _xofields if f.startswith('_')]
-    _store_in_to_dict = ['angle', 'jaw', 'tilt', 'gap', 'side', 'align', 'emittance',
+    _skip_in_to_dict  = [*BaseBlock._skip_in_to_dict, *[f for f in _xofields if f.startswith('_')]]
+    _store_in_to_dict = [*BaseBlock._store_in_to_dict, 'angle', 'jaw', 'tilt', 'gap', 'side', 'align', 'emittance',
                          'bending_radius', 'bending_angle']
 
     _depends_on = [BaseCollimator]
@@ -1026,8 +1074,6 @@ class BaseCrystal(BaseBlock):
             to_assign['align'] = kwargs.pop('align', 'upstream')
             to_assign['emittance'] = kwargs.pop('emittance', None)
             kwargs.setdefault('active', True)
-            kwargs.setdefault('record_touches', False)
-            kwargs.setdefault('record_scatterings', False)
 
             # Set crystal specific
             if 'bending_angle' in kwargs:
@@ -1299,13 +1345,8 @@ class BaseCrystal(BaseBlock):
     # Methods
     # =======
 
-    def enable_scattering(self):
-        BaseCollimator.enable_scattering(self)
-
-    def disable_scattering(self):
-        BaseCollimator.disable_scattering(self)
-
     def _verify_consistency(self):
+        BaseBlock._verify_consistency(self)
         # Verify angles
         ang = abs(np.arccos(self._cos_z))
         ang = np.pi - ang if ang > np.pi/2 else ang
@@ -1315,10 +1356,7 @@ class BaseCrystal(BaseBlock):
         assert np.isclose(ang, abs(np.arcsin(self._sin_y)))
         assert np.isclose(self._sin_y/self._cos_y, self._tan_y)
         # Verify bools
-        assert self._side in [-1, 1, 0]
-        assert isinstance(self.active, bool) or self.active in [0, 1]
-        assert isinstance(self.record_touches, bool) or self.record_touches in [0, 1]
-        assert isinstance(self.record_scatterings, bool) or self.record_scatterings in [0, 1]
+        assert self._side in [-1, 1]
         # Crystal specific
         assert np.isclose(self._bending_angle, np.arcsin(self.length/self._bending_radius))
 

xcoll/beam_elements/blowup.py

@@ -0,0 +1,198 @@
+# copyright ############################### #
+# This file is part of the Xcoll Package.   #
+# Copyright (c) CERN, 2024.                 #
+# ######################################### #
+
+import numpy as np
+
+import xobjects as xo
+import xtrack as xt
+
+from ..general import _pkg_root
+from .base import InvalidXcoll
+
+
+class BlowUp(InvalidXcoll):
+    _xofields = {
+        '_plane':               xo.Int8,
+        'start_at_turn':        xo.Int64,
+        'stop_at_turn':         xo.Int64,
+        'use_individual_kicks': xo.Int8,
+        '_max_kick':            xo.Float64,
+        '_rans':                xo.Float64[:],
+        '_calibration':         xo.Float64,
+        '_active':              xo.Int8,
+    }
+
+    isthick = False
+    behaves_like_drift = False
+    allow_track = True
+    needs_rng = True
+    skip_in_loss_location_refinement = True
+    allow_loss_refinement = False
+
+    _skip_in_to_dict  = ['_max_kick', '_plane', '_calibration', '_active']
+    _store_in_to_dict = ['amplitude', 'plane', 'calibration']
+
+    _depends_on = [InvalidXcoll, xt.RandomUniform]
+
+    _extra_c_sources = [
+        _pkg_root.joinpath('beam_elements','elements_src','blowup.h')
+    ]
+
+    def __init__(self, **kwargs):
+        to_assign = {}
+        if '_xobject' not in kwargs:
+            start_at_turn = int(kwargs.get('start_at_turn', 0))
+            stop_at_turn  = int(kwargs.get('stop_at_turn', start_at_turn+1))
+            kwargs['start_at_turn'] = start_at_turn
+            kwargs['stop_at_turn']  = stop_at_turn
+            kwargs['_rans'] = 2*np.random.uniform(size=stop_at_turn-start_at_turn) - 1
+            if 'plane' in kwargs:
+                to_assign['plane']   = kwargs.pop('plane')
+            to_assign['calibration'] = kwargs.pop('calibration', 1.)
+            to_assign['amplitude']   = kwargs.pop('amplitude', 1)
+            kwargs['_calibration']   = 1.
+        super().__init__(**kwargs)
+        for key, val in to_assign.items():
+            setattr(self, key, val)
+
+
+    @classmethod
+    def install(cls, line, name, *, at_s=None, at=None, need_apertures=True, aperture=None, s_tol=1.e-6, **kwargs):
+        self = cls(**kwargs)
+        line.insert_element(element=self, name=name, at_s=at_s, at=at, s_tol=s_tol)
+        self._name = name
+        self._line = line
+        if need_apertures:
+            if aperture is not None:
+                aper_upstream   = aperture.copy()
+                aper_downstream = aperture.copy()
+            else:
+                idx = line.element_names.index(name)
+                while True:
+                    if xt.line._is_aperture(line.elements[idx], line):
+                        aper_upstream = line.elements[idx].copy()
+                        break
+                    idx -= 1
+                idx = line.element_names.index(name)
+                while True:
+                    if xt.line._is_aperture(line.elements[idx], line):
+                        aper_downstream = line.elements[idx].copy()
+                        break
+                    idx += 1
+            line.insert_element(element=aper_upstream, name=f'{name}_aper_upstream', at=name, s_tol=s_tol)
+            idx = line.element_names.index(name) + 1
+            line.insert_element(element=aper_downstream, name=f'{name}_aper_downstream', at=idx, s_tol=s_tol)
+        return self
+
+    def get_backtrack_element(self, _context=None, _buffer=None, _offset=None):
+        return xt.Marker(_context=_context, _buffer=_buffer, _offset=_offset)
+
+
+    @property
+    def plane(self):
+        if self._plane == 1:
+            return 'H'
+        elif self._plane == -1:
+            return 'V'
+        else:
+            raise ValueError("The plane of the BlowUp is not recognized.")
+
+    @plane.setter
+    def plane(self, val):
+        if val.lower() == 'h':
+            self._plane = 1
+        elif val.lower() == 'v':
+            self._plane = -1
+        else:
+            raise ValueError("The plane of the BlowUp must be either 'H' or 'V'.")
+
+    @property
+    def amplitude(self):
+        return (self._max_kick / self.calibration)**2
+
+    @amplitude.setter
+    def amplitude(self, val):
+        if val< 0:
+            raise ValueError("The amplitude cannot be negative!")
+        self._max_kick = np.sqrt(val) * self.calibration
+
+    @property
+    def calibration(self):
+        return self._calibration
+
+    @calibration.setter
+    def calibration(self, val):
+        if val< 0:
+            raise ValueError("The calibration cannot be negative!")
+        previous_amplitude = self.amplitude
+        self._calibration = val
+        self.amplitude = previous_amplitude
+
+    @property
+    def name(self):
+        if not hasattr(self, '_name'):
+            raise ValueError("Name not set! Install the blow-up using xc.BlowUp.install() "
+                             "or manually set the name after installation.")
+        return self._name
+
+    @name.setter
+    def name(self, val):
+        self._name = val
+
+    @property
+    def line(self):
+        if not hasattr(self, '_line'):
+            raise ValueError("Line not set! Install the blow-up using xc.BlowUp.install() "
+                             "or manually set the line after installation.")
+        return self._line
+
+    @line.setter
+    def line(self, val):
+        self._line = val
+
+
+    def calibrate_by_emittance(self, nemitt, *, twiss=None, beta_gamma_rel=None):
+        # The emittance gained per turn of blow up can be calculated as follows:
+        #     <px^2> = gamma * eps
+        #     gamma * eps = <px^2> = <(px0 + dpx)^2>
+        # where px0 is the initial momentum and dpx is the kick, and eps0 and eps
+        # are the geometric emittance before resp. after the kick, and gamma is the
+        # Courant-Snyder parameter.
+        # If each particle gets another random kick, we can write:
+        #     <(px0 + dpx)^2> = <px0^2> + 2<px0 dpx> + <dpx^2>
+        #                     = gamma * eps0 + 2<px0 dpx> + 1/3 dpx_max^2    (variance of uniform distribution is 1/12(b-a)^2)
+        # The covariance can be estimated with an upper bound:
+        #     0  <=  2<px0 dpx>  <=  2*sqrt(<px0^2> <dpx^2>)
+        #                         = 2/sqrt(3) * sqrt(gamma * eps0) * dpx_max
+        # So that we finally get for the emittance growth after one turn of blow-up:
+        #     deps = (eps-eps0)/eps0 = [dPM^2, dPM^2 + 2dPM]    (dPM = dpx_max/sqrt(3 * gamma * eps0))
+        # Or, to get an emittance growth of deps, we need:
+        #     dpx_max = [sqrt(3* gamma * eps0 * deps), sqrt(3 * gamma * eps0)*(sqrt(1+deps) -1)]
+        # If all particles get the same kick, we can write:
+        #     <(px0 + dpx)^2> = <px0^2> + 2<px0> dpx
+        # However, now things get a bit more complicated. At the start <px0> is the closed orbit,
+        # but when the bunch has had a kick in the previous turn, the bunch is no longer centred
+        # around the closed orbit. We can write:
+        #     deps = (eps-eps0)/eps0 = 2<px0> dpx/gamma/eps0
+        name = self.name
+        line = self.line
+        if beta_gamma_rel is None:
+            if not hasattr(line, 'particle_ref'):
+                raise ValueError("The provided line has no reference particle. Use the argument `beta_gamma_rel`")
+            beta_gamma_rel = line.particle_ref.gamma0[0]*line.particle_ref.beta0[0]
+        if twiss is None:
+            twiss = line.twiss()
+        gamma = twiss.rows[name][f"gam{'x' if self.plane == 'H' else 'y'}"][0]
+        # Asumming a Gaussian beam, we will have shifted all beam beyond 5 sigma with an emittance growth
+        # of around a factor 60. In practive, a ~50x increase is enough due to the covariance terms.
+        # We want to do this slowly, over 1000 turns.
+        deps = 50/1000
+        self.calibration = np.sqrt(3*gamma*nemitt/beta_gamma_rel*deps)
+
+    def activate(self):
+        self._active = True
+
+    def deactivate(self):
+        self._active = False

xcoll/beam_elements/{collimators_src → elements_src}/black_absorber.h

@@ -7,6 +7,22 @@
 #define XCOLL_ABSORBER_H
 
 
+/*gpufun*/
+int8_t BlackAbsorberData_get_record_impacts(BlackAbsorberData el){
+    return BlackAbsorberData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t BlackAbsorberData_get_record_exits(BlackAbsorberData el){
+    return (BlackAbsorberData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t BlackAbsorberData_get_record_scatterings(BlackAbsorberData el){
+    return (BlackAbsorberData_get__record_interactions(el) >> 2) % 2;
+}
+
+
 /*gpufun*/
 CollimatorGeometry BlackAbsorber_init_geometry(BlackAbsorberData el, LocalParticle* part0, int8_t active){
     CollimatorGeometry cg = (CollimatorGeometry) malloc(sizeof(CollimatorGeometry_));
@@ -46,10 +62,12 @@ CollimatorGeometry BlackAbsorber_init_geometry(BlackAbsorberData el, LocalPartic
         // Impact table
         cg->record = BlackAbsorberData_getp_internal_record(el, part0);
         cg->record_index = NULL;
-        cg->record_touches = 0;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
         if (cg->record){
             cg->record_index = InteractionRecordData_getp__index(cg->record);
-            cg->record_touches = BlackAbsorberData_get_record_touches(el);
+            cg->record_impacts = BlackAbsorberData_get_record_impacts(el);
+            cg->record_exits = BlackAbsorberData_get_record_exits(el);
         }
     }
 
@@ -115,4 +133,4 @@ void BlackAbsorber_track_local_particle(BlackAbsorberData el, LocalParticle* par
     BlackAbsorber_free(cg, active);
 }
 
-#endif /* XCOLL_COLL_GEOM_H */
+#endif /* XCOLL_ABSORBER_H */