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

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/elements_src/black_absorber.h

@@ -0,0 +1,136 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_ABSORBER_H
+#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_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        // Jaw corners (with tilts)
+        cg->jaw_LU = BlackAbsorberData_get__jaw_LU(el);
+        cg->jaw_RU = BlackAbsorberData_get__jaw_RU(el);
+        // Get angles of jaws
+        cg->sin_zL = BlackAbsorberData_get__sin_zL(el);
+        cg->cos_zL = BlackAbsorberData_get__cos_zL(el);
+        cg->sin_zR = BlackAbsorberData_get__sin_zR(el);
+        cg->cos_zR = BlackAbsorberData_get__cos_zR(el);
+        cg->sin_zDiff = BlackAbsorberData_get__sin_zDiff(el);
+        cg->cos_zDiff = BlackAbsorberData_get__cos_zDiff(el);
+        cg->jaws_parallel = BlackAbsorberData_get__jaws_parallel(el);
+        // Tilts
+        cg->sin_yL = BlackAbsorberData_get__sin_yL(el);
+        cg->cos_yL = BlackAbsorberData_get__cos_yL(el);
+        cg->sin_yR = BlackAbsorberData_get__sin_yR(el);
+        cg->cos_yR = BlackAbsorberData_get__cos_yR(el);
+        // Length and segments
+        cg->length = BlackAbsorberData_get_length(el);
+        cg->side   = BlackAbsorberData_get__side(el);
+        double s_U, s_D, x_D;
+        if (cg->side != -1){
+            s_U = cg->length/2 * (1-cg->cos_yL);
+            s_D = cg->length/2 * (1+cg->cos_yL);
+            x_D = BlackAbsorberData_get__jaw_LD(el);
+            cg->segments_L = create_jaw(s_U, cg->jaw_LU, s_D, x_D, cg->sin_yL/cg->cos_yL, 1);
+        }
+        if (cg->side != 1){
+            s_U = cg->length/2 * (1-cg->cos_yR);
+            s_D = cg->length/2 * (1+cg->cos_yR);
+            x_D = BlackAbsorberData_get__jaw_RD(el);
+            cg->segments_R = create_jaw(s_U, cg->jaw_RU, s_D, x_D, cg->sin_yR/cg->cos_yR, -1);
+        }
+        // Impact table
+        cg->record = BlackAbsorberData_getp_internal_record(el, part0);
+        cg->record_index = NULL;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
+        if (cg->record){
+            cg->record_index = InteractionRecordData_getp__index(cg->record);
+            cg->record_impacts = BlackAbsorberData_get_record_impacts(el);
+            cg->record_exits = BlackAbsorberData_get_record_exits(el);
+        }
+    }
+
+    return cg;
+}
+
+/*gpufun*/
+void BlackAbsorber_free(CollimatorGeometry restrict cg, int8_t active){
+    if (active){
+        if (cg->side != -1){
+            destroy_jaw(cg->segments_L);
+        }
+        if (cg->side != 1){
+            destroy_jaw(cg->segments_R);
+        }
+    }
+    free(cg);
+}
+
+
+/*gpufun*/
+void BlackAbsorber_track_local_particle(BlackAbsorberData el, LocalParticle* part0){
+
+    // Collimator active and length
+    int8_t active = BlackAbsorberData_get_active(el);
+    active       *= BlackAbsorberData_get__tracking(el);
+    double const length = BlackAbsorberData_get_length(el);
+
+    // Get geometry
+    CollimatorGeometry cg     = BlackAbsorber_init_geometry(el, part0, active);
+    int8_t record_scatterings = BlackAbsorberData_get_record_scatterings(el);
+
+    //start_per_particle_block (part0->part)
+        if (!active){
+            // Drift full length
+            Drift_single_particle(part, length);
+
+        } else {
+            // Check collimator initialisation
+            int8_t is_tracking = assert_tracking(part, XC_ERR_INVALID_TRACK);
+
+            if (is_tracking) {
+                // Store s-location of start of collimator
+                double s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Check if hit on jaws
+                int8_t is_hit = hit_jaws_check_and_transform(part, cg);
+
+                if (is_hit != 0){
+                    LocalParticle_set_state(part, XC_LOST_ON_ABSORBER);
+                    if (record_scatterings) {
+                        InteractionRecordData_log(cg->record, cg->record_index, part, XC_ABSORBED);  // In coll jaw reference frame
+                    }
+                }
+
+                // Transform back to the lab frame
+                hit_jaws_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
+            }
+        }
+    //end_per_particle_block
+    BlackAbsorber_free(cg, active);
+}
+
+#endif /* XCOLL_ABSORBER_H */

xcoll/beam_elements/elements_src/black_crystal.h

@@ -0,0 +1,129 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_ABSORBER_CRY_H
+#define XCOLL_ABSORBER_CRY_H
+
+
+/*gpufun*/
+int8_t BlackCrystalData_get_record_impacts(BlackCrystalData el){
+    return BlackCrystalData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t BlackCrystalData_get_record_exits(BlackCrystalData el){
+    return (BlackCrystalData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t BlackCrystalData_get_record_scatterings(BlackCrystalData el){
+    return (BlackCrystalData_get__record_interactions(el) >> 2) % 2;
+}
+
+
+/*gpufun*/
+CrystalGeometry BlackCrystal_init_geometry(BlackCrystalData el, LocalParticle* part0, int8_t active){
+    CrystalGeometry cg = (CrystalGeometry) malloc(sizeof(CrystalGeometry_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        cg->length = BlackCrystalData_get_length(el);
+        cg->side   = BlackCrystalData_get__side(el);
+        cg->bending_radius = BlackCrystalData_get__bending_radius(el);
+        cg->bending_angle  = BlackCrystalData_get__bending_angle(el);
+        cg->width  = BlackCrystalData_get_width(el);
+        cg->height = BlackCrystalData_get_height(el);
+        cg->jaw_U  = BlackCrystalData_get__jaw_U(el);
+        cg->sin_z  = BlackCrystalData_get__sin_z(el);
+        cg->cos_z  = BlackCrystalData_get__cos_z(el);
+        cg->sin_y  = BlackCrystalData_get__sin_y(el);
+        cg->cos_y  = BlackCrystalData_get__cos_y(el);
+        double jaw;
+        if (cg->side == 1){
+            jaw = cg->jaw_U;
+        } else if (cg->side == -1){
+            jaw = cg->jaw_U - cg->width;   // To ensure that jaw_U is the inner corner
+        } else {
+            kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+            return cg;
+        }
+        cg->segments = create_crystal(cg->bending_radius, cg->width, cg->length, jaw, cg->sin_y, cg->cos_y);
+        // Impact table
+        cg->record = BlackCrystalData_getp_internal_record(el, part0);
+        cg->record_index = NULL;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
+        if (cg->record){
+            cg->record_index = InteractionRecordData_getp__index(cg->record);
+            cg->record_impacts = BlackCrystalData_get_record_impacts(el);
+            cg->record_exits = BlackCrystalData_get_record_exits(el);
+        }
+        // Not needed, set to zero
+        cg->miscut_angle = 0;
+        cg->s_P = 0;
+        cg->x_P = 0;
+        cg->t_VImax = 0;
+    }
+
+    return cg;
+}
+
+/*gpufun*/
+void BlackCrystal_free(CrystalGeometry restrict cg, int8_t active){
+    if (active){
+        destroy_crystal(cg->segments);
+    }
+    free(cg);
+}
+
+
+/*gpufun*/
+void BlackCrystal_track_local_particle(BlackCrystalData el, LocalParticle* part0){
+
+    // Collimator active and length
+    int8_t active = BlackCrystalData_get_active(el);
+    active       *= BlackCrystalData_get__tracking(el);
+    double const length = BlackCrystalData_get_length(el);
+
+    // Get geometry
+    CrystalGeometry cg        = BlackCrystal_init_geometry(el, part0, active);
+    int8_t record_scatterings = BlackCrystalData_get_record_scatterings(el);
+
+    if (cg->width==0 || cg->height==0 || cg->bending_radius==0){
+        kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+    }
+
+    //start_per_particle_block (part0->part)
+        if (!active){
+            // Drift full length
+            Drift_single_particle(part, length);
+
+        } else {
+            // Check collimator initialisation
+            int8_t is_tracking = assert_tracking(part, XC_ERR_INVALID_TRACK);
+
+            if (is_tracking) {
+                // Store s-location of start of collimator
+                double s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Check if hit on jaws
+                int8_t is_hit = hit_crystal_check_and_transform(part, cg);
+
+                if (is_hit != 0){
+                    LocalParticle_set_state(part, XC_LOST_ON_ABSORBER);
+                    if (record_scatterings) {
+                        InteractionRecordData_log(cg->record, cg->record_index, part, XC_ABSORBED);  // In coll jaw reference frame
+                    }
+                }
+
+                // Transform back to the lab frame
+                hit_crystal_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
+            }
+        }
+    //end_per_particle_block
+    BlackCrystal_free(cg, active);
+}
+
+#endif /* XCOLL_ABSORBER_CRY_H */

xcoll/beam_elements/elements_src/blowup.h

@@ -0,0 +1,42 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_BLOWUP_H
+#define XCOLL_BLOWUP_H
+
+/*gpufun*/
+void BlowUp_track_local_particle(BlowUpData el, LocalParticle* part0){
+
+    int8_t plane          = BlowUpData_get__plane(el);
+    double max_kick       = BlowUpData_get__max_kick(el);
+    int8_t active         = BlowUpData_get__active(el);
+    int8_t individual     = BlowUpData_get_use_individual_kicks(el);
+    int64_t start_at_turn = BlowUpData_get_start_at_turn(el);
+    int64_t stop_at_turn  = BlowUpData_get_stop_at_turn(el);
+
+    //start_per_particle_block (part0->part)
+        if (active){
+            int64_t at_turn = LocalParticle_get_at_turn(part);
+            if (at_turn >= start_at_turn && at_turn < stop_at_turn){
+                double ran;
+                if (individual){
+                    ran = (2*RandomUniform_generate(part) - 1);
+                } else {
+                    ran = BlowUpData_get__rans(el, at_turn - start_at_turn);
+                }
+                double kick = max_kick * ran;
+                if (plane == 1){
+                    LocalParticle_add_to_px(part, kick);
+                } else if (plane == -1){
+                    LocalParticle_add_to_py(part, kick);
+                } else {
+                    LocalParticle_kill_particle(part, XC_ERR_INVALID_XOFIELD);
+                }
+            }
+        }
+    //end_per_particle_block
+}
+
+#endif /* XCOLL_BLOWUP_H */

xcoll/beam_elements/elements_src/emittance_monitor.h

@@ -0,0 +1,109 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_EMITTANCE_MONITOR_H
+#define XCOLL_EMITTANCE_MONITOR_H
+
+#ifndef C_LIGHT
+#define C_LIGHT 299792458.0
+#endif
+
+/*gpufun*/
+void EmittanceMonitor_track_local_particle(EmittanceMonitorData el, LocalParticle* part0){
+    EmittanceMonitorData_set__cached(el, 0);
+    int64_t const start_at_turn = EmittanceMonitorData_get_start_at_turn(el);
+    int64_t const part_id_start = EmittanceMonitorData_get_part_id_start(el);
+    int64_t const part_id_end   = EmittanceMonitorData_get_part_id_end(el);
+    double const frev = EmittanceMonitorData_get_frev(el);
+    double const sampling_frequency = EmittanceMonitorData_get_sampling_frequency(el);
+
+    EmittanceMonitorRecord record = EmittanceMonitorData_getp_data(el);
+
+    int64_t max_slot = EmittanceMonitorRecord_len_count(record);
+
+    int const plane_selector = EmittanceMonitorData_get__plane_selector(el);
+    int const monitor_horizontal   =  plane_selector % 2;
+    int const monitor_vertical     = (plane_selector >> 1) % 2;
+    int const monitor_longitudinal = (plane_selector >> 2) % 2;
+
+    //start_per_particle_block(part0->part)
+        int64_t particle_id = LocalParticle_get_particle_id(part);
+        if (part_id_end < 0 || (part_id_start <= particle_id && particle_id < part_id_end)){
+
+            // zeta is the absolute path length deviation from the reference particle: zeta = (s - beta0*c*t)
+            // but without limits, i.e. it can exceed the circumference (for coasting beams)
+            // as the particle falls behind or overtakes the reference particle
+            double const zeta = LocalParticle_get_zeta(part);
+            double const beta0 = LocalParticle_get_beta0(part);
+            double const at_turn = LocalParticle_get_at_turn(part);
+
+            double x =0;
+            double px = 0;
+            double y = 0;
+            double py = 0;
+            double pzeta = 0;
+
+            // compute sample index
+            int64_t slot = round(sampling_frequency * ( (at_turn-start_at_turn)/frev - zeta/beta0/C_LIGHT ));
+
+            if (slot >= 0 && slot < max_slot){
+                /*gpuglmem*/ double *count = EmittanceMonitorRecord_getp1_count(record, slot); atomicAdd(count, 1);
+
+                if (monitor_horizontal){
+                    x  = LocalParticle_get_x(part);
+                    px = LocalParticle_get_px(part);
+                    /*gpuglmem*/ double *x_sum1     = EmittanceMonitorRecord_getp1_x_sum1(record, slot);     atomicAdd(x_sum1, x);
+                    /*gpuglmem*/ double *px_sum1    = EmittanceMonitorRecord_getp1_px_sum1(record, slot);    atomicAdd(px_sum1, px);
+                    /*gpuglmem*/ double *x_x_sum2   = EmittanceMonitorRecord_getp1_x_x_sum2(record, slot);   atomicAdd(x_x_sum2, x*x);
+                    /*gpuglmem*/ double *x_px_sum2  = EmittanceMonitorRecord_getp1_x_px_sum2(record, slot);  atomicAdd(x_px_sum2, x*px);
+                    /*gpuglmem*/ double *px_px_sum2 = EmittanceMonitorRecord_getp1_px_px_sum2(record, slot); atomicAdd(px_px_sum2, px*px);
+                }
+
+                if (monitor_vertical){
+                    y  = LocalParticle_get_y(part);
+                    py = LocalParticle_get_py(part);
+                    /*gpuglmem*/ double *y_sum1     = EmittanceMonitorRecord_getp1_y_sum1(record, slot);     atomicAdd(y_sum1, y);
+                    /*gpuglmem*/ double *py_sum1    = EmittanceMonitorRecord_getp1_py_sum1(record, slot);    atomicAdd(py_sum1, py);
+                    /*gpuglmem*/ double *y_y_sum2   = EmittanceMonitorRecord_getp1_y_y_sum2(record, slot);   atomicAdd(y_y_sum2, y*y);
+                    /*gpuglmem*/ double *y_py_sum2  = EmittanceMonitorRecord_getp1_y_py_sum2(record, slot);  atomicAdd(y_py_sum2, y*py);
+                    /*gpuglmem*/ double *py_py_sum2 = EmittanceMonitorRecord_getp1_py_py_sum2(record, slot); atomicAdd(py_py_sum2, py*py);
+                }
+
+                if (monitor_longitudinal){
+                    double const ptau = LocalParticle_get_ptau(part);
+                    pzeta = ptau/beta0;
+                    /*gpuglmem*/ double *zeta_sum1        = EmittanceMonitorRecord_getp1_zeta_sum1(record, slot);        atomicAdd(zeta_sum1, zeta);
+                    /*gpuglmem*/ double *pzeta_sum1       = EmittanceMonitorRecord_getp1_pzeta_sum1(record, slot);       atomicAdd(pzeta_sum1, pzeta);
+                    /*gpuglmem*/ double *zeta_zeta_sum2   = EmittanceMonitorRecord_getp1_zeta_zeta_sum2(record, slot);   atomicAdd(zeta_zeta_sum2, zeta*zeta);
+                    /*gpuglmem*/ double *zeta_pzeta_sum2  = EmittanceMonitorRecord_getp1_zeta_pzeta_sum2(record, slot);  atomicAdd(zeta_pzeta_sum2, zeta*pzeta);
+                    /*gpuglmem*/ double *pzeta_pzeta_sum2 = EmittanceMonitorRecord_getp1_pzeta_pzeta_sum2(record, slot); atomicAdd(pzeta_pzeta_sum2, pzeta*pzeta);
+                }
+
+                if (monitor_horizontal && monitor_vertical){
+                    /*gpuglmem*/ double *x_y_sum2   = EmittanceMonitorRecord_getp1_x_y_sum2(record, slot);   atomicAdd(x_y_sum2, x*y);
+                    /*gpuglmem*/ double *x_py_sum2  = EmittanceMonitorRecord_getp1_x_py_sum2(record, slot);  atomicAdd(x_py_sum2, x*py);
+                    /*gpuglmem*/ double *px_y_sum2  = EmittanceMonitorRecord_getp1_px_y_sum2(record, slot);  atomicAdd(px_y_sum2, px*y);
+                    /*gpuglmem*/ double *px_py_sum2 = EmittanceMonitorRecord_getp1_px_py_sum2(record, slot); atomicAdd(px_py_sum2, px*py);
+                }
+
+                if (monitor_horizontal && monitor_longitudinal){
+                    /*gpuglmem*/ double *x_zeta_sum2   = EmittanceMonitorRecord_getp1_x_zeta_sum2(record, slot);   atomicAdd(x_zeta_sum2, x*zeta);
+                    /*gpuglmem*/ double *x_pzeta_sum2  = EmittanceMonitorRecord_getp1_x_pzeta_sum2(record, slot);  atomicAdd(x_pzeta_sum2, x*pzeta);
+                    /*gpuglmem*/ double *px_zeta_sum2  = EmittanceMonitorRecord_getp1_px_zeta_sum2(record, slot);  atomicAdd(px_zeta_sum2, px*zeta);
+                    /*gpuglmem*/ double *px_pzeta_sum2 = EmittanceMonitorRecord_getp1_px_pzeta_sum2(record, slot); atomicAdd(px_pzeta_sum2, px*pzeta);
+                }
+
+                if (monitor_vertical && monitor_longitudinal){
+                    /*gpuglmem*/ double *y_zeta_sum2   = EmittanceMonitorRecord_getp1_y_zeta_sum2(record, slot);   atomicAdd(y_zeta_sum2, y*zeta);
+                    /*gpuglmem*/ double *y_pzeta_sum2  = EmittanceMonitorRecord_getp1_y_pzeta_sum2(record, slot);  atomicAdd(y_pzeta_sum2, y*pzeta);
+                    /*gpuglmem*/ double *py_zeta_sum2  = EmittanceMonitorRecord_getp1_py_zeta_sum2(record, slot);  atomicAdd(py_zeta_sum2, py*zeta);
+                    /*gpuglmem*/ double *py_pzeta_sum2 = EmittanceMonitorRecord_getp1_py_pzeta_sum2(record, slot); atomicAdd(py_pzeta_sum2, py*pzeta);
+                }
+            }
+        }
+	//end_per_particle_block
+}
+
+#endif /* XCOLL_EMITTANCE_MONITOR_H */