xtrack 0.89.0__tar.gz → 0.89.2__tar.gz

{xtrack-0.89.0/xtrack.egg-info → xtrack-0.89.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.89.0
+Version: 0.89.2
 Summary: Tracking library for particle accelerators
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xtrack

{xtrack-0.89.0 → xtrack-0.89.2}/tests/test_madnginterface.py

@@ -126,4 +126,41 @@ def test_madng_survey():
     xo.assert_allclose(survey.angle, xsurvey.angle, atol=1e-5, rtol=0)
     xo.assert_allclose(survey.tilt, xsurvey.rot_s_rad, atol=1e-5, rtol=0)
     # Length doesn't work because of multipoles.
-    #xo.assert_allclose(survey.length, xsurvey.length, atol=1e-5, rtol=0)
+    #xo.assert_allclose(survey.length, xsurvey.length, atol=1e-5, rtol=0)
+
+def test_madng_conversion_drift_slice():
+
+    env = xt.Environment()
+    env.particle_ref = xt.Particles(p0c=1e9)
+
+    line = env.new_line(length=10, components=[
+        env.new('q1', xt.Quadrupole, length=1, k1=0.3, at=4),
+        env.new('q2', xt.Quadrupole, length=1, k1=-0.3, at=6)
+    ])
+
+    line.insert('m', xt.Marker(), at=2)
+
+    tt = line.get_table()
+    # is:
+    # Table: 8 rows, 11 cols
+    # name                   s element_type isthick isreplica parent_name ...
+    # drift_1..0             0 DriftSlice      True     False drift_1
+    # m                      2 Marker         False     False None
+    # drift_1..1             2 DriftSlice      True     False drift_1
+    # q1                   3.5 Quadrupole      True     False None
+    # drift_2              4.5 Drift           True     False None
+    # q2                   5.5 Quadrupole      True     False None
+    # drift_3              6.5 Drift           True     False None
+    # _end_point            10                False     False None
+
+    assert np.all(tt.name == [
+        'drift_1..0', 'm', 'drift_1..1', 'q1', 'drift_2', 'q2', 'drift_3', '_end_point'])
+    xo.assert_allclose(tt.s, [0, 2, 2, 3.5, 4.5, 5.5, 6.5, 10], atol=1e-10)
+    assert np.all(tt.element_type == [
+        'DriftSlice', 'Marker', 'DriftSlice', 'Quadrupole', 'Drift', 'Quadrupole', 'Drift', ''])
+
+    tw = line.twiss4d()
+    tw_ng = line.madng_twiss(normal_form=False)
+
+    xo.assert_allclose(tw_ng.beta11_ng, tw.betx, rtol=1e-8)
+    xo.assert_allclose(tw_ng.beta22_ng, tw.bety, rtol=1e-8)

{xtrack-0.89.0 → xtrack-0.89.2}/tests/test_tapering.py

@@ -29,7 +29,7 @@ def test_tapering_and_twiss_with_radiation():
 
     # Initial twiss (no radiation)
     line.configure_radiation(model=None)
-    tw_no_rad = line.twiss(method='4d', freeze_longitudinal=True)
+    tw_no_rad = line.twiss(method='4d')
 
     assert tw_no_rad.radiation_method == None
 
@@ -145,7 +145,7 @@ def test_tapering_zero_mean():
     line.particle_ref.p0c = 4e9  # eV
 
     line.configure_radiation(model=None)
-    tw_no_rad = line.twiss(method='4d', freeze_longitudinal=True)
+    tw_no_rad = line.twiss(method='4d')
 
     ###############################################
     # Enable radiation and compensate energy loss #

xtrack-0.89.2/xtrack/_version.py

@@ -0,0 +1 @@
+__version__ = '0.89.2'

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/base_element.py

@@ -15,6 +15,7 @@ from xobjects.hybrid_class import _build_xofields_dict
 from .general import _pkg_root
 from .internal_record import RecordIdentifier, RecordIndex, generate_get_record
 from .particles import Particles
+from .track_flags import c_header_flag_mapping
 
 start_per_part_block = """
     {
@@ -280,6 +281,7 @@ def _generate_per_particle_kernel_from_local_particle_function(
             for (int64_t batch_id = 0; batch_id < num_threads; batch_id++) {                   //only_for_context cpu_openmp
                 LocalParticle lpart;
                 lpart.io_buffer = io_buffer;
+                lpart.track_flags = 0;
                 int64_t part_id = batch_id * chunk_size;                                       //only_for_context cpu_openmp
                 int64_t end_id = (batch_id + 1) * chunk_size;                                  //only_for_context cpu_openmp
                 if (end_id > num_particles_to_track) end_id = num_particles_to_track;          //only_for_context cpu_openmp
@@ -452,6 +454,7 @@ class MetaBeamElement(xo.MetaHybridClass):
             _pkg_root.joinpath('headers','particle_states.h'),
             _pkg_root.joinpath('beam_elements', 'elements_src', 'track_srotation.h'),
             _pkg_root.joinpath('beam_elements', 'elements_src', 'track_drift.h'),
+            c_header_flag_mapping
         ]
         kernels = {}
 

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/beam_elements/elements_src/dipoleedge.h

@@ -18,22 +18,21 @@ void DipoleEdge_track_local_particle(DipoleEdgeData el, LocalParticle* part0){
 
     int64_t const model = DipoleEdgeData_get_model(el);
 
-    #ifdef XTRACK_MULTIPOLE_NO_SYNRAD
-        double const delta_taper = 0.0;
-    #else
-        #ifndef XTRACK_DIPOLEEDGE_TAPER
-        double const delta_taper = DipoleEdgeData_get_delta_taper(el);
-        #endif
+    double delta_taper = 0.0;
+    #ifndef XTRACK_MULTIPOLE_NO_SYNRAD
+        if (!LocalParticle_check_track_flag(part0, XS_FLAG_SR_TAPER)){
+            delta_taper = DipoleEdgeData_get_delta_taper(el);
+        }
     #endif
 
     if (model == 0){
         double r21 = DipoleEdgeData_get_r21(el);
         double r43 = DipoleEdgeData_get_r43(el);
 
-        #ifndef XTRACK_DIPOLEEDGE_TAPER
+        if (!LocalParticle_check_track_flag(part0, XS_FLAG_SR_TAPER)){
             r21 = r21 * (1 + delta_taper);
             r43 = r43 * (1 + delta_taper);
-        #endif
+        }
 
         #ifdef XSUITE_BACKTRACK
             r21 = -r21;
@@ -41,11 +40,11 @@ void DipoleEdge_track_local_particle(DipoleEdgeData el, LocalParticle* part0){
         #endif
 
         START_PER_PARTICLE_BLOCK(part0, part);
-            #ifdef XTRACK_DIPOLEEDGE_TAPER
+            if (LocalParticle_check_track_flag(part0, XS_FLAG_SR_TAPER)){
                 double const delta_taper = LocalParticle_get_delta(part);
                 r21 = r21 * (1 + delta_taper);
                 r43 = r43 * (1 + delta_taper);
-            #endif
+            }
 
             DipoleEdgeLinear_single_particle(part, r21, r43);
         END_PER_PARTICLE_BLOCK;

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/beam_elements/elements_src/linesegmentmap.h

@@ -204,6 +204,8 @@ void longitudinal_motion(LocalParticle *part0,
         double const bucket_length = LineSegmentMapData_get_bucket_length(el)*LocalParticle_get_beta0(part0)*C_LIGHT;
         double const sin_s = sin(2 * PI * qs);
         double const cos_s = cos(2 * PI * qs);
+        uint8_t kill_energy_kick = LocalParticle_check_track_flag(
+                    part0, XS_FLAG_KILL_CAVITY_KICK);
         START_PER_PARTICLE_BLOCK(part0, part);
             // We set cos_s = 999 if long map is to be skipped
             double shift = 0.0;
@@ -215,7 +217,9 @@ void longitudinal_motion(LocalParticle *part0,
             double const new_pzeta = sin_s * LocalParticle_get_zeta(part) / bets + cos_s * LocalParticle_get_pzeta(part);
 
             LocalParticle_set_zeta(part, new_zeta+shift);
-            LocalParticle_update_pzeta(part, new_pzeta);
+            if (!kill_energy_kick){
+                LocalParticle_update_pzeta(part, new_pzeta);
+            }
         END_PER_PARTICLE_BLOCK;
     }
     else if (mode_flag==2){ // non-linear motion
@@ -325,6 +329,8 @@ GPUFUN
 void correlated_radiation_damping(LocalParticle *part0,
             LineSegmentMapData el){
 
+    uint8_t kill_energy_kick = LocalParticle_check_track_flag(
+                    part0, XS_FLAG_KILL_CAVITY_KICK);
     START_PER_PARTICLE_BLOCK(part0, part);
         double in[6];
         in[0] = LocalParticle_get_x(part);
@@ -345,7 +351,8 @@ void correlated_radiation_damping(LocalParticle *part0,
         LocalParticle_set_y(part, out[2]);
         LocalParticle_set_py(part, out[3]);
         LocalParticle_set_zeta(part, out[4]);
-        LocalParticle_update_pzeta(part,out[5]);
+        if (!kill_energy_kick){
+            LocalParticle_update_pzeta(part,out[5]);}
     END_PER_PARTICLE_BLOCK;
 }
 

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/beam_elements/elements_src/track_magnet.h

@@ -400,12 +400,12 @@ void track_magnet_particles(
     #endif
 
     // Tapering
-    #ifdef XTRACK_MULTIPOLE_TAPER // Computing the tapering
+    if (LocalParticle_check_track_flag(part0, XS_FLAG_SR_TAPER)){
         part0->ipart = 0;
         delta_taper = LocalParticle_get_delta(part0); // I can use part0 because
                                                       // there is only one particle
                                                       // when doing the tapering
-    #endif
+    }
 
     #ifndef XTRACK_MULTIPOLE_NO_SYNRAD
         if (radiation_flag){

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/beam_elements/elements_src/track_magnet.template.h

@@ -319,12 +319,12 @@ void track_magnet_particles(
     #endif
 
     // Tapering
-    #ifdef XTRACK_MULTIPOLE_TAPER // Computing the tapering
+    if (LocalParticle_check_track_flag(part0, XS_FLAG_SR_TAPER)){
         part0->ipart = 0;
         delta_taper = LocalParticle_get_delta(part0); // I can use part0 because
                                                       // there is only one particle
                                                       // when doing the tapering
-    #endif
+    }
 
     #ifndef XTRACK_MULTIPOLE_NO_SYNRAD
         if (radiation_flag){
@@ -348,7 +348,7 @@ void track_magnet_particles(
         if (rbend_model == 2){
             // straight body --> curvature in the edges
             START_PER_PARTICLE_BLOCK(part0, part);
-                YRotation_single_particle(part, sin_rbha, cos_rbha, sin_rbha/cos_rbha);
+                YRotation_single_particle(part, -sin_rbha, cos_rbha, -sin_rbha/cos_rbha);
                 LocalParticle_add_to_x(part, -dx_rb);
             END_PER_PARTICLE_BLOCK;
         }
@@ -500,7 +500,7 @@ void track_magnet_particles(
             // straight body --> curvature in the edges
             START_PER_PARTICLE_BLOCK(part0, part);
                 LocalParticle_add_to_x(part, dx_rb); // shift by half sagitta
-                YRotation_single_particle(part, sin_rbha, cos_rbha, sin_rbha/cos_rbha);
+                YRotation_single_particle(part, -sin_rbha, cos_rbha, -sin_rbha/cos_rbha);
             END_PER_PARTICLE_BLOCK;
         }
     }

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/beam_elements/elements_src/track_rf.h

@@ -28,7 +28,8 @@ void track_rf_kick_single_particle(
     GPUGLMEM const double* knl,
     GPUGLMEM const double* ksl,
     GPUGLMEM const double* pn,
-    GPUGLMEM const double* ps
+    GPUGLMEM const double* ps,
+    const uint8_t kill_energy_kick
 ){
 
     double phase0 = 0;
@@ -140,11 +141,13 @@ void track_rf_kick_single_particle(
     }
 
 
-    #ifdef XTRACK_CAVITY_PRESERVE_ANGLE
-    LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 0);
-    #else
-    LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 1);
-    #endif
+    if (!kill_energy_kick) {
+        #ifdef XTRACK_CAVITY_PRESERVE_ANGLE
+        LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 0);
+        #else
+        LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 1);
+        #endif
+    }
 
 }
 
@@ -167,7 +170,8 @@ void track_rf_body_single_particle(
     GPUGLMEM const double* ps,
     const int64_t num_kicks,
     const int8_t drift_model,
-    const int8_t integrator
+    const int8_t integrator,
+    const uint8_t kill_energy_kick
 ) {
 
     #define RF_KICK(part, kick_weight) \
@@ -175,7 +179,8 @@ void track_rf_body_single_particle(
             part, voltage * (kick_weight), frequency, lag,\
             transverse_voltage * (kick_weight), transverse_lag,\
             absolute_time, order, \
-            factor_knl_ksl * (kick_weight), knl, ksl, pn, ps\
+            factor_knl_ksl * (kick_weight), knl, ksl, pn, ps,\
+            kill_energy_kick\
         )
 
     #define RF_DRIFT(part, dlength) \
@@ -318,6 +323,8 @@ void track_rf_particles(
 ) {
 
     double factor_knl_ksl = 1.0;
+    uint8_t kill_energy_kick = LocalParticle_check_track_flag(
+                    part0, XS_FLAG_KILL_CAVITY_KICK);
 
     // Backtracking
     #ifdef XSUITE_BACKTRACK
@@ -397,7 +404,8 @@ void track_rf_particles(
                 ps,
                 num_kicks,
                 drift_model,
-                integrator
+                integrator,
+                kill_energy_kick
             );
         END_PER_PARTICLE_BLOCK;
 

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/beam_elements/elements_src/track_rf.template.h

@@ -28,7 +28,8 @@ void track_rf_kick_single_particle(
     GPUGLMEM const double* knl,
     GPUGLMEM const double* ksl,
     GPUGLMEM const double* pn,
-    GPUGLMEM const double* ps
+    GPUGLMEM const double* ps,
+    const uint8_t kill_energy_kick
 ){
 
     double phase0 = 0;
@@ -140,11 +141,13 @@ void track_rf_kick_single_particle(
     }
 
 
-    #ifdef XTRACK_CAVITY_PRESERVE_ANGLE
-    LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 0);
-    #else
-    LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 1);
-    #endif
+    if (!kill_energy_kick) {
+        #ifdef XTRACK_CAVITY_PRESERVE_ANGLE
+        LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 0);
+        #else
+        LocalParticle_add_to_energy(part, energy_kick + rfmultipole_energy_kick, 1);
+        #endif
+    }
 
 }
 
@@ -167,7 +170,8 @@ void track_rf_body_single_particle(
     GPUGLMEM const double* ps,
     const int64_t num_kicks,
     const int8_t drift_model,
-    const int8_t integrator
+    const int8_t integrator,
+    const uint8_t kill_energy_kick
 ) {
 
     #define RF_KICK(part, kick_weight) \
@@ -175,7 +179,8 @@ void track_rf_body_single_particle(
             part, voltage * (kick_weight), frequency, lag,\
             transverse_voltage * (kick_weight), transverse_lag,\
             absolute_time, order, \
-            factor_knl_ksl * (kick_weight), knl, ksl, pn, ps\
+            factor_knl_ksl * (kick_weight), knl, ksl, pn, ps,\
+            kill_energy_kick\
         )
 
     #define RF_DRIFT(part, dlength) \
@@ -237,6 +242,8 @@ void track_rf_particles(
 ) {
 
     double factor_knl_ksl = 1.0;
+    uint8_t kill_energy_kick = LocalParticle_check_track_flag(
+                    part0, XS_FLAG_KILL_CAVITY_KICK);
 
     // Backtracking
     #ifdef XSUITE_BACKTRACK
@@ -316,7 +323,8 @@ void track_rf_particles(
                 ps,
                 num_kicks,
                 drift_model,
-                integrator
+                integrator,
+                kill_energy_kick
             );
         END_PER_PARTICLE_BLOCK;
 

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/headers/synrad_spectrum.h

@@ -46,33 +46,33 @@ void synrad_average_kick(LocalParticle* part, double B_T, double lpath,
     }
     #endif
 
-    #ifdef XTRACK_SYNRAD_KICK_SAME_AS_FIRST
-    if (part -> ipart == 0){
-      *dp_record = LocalParticle_get_delta(part);
-      *dpx_record = LocalParticle_get_px(part);
-      *dpy_record = LocalParticle_get_py(part);
-    }
-    else{
-      f_t = 1.0;
+    if (LocalParticle_check_track_flag(part, XS_FLAG_SR_KICK_SAME_AS_FIRST)){
+      if (part -> ipart == 0){
+        *dp_record = LocalParticle_get_delta(part);
+        *dpx_record = LocalParticle_get_px(part);
+        *dpy_record = LocalParticle_get_py(part);
+      }
+      else{
+        f_t = 1.0;
+      }
     }
-    #endif
 
     LocalParticle_update_delta(part, (delta+1) * f_t - 1);
     LocalParticle_scale_px(part, f_t);
     LocalParticle_scale_py(part, f_t);
 
-    #ifdef XTRACK_SYNRAD_KICK_SAME_AS_FIRST
-    if (part -> ipart == 0){
-      *dp_record = LocalParticle_get_delta(part) - *dp_record;
-      *dpx_record = LocalParticle_get_px(part) - *dpx_record;
-      *dpy_record = LocalParticle_get_py(part) - *dpy_record;
-    }
+    if (LocalParticle_check_track_flag(part, XS_FLAG_SR_KICK_SAME_AS_FIRST)){
+      if (part -> ipart == 0){
+        *dp_record = LocalParticle_get_delta(part) - *dp_record;
+        *dpx_record = LocalParticle_get_px(part) - *dpx_record;
+        *dpy_record = LocalParticle_get_py(part) - *dpy_record;
+      }
     else{
       LocalParticle_update_delta(part, LocalParticle_get_delta(part) + *dp_record);
       LocalParticle_add_to_px(part, *dpx_record);
       LocalParticle_add_to_py(part, *dpy_record);
     }
-    #endif
+  }
 }
 
 GPUFUN

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/line.py

@@ -5513,6 +5513,15 @@ def _preserve_config(ln_or_trk):
         ln_or_trk.config.clear()
         ln_or_trk.config.update(config)
 
+@contextmanager
+def _preserve_track_flags(line):
+    old_flags = line.tracker.track_flags.flags.copy()
+    try:
+        yield
+    finally:
+        line.tracker.track_flags.flags.clear()
+        line.tracker.track_flags.flags.update(old_flags)
+
 
 @contextmanager
 def freeze_longitudinal(ln_or_trk):

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/mad_writer.py

@@ -232,6 +232,34 @@ def drift_to_mad_str(name, line, mad_type=MadType.MADX, substituted_vars=None):
         tokens = _handle_tokens_madng(tokens, substituted_vars)
     return ', '.join(tokens)
 
+def drift_slice_to_mad_str(name, line, mad_type=MadType.MADX, substituted_vars=None):
+    """
+    Convert a drift element to a MADX/MAD-NG string representation.
+
+    Parameters:
+    - name: Name of the drift element.
+    - line: The line containing the element.
+    - mad_type: Type of MAD (MADX or MADNG).
+    - substituted_vars: List of substituted variables for MADNG.
+
+    Returns:
+    - A string representation of the drift in MADX/MAD-NG format.
+    """
+
+    drift_slice = _get_eref(line, name)
+    tokens = []
+    tokens.append('drift')
+    if mad_type == MadType.MADNG:
+        tokens.append(f"'{name.replace(':', '__')}'")  # replace ':' with '__' for MADNG
+
+    tokens.append(mad_assignment('l', (float(drift_slice._parent.length._value)
+                                     * float(drift_slice.weight._value)),
+                                 mad_type, substituted_vars=substituted_vars))
+
+    if mad_type == MadType.MADNG:
+        tokens = _handle_tokens_madng(tokens, substituted_vars)
+    return ', '.join(tokens)
+
 def multipole_to_mad_str(name, line, mad_type=MadType.MADX, substituted_vars=None):
     """ Convert a multipole element to a MADX/MAD-NG string representation.
 
@@ -562,7 +590,8 @@ xsuite_to_mad_converters = {
     xt.UniformSolenoid: solenoid_to_mad_str,
     xt.SRotation: srotation_to_mad_str,
     xt.RFMultipole: rfmultipole_to_mad_str,
-    xt.CrabCavity: crabcavity_to_mad_str
+    xt.CrabCavity: crabcavity_to_mad_str,
+    xt.DriftSlice: drift_slice_to_mad_str
 }
 
 def to_madx_sequence(line, name='seq', mode='sequence'):

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/particles/particles.py

@@ -1429,6 +1429,7 @@ class Particles(xo.HybridClass):
 
         src_lines.append('                 int64_t ipart;')
         src_lines.append('                 int64_t endpart;')
+        src_lines.append('                 uint64_t track_flags;')
         src_lines.append('    /*gpuglmem*/ int8_t* io_buffer;')
         src_lines.append('} LocalParticle;')
         src_typedef = '\n'.join(src_lines)
@@ -1443,6 +1444,14 @@ class Particles(xo.HybridClass):
 
             ''')
 
+        # Get track flag
+        src_lines.append('''
+            /*gpufun*/
+            uint64_t LocalParticle_check_track_flag(LocalParticle* part, uint8_t index){
+                return (part->track_flags >> index) & 1;
+            }
+        ''')
+
         # Particles_to_LocalParticle
         src_lines.append('''
             /*gpufun*/

{xtrack-0.89.0 → xtrack-0.89.2}/xtrack/tapering.py

@@ -72,9 +72,8 @@ def compensate_radiation_energy_loss(line, delta0='zero_mean', rtol_eneloss=1e-1
     f_setter.set_values(np.zeros_like(f_setter.get_values()))
 
     if verbose: _print("Share energy loss among cavities (repeat until energy loss is zero)")
-    with xt.line._preserve_config(line):
-        line.config.XTRACK_MULTIPOLE_TAPER = True
-        line.config.XTRACK_DIPOLEEDGE_TAPER = True
+    with xt.line._preserve_track_flags(line):
+        line.tracker.track_flags.XS_FLAG_SR_TAPER = True
 
         if delta0 == 'zero_mean':
             num_rounds = 2

xtrack-0.89.2/xtrack/track_flags.py

@@ -0,0 +1,70 @@
+import numpy as np
+
+flag_mapping = {
+    'XS_FLAG_BACKTRACK': 0,
+    'XS_FLAG_KILL_CAVITY_KICK': 2,
+    'XS_FLAG_IGNORE_GLOBAL_APERTURE': 3,
+    'XS_FLAG_IGNORE_LOCAL_APERTURE': 4,
+    'XS_FLAG_SR_TAPER': 5,
+    'XS_FLAG_SR_KICK_SAME_AS_FIRST': 6
+}
+
+flag_defaults = {
+    'XS_FLAG_BACKTRACK': False,
+    'XS_FLAG_KILL_CAVITY_KICK': False,
+    'XS_FLAG_IGNORE_GLOBAL_APERTURE': False,
+    'XS_FLAG_IGNORE_LOCAL_APERTURE': False,
+    'XS_FLAG_SR_TAPER': False,
+    'XS_FLAG_SR_KICK_SAME_AS_FIRST': False
+}
+
+c_header_flag_mapping = """
+#ifndef XSTUITE_TRACK_FLAGS_H
+#define XSTUITE_TRACK_FLAGS_H
+"""
+for flag_name, bit_pos in flag_mapping.items():
+    c_header_flag_mapping += f"#define {flag_name} ({bit_pos})\n"
+c_header_flag_mapping += """
+#endif // XSTUITE_TRACK_FLAGS_H
+"""
+
+class TrackFlags:
+
+    c_header_flag_mapping = c_header_flag_mapping
+
+    def __init__(self, **kwargs):
+        object.__setattr__(self, 'flags', flag_defaults.copy())
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def get_flags_register(self):
+
+        reg = 0
+        for flag_name, bit_pos in flag_mapping.items():
+            assert bit_pos >= 0
+            assert bit_pos < 64
+            if self.flags.get(flag_name, False):
+                reg |= (1 << bit_pos)
+        return np.uint64(reg)
+
+    def __getattr__(self, name):
+        if name == 'flags':
+            return object.__getattribute__(self, 'flags')
+        if name in self.flags:
+            return self.flags[name]
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, name, value):
+        if name == 'flags': # for unpickling
+            object.__setattr__(self, 'flags', value)
+            return
+        if name not in self.flags:
+            raise KeyError(f"Unknown flag '{name}'")
+        self.flags[name] = value
+
+    def __repr__(self):
+        return f"TrackFlags({self.flags})"
+
+    def print_flag_register(self):
+        reg = self.get_flags_register()
+        print(f"Flag register (binary): {bin(reg)[2:].zfill(64)}")