liftof_lib/
thread_control.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
//! Thread control structures

use std::collections::HashMap;
use std::fmt;

#[cfg(feature = "database")]
use tof_dataclasses::database::ReadoutBoard;

use tof_dataclasses::status::TofDetectorStatus;
use tof_dataclasses::calibrations::RBCalibrations;

use crate::settings::LiftofSettings;

/// Send runtime information 
/// to threads via shared memory
/// (Arc(Mutex)
#[derive(Default, Debug)]
pub struct ThreadControl {
  /// Stop ALL threads
  pub stop_flag                  : bool,
  /// Received INT signal        
  pub sigint_recvd               : bool,
  /// signal to end all rb thread activity
  pub end_all_rb_threads         : bool,
  /// Trigger calibration thread
  pub calibration_active         : bool,
  /// Keep track on how many calibration 
  /// packets we have received
  pub finished_calibrations      : HashMap<u8,bool>,
  /// Hold the actual calibration data
  pub calibrations               : HashMap<u8, RBCalibrations>,
  /// Hold off the master trigger thread, until everything else
  /// is ready
  pub holdoff_mtb_thread         : bool,
  /// alive indicator for cmd dispatch thread
  pub thread_cmd_dispatch_active : bool,
  /// alive indicator for data sink thread
  pub thread_data_sink_active    : bool,
  /// alive indicator for runner thread
  pub thread_runner_active       : bool,
  /// alive indicator for event builder thread
  pub thread_event_bldr_active   : bool,
  /// alive indicator for master trigger thread
  pub thread_master_trg_active   : bool,
  /// alive indicator for monitoring thread
  pub thread_monitoring_active   : bool,
  /// Running readoutboard communicator threads - the key is associated rb id
  pub thread_rbcomm_active       : HashMap<u8, bool>,
  /// Manage CTRL+C (or CMD+C/Mac) input
  pub thread_signal_hdlr_active  : bool,
  /// The current run id
  pub run_id                     : u32,
  /// The number of boards available
  pub n_rbs                      : u32,
  #[cfg(feature = "database")]
  /// The active readoutboards in the Tof
  pub rb_list                    : Vec<ReadoutBoard>,
  /// Verification run currently active
  pub verification_active        : bool,
  /// TOF Detector status - which channels are active?
  pub detector_status            : TofDetectorStatus,
  /// Decide if data is actually written to disk
  pub write_data_to_disk         : bool,
  /// indicator that a new 
  /// run has started
  /// (data sinks need to know)
  pub new_run_start_flag         : bool,
  /// initiate a MTB DAQ reset (if the queue is behind)
  pub reset_mtb_daq              : bool,
  pub liftof_settings            : LiftofSettings,
}

impl ThreadControl {
  pub fn new() -> Self {
    Self {
      stop_flag                  : false,
      calibration_active         : false,
      finished_calibrations      : HashMap::<u8,bool>::new(),
      calibrations               : HashMap::<u8, RBCalibrations>::new(),
      sigint_recvd               : false,
      end_all_rb_threads         : false,
      holdoff_mtb_thread         : false,
      thread_cmd_dispatch_active : false,
      thread_data_sink_active    : false,
      thread_runner_active       : false,
      thread_event_bldr_active   : false,
      thread_master_trg_active   : false,
      thread_monitoring_active   : false,
      thread_rbcomm_active       : HashMap::<u8,bool>::new(),
      // in principle this should always be active
      thread_signal_hdlr_active  : true,
      run_id                     : 0,
      n_rbs                      : 0,
      #[cfg(feature = "database")]
      rb_list                    : Vec::<ReadoutBoard>::new(),
      verification_active        : false,
      detector_status            : TofDetectorStatus::new(),
      write_data_to_disk         : false,
      new_run_start_flag         : false,
      reset_mtb_daq              : false,
      liftof_settings            : LiftofSettings::new(),
    }
  }
}

impl fmt::Display for ThreadControl {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    let mut repr = String::from("<ThreadControl:");
    repr        += &(format!("\n  Run ID         : {}", self.run_id));
    repr        += &(format!("\n  N RBs          : {}", self.n_rbs));
    repr        += &(format!("\n  wr to disk     : {}", self.write_data_to_disk));
    repr        += "\n    -- reported RB calibration activity:";
    repr        += &(format!("\n  RB cali active : {}", self.calibration_active));
    for k in self.finished_calibrations.keys() {
      repr        += &(format!("\n  -- finished  {}  : {}", k, self.finished_calibrations.get(k).unwrap()));       
    }
    repr        += &(format!("\n    -- verification run: {}", self.verification_active));
    repr        += "\n    -- program status:";
    repr        += &(format!("\n  stop flag        : {}", self.stop_flag));
    repr        += "\n    -- reported thread activity:";
    repr        += &(format!("\n  holdoff mtb thr. : {}", self.holdoff_mtb_thread));
    repr        += &(format!("\n  cmd dispatcher   : {}", self.thread_cmd_dispatch_active));
    repr        += &(format!("\n  runner           : {}", self.thread_runner_active));
    repr        += &(format!("\n  data sink        : {}", self.thread_data_sink_active));
    repr        += &(format!("\n  monitoring       : {}", self.thread_monitoring_active));
    repr        += &(format!("\n  evt builder      : {}", self.thread_event_bldr_active));
    repr        += &(format!("\n  master_trigger   : {}", self.thread_master_trg_active));
    if self.thread_rbcomm_active.len() > 0 {
      repr        += "\n -- active RB threads";
      for k in self.thread_rbcomm_active.keys() {
        repr      += &(format!("\n -- -- {} : {}", k, self.thread_rbcomm_active.get(k).unwrap()));
      }
    }
    repr        += &(format!("\n  master trig    : {}>", self.thread_master_trg_active));
    write!(f, "{}", repr)
  }
}