gondola 0.12.1__tar.gz → 0.12.2__tar.gz

{gondola-0.12.1 → gondola-0.12.2}/Cargo.lock

@@ -1352,7 +1352,7 @@ checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
 
 [[package]]
 name = "gondola-core"
-version = "0.12.1"
+version = "0.12.2"
 dependencies = [
  "cfg-if 1.0.0",
  "chrono",

{gondola-0.12.1 → gondola-0.12.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gondola-core"
-version = "0.12.1"
+version = "0.12.2"
 edition = "2024"
 readme = "README.md"
 
@@ -71,6 +71,7 @@ optional = true
 version  = "0.1"
 optional = true
 
+
 [dev-dependencies]
 criterion = "0.4"
 #tempfile  = "3.10"

{gondola-0.12.1 → gondola-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gondola
-Version: 0.12.1
+Version: 0.12.2
 Requires-Dist: tqdm>=4.0
 Requires-Dist: numpy>=2.3
 Requires-Dist: matplotlib>=3.10

gondola-0.12.2/python/gondola/tof/__init__.py

@@ -0,0 +1,64 @@
+"""
+TOF related entities which did not fit anywhere else 
+"""
+
+from .. import _gondola_core  as _gc 
+
+from . import analysis
+
+RBPaddleID            = _gc.tof.RBPaddleID
+RBPaddleID.__module__ = __name__
+RBPaddleID.__name__   = "RBPaddleID"
+#RBPaddleID.__doc__    = _gc.tof.RBPaddleID.__doc__
+TofDetectorStatus   = _gc.tof.TofDetectorStatus
+TofCommandCode      = _gc.tof.TofCommandCode
+TofCommand          = _gc.tof.TofCommand
+TofOperationMode    = _gc.tof.TofOperationMode
+BuildStrategy       = _gc.tof.BuildStrategy
+PreampBiasConfig    = _gc.tof.PreampBiasConfig
+RBChannelMaskConfig = _gc.tof.RBChannelMaskConfig
+TriggerConfig       = _gc.tof.TriggerConfig
+TofRunConfig        = _gc.tof.TofRunConfig
+TofCuts             = _gc.tof.TofCuts
+to_board_id_string  = _gc.tof.to_board_id_string
+TofAnalysis         = analysis.TofAnalysis
+
+## command factories
+#start_run            = _gc.tof.start_run 
+#start_run.__module__ = __name__
+#start_run.__name___  = 'start_run'
+#
+#stop_run            = _gc.tof.stop_run 
+#stop_run.__module__ = __name__
+#stop_run.__name___  = 'stop_run'
+#
+#enable_verification_run            = _gc.tof.enable_verification_run  
+#enable_verification_run.__module__ = __name__
+#enable_verification_run.__name___  = 'enable_verification_run'
+#
+#restart_liftofrb    = _gc.tof.restart_liftofrb 
+#restart_liftofrb.___module__ = __name__ 
+#restart_liftofrb.__name__ = 'restart_liftofrb'
+#
+#shutdown_all_rbs    = _gc.tof.shutdown_all_rbs
+#shutdown_all_rbs.__module__ = __name__
+#shutdown_all_rbs.__name__   = 'shutdown_all_rbs'
+#
+#shutdown_rat        = _gc.tof.shutdown_rat 
+#shutdown_rat.__module__ = __name__ 
+#shutdown_rat.__name__   = 'shutdown_rat' 
+#
+#shutdown_ratpair    = _gc.tof.shutdown_ratpair
+#shutdown_ratpair.__module__ = __name__ 
+#shutdown_ratpair.__name__ = 'shutdown_ratpair' 
+#
+#shutdown_rb         = _gc.tof.shutdown_rb 
+#shutdown_rb.__module__  = __name__
+#shutdown_rb.__name__    = 'shutdown_rb' 
+#
+#shutdown_tofcpu     = _gc.tof.shutdown_tofcpu 
+#shutdown_tofcpu.__module__ = __name__ 
+#shutdown_tofcpu.__name__   = 'shutdown_tofcpu'
+#
+
+

{gondola-0.12.1 → gondola-0.12.2}/src/calibration/tof.rs

@@ -1357,7 +1357,7 @@ impl RBCalibrations {
   
   /// Self check if the timing constants are sane 
   pub fn passes_timing_checks(&self) -> bool {
-    for ch in 0..8 {
+    for ch in 0..9 {
       let mut mean = 0.0;
       for k in 0..NWORDS {
         mean += self.tbin[ch][k];
@@ -1380,7 +1380,7 @@ impl RBCalibrations {
 
   /// Self check if the voltage constants are sane
   pub fn passes_voltage_checks(&self) -> bool {
-    for ch in 0..8 {
+    for ch in 0..9 {
       let mut mean = 0.0;
       for k in 0..NWORDS {
         mean += self.v_offsets[ch][k];

{gondola-0.12.1 → gondola-0.12.2}/src/io/telemetry_reader.rs

@@ -10,6 +10,7 @@ use std::io::{
   Seek,
   SeekFrom,
 };
+use std::cmp::Ordering;
 
 use crate::prelude::*;
 
@@ -52,7 +53,11 @@ pub struct TelemetryPacketReader {
   pub n_duplicates    : usize,
   /// A cache to allow to quench duplicates 
   /// pkt counter -> pkt checksum
-  dedup_cache         : HashMap<u16, VecDeque<u16>>
+  dedup_cache         : HashMap<u16, VecDeque<u16>>,
+  /// If ::cache_all_packets is called, this will hold 
+  /// all TelemetryPackets sorted by timestamp and 
+  /// packet counter
+  pub packet_cache    : Vec<TelemetryPacket> 
 }
 
 
@@ -102,6 +107,7 @@ impl TelemetryPacketReader {
               n_packs_skipped   : 0,
               n_duplicates      : 0,
               dedup_cache       : dedup_cache,
+              packet_cache      : Vec::<TelemetryPacket>::new()
             };
             packet_reader
           }
@@ -109,7 +115,35 @@ impl TelemetryPacketReader {
       }
     }
   } 
-  
+ 
+  /// Instead of reading packets one at a time, we can read the entire input 
+  /// at once and keep it in memory. This allows to sort the packeges.
+  ///
+  /// This comes with a performance cost and extended memory needs, however, 
+  /// it might be helpful for debugging
+  pub fn cache_all_packets(&mut self) {
+    loop {
+      match self.read_next_item() {
+        None => {
+          info!("Read all packets!");
+          break;
+        }
+        Some(pack) => {
+          self.packet_cache.push(pack);
+        }
+      }
+    }
+    // sort the packet cache by timestamp and counter of 
+    // the header 
+    self.packet_cache.sort_by(|a,b|{
+      b.header.get_gcutime().partial_cmp(&a.header.get_gcutime()).unwrap_or(Ordering::Equal)  
+      .then(b.header.counter.cmp(&a.header.counter))
+    });
+    // reverse the vector, so that the first packet gets 
+    // returned first 
+    self.packet_cache.reverse();
+  }
+
   pub fn clear_dedup_cache(&mut self) {
     let mut dedup_cache = HashMap::<u16, VecDeque<u16>>::with_capacity(u16::MAX as usize + 1);  
     for k in 0..u16::MAX as usize + 1 {
@@ -197,7 +231,7 @@ impl TelemetryPacketReader {
           }
           // read the the size of the packet
           // first we have to skip 6 bytes
-          let mut buffer_skip = [0,0,0,0,0,0,0];
+          let mut buffer_skip = [0,0,0,0,0,0];
           match self.file_reader.read_exact(&mut buffer_skip) {
             Err(err) => {
               debug!("Unable to read from file! {err}");
@@ -210,7 +244,7 @@ impl TelemetryPacketReader {
               };
             }
             Ok(_) => {
-              self.cursor += 7;
+              self.cursor += 6;
             }
           }
           let mut buffer_psize = [0,0];
@@ -229,9 +263,11 @@ impl TelemetryPacketReader {
             }
           }
           let vec_data = buffer_psize.to_vec();
-          let size     = parse_u16(&vec_data, &mut 0);
+          // packet size is the size including the header, so for the 
+          // payload only we have to subtract that.
+          let size     = parse_u16(&vec_data, &mut 0) - 13;
           let mut temp_buffer = vec![0; size as usize];
-          // skip 2 more bytes
+          // skip 2 more bytes for the header checksum
           match self.file_reader.read_exact(&mut buffer_psize) {
             Err(_err) => {
               match self.prime_next_file() {
@@ -324,8 +360,7 @@ impl TelemetryPacketReader {
           let mut thead     = TelemetryPacketHeader::new();
           thead.sync        = 0x90eb;
           thead.packet_type = TelemetryPacketType::from(buffer[0]);
-          let ptype    = TelemetryPacketType::from(buffer[0]);
-          // read the the size of the packet
+          //let ptype    = TelemetryPacketType::from(buffer[0]);
           let mut buffer_ts = [0,0,0,0];
           match self.file_reader.read_exact(&mut buffer_ts) {
             Err(err) => {
@@ -381,7 +416,7 @@ impl TelemetryPacketReader {
             return None;
           }
           size -= TelemetryPacketHeader::SIZE as u16;
-          if ptype != self.filter && self.filter != TelemetryPacketType::Unknown {
+          if thead.packet_type != self.filter && self.filter != TelemetryPacketType::Unknown {
             match self.file_reader.seek(SeekFrom::Current(size as i64)) {
               Err(err) => {
                 debug!("Unable to read more data! {err}");
@@ -536,7 +571,7 @@ reader!(TelemetryPacketReader, TelemetryPacket);
 impl TelemetryPacketReader {
 
   #[new]
-  #[pyo3(signature = (filenames_or_directory, dedup = true, start_time = None, end_time = None))]
+  #[pyo3(signature = (filenames_or_directory, dedup = false, start_time = None, end_time = None))]
   fn new_py(filenames_or_directory : &Bound<'_,PyAny>, dedup : bool, start_time : Option<f64>, end_time : Option<f64>) -> PyResult<Self> {
     
     let mut string_value = String::from("foo");
@@ -593,6 +628,21 @@ impl TelemetryPacketReader {
     self.count_packets()
   }
 
+  #[pyo3(name = "cache_all_packets")]
+  fn cache_all_packets_py(&mut self) {
+    self.cache_all_packets();
+  }
+
+  /// Retrieve a copy of the internal packet cache.
+  /// This will only yield a meaningful result after 
+  /// a call to .cache_all_packets(). Since the entire
+  /// cache is copied in the processs, this is slow 
+  /// and might only be helpful for debugging. 
+  #[pyo3(name = "copy_packet_cache")]
+  fn copy_packet_cache(&self) -> Vec<TelemetryPacket> {
+    self.packet_cache.clone()
+  }
+
   //#[getter]
   //fn first(&mut self) -> Option<TofPacket> {
   //  self.first_packet()

{gondola-0.12.1 → gondola-0.12.2}/src/lib.rs

@@ -174,6 +174,19 @@ fn tof_py<'_py>(m: &Bound<'_py, PyModule>) -> PyResult<()> {
   m.add_class::<TofCuts>()?;
   m.add_class::<PyMasterTrigger>()?;
   m.add_function(wrap_pyfunction!(to_board_id_string, m)?)?;
+  // the commands
+  m.add_function(wrap_pyfunction!(start_run, m)?)?;
+  m.add_function(wrap_pyfunction!(stop_run, m)?)?;
+  m.add_function(wrap_pyfunction!(restart_liftofrb, m)?)?;
+  m.add_function(wrap_pyfunction!(enable_verification_run, m)?)?;
+  m.add_function(wrap_pyfunction!(shutdown_all_rbs, m)?)?;
+  m.add_function(wrap_pyfunction!(shutdown_rat, m)?)?;
+  m.add_function(wrap_pyfunction!(shutdown_ratpair, m)?)?;
+  m.add_function(wrap_pyfunction!(shutdown_rb, m)?)?;
+  m.add_function(wrap_pyfunction!(shutdown_tofcpu, m)?)?;
+
+
+
   Ok(())
 }
 

{gondola-0.12.1 → gondola-0.12.2}/src/tof/commands.rs

@@ -527,12 +527,26 @@ pub fn stop_run() -> Option<TofCommand> {
   })
 }
 
+/// Enable verfication runs before every run start
+/// 
+/// A verification run will not send any event
+/// packets, but only a TofDetectorStatus frame
+#[cfg_attr(feature="pybindings", pyfunction)]
+pub fn enable_verification_run(enabled : bool) -> Option<TofCommand> {
+  Some(TofCommand {
+    command_code : TofCommandCode::StartValidationRun,
+    payload      : vec![enabled as u8],
+  })
+}
+
+
+
 /// Run a calibration of all RBs
 ///
 /// # Arguments:
 ///   * pre_run_calibration : Run the RBCalibration routine before 
 ///                           every run start
-///   * send_packetes       : Send the RBCalibration packets
+    ///   * send_packetes       : Send the RBCalibration packets
 ///   * save_events         : Save the events to the RBCalibration
 ///                           packets
 #[cfg_attr(feature="pybindings", pyfunction)]

{gondola-0.12.1 → gondola-0.12.2}/src/tof/master_trigger.rs

@@ -511,12 +511,14 @@ pub fn master_trigger(mt_address     : &str,
   let mut settings       : MTBSettings;
   let mut cali_active    : bool;
   let mut holdoff        : bool;
+  let mut veri_active    : bool;
   loop {
     match thread_control.lock() {
       Ok(tc) => {
         settings    = tc.liftof_settings.mtb_settings.clone();  
         cali_active = tc.calibration_active; 
         holdoff     = tc.holdoff_mtb_thread;
+        veri_active = tc.verification_active;
       }
       Err(err) => {
         error!("Can't acquire lock for ThreadControl! Unable to set calibration mode! {err}");
@@ -772,12 +774,14 @@ pub fn master_trigger(mt_address     : &str,
         }
         last_event_id = _ev.event_id;
         heartbeat.n_events += 1;
-        match mt_sender.send(_ev) {
-          Err(err) => {
-            error!("Can not send TofEvent over channel! {err}");
-            heartbeat.n_ev_unsent += 1;
-          },
-          Ok(_) => ()
+        if !veri_active {
+          match mt_sender.send(_ev) {
+            Err(err) => {
+              error!("Can not send TofEvent over channel! {err}");
+              heartbeat.n_ev_unsent += 1;
+            },
+            Ok(_) => ()
+          }
         }
       }
     }

{gondola-0.12.1 → gondola-0.12.2}/src/tof/settings.rs

@@ -73,6 +73,11 @@ pub struct MTBSettings {
   pub tiu_ignore_busy    : bool,
   pub tofbot_webhook     : String,
   pub hb_send_interval   : u64,
+  /// Instruct the MTB to ignore the tiu 
+  /// busy time and instead impose always 
+  /// the same deadtime of 600mu sec on 
+  /// itself
+  pub use_fixed_deadtime : Option<bool>,
 }
 
 impl MTBSettings {
@@ -93,6 +98,7 @@ impl MTBSettings {
       use_combo_trigger       : false,
       global_trigger_type     : TriggerType::Unknown,
       global_trigger_prescale : 1.0,
+      use_fixed_deadtime      : None,
     }
   }
 
@@ -868,7 +874,11 @@ pub struct LiftofSettings {
   /// packet. If a verification run is desired, change this 
   /// number to the number of seconds to do the verification 
   /// run
-  pub verification_runtime_sec   : u32,
+  #[deprecated(since = "0.11", note = "Use flag verfication_rnn and runtime instead!")]
+  pub verification_runtime_sec   : Option<u32>,
+  /// If this is set, don't save anything to disk 
+  /// and just transmit the TofDetectorStatus packet
+  pub verification_run           : Option<bool>,
   /// Settings to control the MTB
   pub mtb_settings               : MTBSettings,
   /// Settings for the TOF event builder
@@ -905,7 +915,8 @@ impl LiftofSettings {
       run_analysis_engine       : true,
       pre_run_calibration       : false,
       save_cali_wf              : false,
-      verification_runtime_sec  : 0, // no verification run per default
+      verification_runtime_sec  : None, // no verification run per default
+      verification_run          : None,
       mtb_settings              : MTBSettings::new(),
       event_builder_settings    : TofEventBuilderSettings::new(),
       analysis_engine_settings  : AnalysisEngineSettings::new(),
@@ -926,60 +937,6 @@ impl LiftofSettings {
     }
   }
 
-  /// Change a value by giving the specific key as 
-  /// a string, the value then will be parsed 
-  /// accordingly
-  #[deprecated(since="0.10.0", note="This is a dev deadend and will be nuked!")]
-  pub fn set_by_key(&mut self, key : &str, value : String) {
-    match key {
-      "runtime_sec"               => {
-        if let Ok(val) = value.parse::<u64>() {
-          self.runtime_sec = val;
-        } else {
-          error!("Unable to parse {value}!");
-        }
-      }
-      "cpu_moni_interval_sec"     => {
-        if let Ok(val) = value.parse::<u64>() {
-          self.cpu_moni_interval_sec = val;
-        } else {
-          error!("Unable to parse {value}!");
-        }
-      }
-      "rb_ignorelist_run"         => {
-      }
-      "run_analysis_engine"       => {
-        if let Ok(val) = value.parse::<bool>() {
-          self.run_analysis_engine = val;
-        } else {
-          error!("Unable to parse {value}!");
-        }
-      }
-      "pre_run_calibration"       => {
-        if let Ok(val) = value.parse::<bool>() {
-          self.pre_run_calibration = val;
-        } else {
-          error!("Unable to parse {value}!");
-        }
-      }
-      "save_cali_wf"              => {
-        if let Ok(val) = value.parse::<bool>() {
-          self.save_cali_wf = val;
-        } else {
-          error!("Unable to parse {value}!");
-        }
-      }
-      "verification_runtime_sec"  => {
-        if let Ok(val) = value.parse::<u32>() {
-          self.verification_runtime_sec = val;
-        } else {
-          error!("Unable to parse {value}!");
-        }
-      }
-      _ => error!("Set by key for {} is not implemented!", key)
-    }
-  }
-
   /// Write the settings to a toml file
   pub fn to_toml(&self, mut filename : String) {
     if !filename.ends_with(".toml") {

gondola-0.12.1/python/gondola/tof/__init__.py

@@ -1,22 +0,0 @@
-"""
-TOF related entities which did not fit anywhere else 
-"""
-
-from .. import _gondola_core  as _gc 
-
-from . import analysis
-
-RBPaddleID          = _gc.tof.RBPaddleID
-TofDetectorStatus   = _gc.tof.TofDetectorStatus
-TofCommandCode      = _gc.tof.TofCommandCode
-TofCommand          = _gc.tof.TofCommand
-TofOperationMode    = _gc.tof.TofOperationMode
-BuildStrategy       = _gc.tof.BuildStrategy
-PreampBiasConfig    = _gc.tof.PreampBiasConfig
-RBChannelMaskConfig = _gc.tof.RBChannelMaskConfig
-TriggerConfig       = _gc.tof.TriggerConfig
-TofRunConfig        = _gc.tof.TofRunConfig
-TofCuts             = _gc.tof.TofCuts
-to_board_id_string  = _gc.tof.to_board_id_string
-TofAnalysis         = analysis.TofAnalysis
-

{gondola-0.12.1 → gondola-0.12.2}/src/events/tof_event.rs

@@ -789,11 +789,6 @@ impl Serialization for TofEvent {
       //println!("{}", next_rb_event);
       te.rb_events.push(next_rb_event);
     }
-    let tail = parse_u16(stream, pos);
-    if tail != Self::TAIL {
-      error!("Decoding of TAIL failed! Got {} instead!", tail);
-      return Err(SerializationError::TailInvalid);
-    }
     //println!("{}",te);
     
     // FIXME - this is slow, use Arc<> instead. However, then make 
@@ -804,6 +799,11 @@ impl Serialization for TofEvent {
         te.hits.push(*h);
       }
     }
+    let tail = parse_u16(stream, pos);
+    if tail != Self::TAIL {
+      error!("Decoding of TAIL failed! Got {} instead!", tail);
+      return Err(SerializationError::TailInvalid);
+    }
     return Ok(te);
   }
 }