RunHistory.h
Go to the documentation of this file.
1 
2 #ifndef _RUNHISTORY_H
3 #define _RUNHISTORY_H
4 
5 #include <string>
6 #include <vector>
7 #include <map>
8 #include <list>
9 #include <ctime>
10 #include <climits>
11 #include <stdint.h>
12 #include <memory>
13 
15 #include <DAQChannelMap/DAQChannelMap.h>
16 #include <NovaDAQConventions/DAQConventions.h>
17 #ifdef NOVACMAKE
19 #else
20 #include <Database/DataType.h>
21 #endif
22 
23 namespace nova {
24  namespace dbi {
25 
26  class ChanInfo_t {
27  public:
28  ChanInfo_t() { occ=-6.; coinc=0.; tstart=0;}
30 
31  float occ;
32  float coinc;
33  time_t tstart;
34  };
35 
36  class BadChan_t {
37  public:
38  BadChan_t() { isBad = false; tstart=0;}
39  ~BadChan_t() {};
40 
41  bool isBad;
42  time_t tstart;
43  };
44 
45  struct Subrun {
46  time_t tstart;
47  time_t tstop;
53  };
54 
55  class DataEpoch {
56  public:
57  DataEpoch() : name(""), run_start(0), run_end(0), duration(0), timing_mode(""),
58  comment("") {}
59  ~DataEpoch() {};
60 
62  int run_start;
63  int run_end;
64  uint64_t duration;
67 
68  friend std::ostream& operator << (std::ostream &o, const DataEpoch & ep)
69  {
70  o << ep.name << ", "
71  << ep.run_start << ", "
72  << ep.run_end << ", "
73  << ep.duration << ", "
74  << ep.timing_mode << ", "
75  << ep.comment;
76  return o;
77  }
78  };
79 
80  struct DQSubrunInfo {
81 
82  DQSubrunInfo() : _run(0), _subrun(-1), _flag(0), _version(0),
83  _miprate(0.), _ngooddb(0), _numslc(0.), _trkfrac(0.)
84  {
85  }
86 
87  int _run;
88  short _subrun;
89  int _flag;
90  int _version;
91  float _miprate;
92  int _ngooddb;
93  float _numslc;
94  float _trkfrac;
95 
96  friend std::ostream& operator << (std::ostream &o, const DQSubrunInfo & sri)
97  {
98  o << sri._run << " "
99  << sri._subrun << " "
100  << sri._flag << " "
101  << sri._version << " "
102  << sri._miprate << " "
103  << sri._ngooddb << " "
104  << sri._numslc << " "
105  << sri._trkfrac;
106  return o;
107  }
108 
109  };
110 
111 
112  struct APDInfo {
113 
115  : _sn ("")
116  , _barcode (UINT_MAX)
117  , _batch (UINT_MAX)
118  , _temp (INT_MAX)
119  , _voltage (UINT_MAX)
120  , _module (UINT_MAX)
121  , _modcon (UINT_MAX)
122  , _installed(0.)
123  {
124  _pixelGain.resize(32, 100.);
125  }
126 
127  std::string _sn; ///< APD SN
128  uint32_t _barcode; ///< barcode id from barcoded_item table
129  uint32_t _batch; ///< APD batch number
130  int32_t _temp; ///< operating temperature
131  float _voltage; ///< operating voltage
132  uint32_t _module; ///< module APD is connected to
133  uint32_t _modcon; ///< module connection id
134  double _installed; ///< time the APD was installed on the
135  ///< detector in seconds since 1970
136  std::vector<float> _pixelGain; ///< pixel gain map for APD
137 
138  bool operator<( const APDInfo& apdi ) const
139  { return _installed < apdi._installed; }
140 
141  bool operator==( const APDInfo& apdi ) const
142  { return _sn == apdi._sn; }
143 
144  bool operator!=( const APDInfo& apdi ) const
145  { return _sn != apdi._sn; }
146 
147  friend std::ostream& operator << (std::ostream &o, const APDInfo & apdi)
148  {
149  o << "APD: " << apdi._sn << " "
150  << apdi._barcode << " "
151  << apdi._batch << " "
152  << apdi._temp << " "
153  << apdi._voltage << " "
154  << apdi._module << " "
155  << apdi._modcon << " "
156  << apdi._installed << std::endl;
157  return o;
158  }
159  };
160 
161  struct FEBInfo {
162  std::string _sn; ///< FEB SN
163  float _intercept; ///< intercept for voltage setting
164  float _slope; ///< slope for voltage setting
165  uint32_t _barcode; ///< barcoded_item_id from barcoded_item table
166  uint32_t _module; ///< module FEB is connected to
167  uint32_t _modcon; ///< module connection id
168  double _installed; ///< time the FEB was installed on the
169  ///< detector in seconds since 1970
170 
171  bool operator<( const FEBInfo& febi ) const
172  { return _installed < febi._installed; }
173 
174  bool operator==( const FEBInfo& febi) const
175  { return _sn == febi._sn; }
176 
177  bool operator!=( const FEBInfo& febi) const
178  { return _sn != febi._sn; }
179 
180  friend std::ostream& operator << (std::ostream &o, const FEBInfo & febi)
181  {
182  o << "FEB: "
183  << febi._sn << " "
184  << febi._barcode << " "
185  << febi._module << " "
186  << febi._intercept << " "
187  << febi._slope << " "
188  << febi._modcon << " "
189  << febi._installed << std::endl;
190  return o;
191  }
192 
193  };
194 
196 
197  int32_t _detid; ///< Detector ID
198  uint32_t _diblock; ///< Diblock
199  uint32_t _dcm; ///< DCM
200  uint32_t _feb; ///< FEB port
201  uint32_t _block; ///< installed block
202  uint32_t _layer; ///< layer in the block
203  uint32_t _layerPos; ///< position in the layer
204 
205  // it is assumed that each RunHistory object is only for
206  // 1 detector so no need to test on _detid in the
207  // comparison operators
208  bool operator<( const HardwareLocation& hl ) const
209  {
210  if ( _diblock < hl._diblock ) return true;
211  else if( _diblock == hl._diblock &&
212  _dcm < hl._dcm ) return true;
213  else if( _diblock == hl._diblock &&
214  _dcm == hl._dcm &&
215  _feb < hl._feb ) return true;
216 
217  return false;
218  }
219 
220  bool operator==( const HardwareLocation& hl ) const
221  {
222  return ( _diblock == hl._diblock &&
223  _dcm == hl._dcm &&
224  _feb == hl._feb);
225  }
226 
227  bool operator!=( const HardwareLocation& hl ) const
228  {
229  return ( _diblock != hl._diblock ||
230  _dcm != hl._dcm ||
231  _feb != hl._feb);
232  }
233 
234  friend std::ostream& operator << (std::ostream &o, const HardwareLocation & hl)
235  {
236  o << "dcm-"
237  << hl._detid << "-"
238  << hl._diblock << "-"
239  << hl._dcm << "-"
240  << hl._feb << std::endl;
241  return o;
242  }
243 
244  };
245 
246  /**
247  * Utilities for accessing run history, calib. constants, etc.
248  *
249  * @author Jonathan Paley
250  * @version $Revision: 1.9 $ $Date: 2013/02/11 15:36:10 $
251  */
252 
253  class RunHistory {
254 
255  public:
256 
257  class FEB {
258  public:
259  FEB();
260  ~FEB() {};
261 
262  std::string hwid;
263  bool hasAPD; ///< true if instrumented and active in run, and not masked
264  short block;
265  short layer;
268  int32_t pixelMask;
269  std::vector<int16_t> pixelThresh;
270  int apdV;
271  bool isEnabled;
272  bool isCooled;
274  float temperature;
275  float gain;
276  std::vector<float> pixelGain; ///< each entry is the gain for the pixel with the number of the index
277  };
278 
279  class DCM {
280  public:
281  DCM() {feb.clear(); isActive=false; nInstrumentedFEBs=0; diblock=-1;};
282  ~DCM() {};
283 
284  bool isActive; ///< if it was active in run according to DAQ
285  short diblock;
286  short position;
287  int nInstrumentedFEBs; ///< number of FEBs that were instrumented and active in run and not masked
290  int64_t febMask;
291  std::vector<FEB> feb;
292 
293  };
294 
295  class DiBlock {
296  public:
297  DiBlock(unsigned int ndcm=12) {dcm.resize(ndcm); nInstrumentedFEBs=0;
298  for (unsigned int i=0; i<ndcm; ++i) dcm[i].position=i+1;};
299  DiBlock(int dbnum, unsigned int ndcm=12) {
300  dcm.resize(ndcm); nInstrumentedFEBs=0; num=dbnum;
301  for (unsigned int i=0; i<ndcm; ++i) {
302  dcm[i].position=i+1;
303  dcm[i].diblock=dbnum;
304  }
305  };
306  ~DiBlock() {};
307 
308  bool hasNoAPDs;
309  short num;
310  int nInstrumentedFEBs; ///< number of FEBs that were intrumented and active in run and not masked
311  std::vector<DCM> dcm;
312  };
313 
314  class BNEVB {
315  public:
316  BNEVB() {};
317  ~BNEVB() {};
318 
319  std::string hwid;
321  };
322 
323  RunHistory();
324 
325  virtual ~RunHistory();
326 #ifndef __GCCXML__
328  RunHistory(int run, novadaq::cnv::DetId detid);
329 
330  void SetDBInfo(std::string dbname="", std::string dbhost="",
332  void SetRunNumber(int run);
333  void SetDetector(novadaq::cnv::DetId det);
334  void SetDetector(const std::string& det);
335 
336  bool LoadDAQRunHistory();
337  bool LoadHardwareInfo();
338  bool LoadDCSAlarms(int subrun=-1);
339  bool LoadCoolingInfo();
340  bool LoadPixelInfo(int nAttempt=0); // slow! from DAQ database
341  bool LoadPixelMasks(); // fast! from conditions database
342  bool LoadFEBMasks(); // fast! from conditions database
343  bool LoadFEBMasksFromDAQDB(); // slow! from DAQ database
344  bool LoadPedestals(); // fast! fromc conditions database
345  bool LoadAPDSettings();
346  bool LoadPOT();
347  bool LoadGoodDiBlockMask();
348  bool LoadDataEpoch();
349  bool LoadAllDetInfo() { return (LoadDAQRunHistory() &&
350  LoadHardwareInfo() &&
351  LoadPixelInfo() &&
352  LoadAPDSettings()); };
353  bool IsRHC();
354  void Dump();
355 
356  void SetNDRHCRunStart(std::vector<int> r) { _ndRHCRunStart = r; }
357  void SetNDRHCRunStop(std::vector<int> r) { _ndRHCRunStop = r; }
358  void SetFDRHCRunStart(std::vector<int> r) { _fdRHCRunStart = r; }
359  void SetFDRHCRunStop(std::vector<int> r) { _fdRHCRunStop = r; }
360 
361  void SetTimeQueries(bool f) {_timeQueries=f;}
362  void SetTimeParsing(bool f) {_timeParsing=f;}
363  void SetIfAnyMasking(bool f) {_useMasking=f;} ///< set from fcl: do we want to use any masking at all? If no, other masking options irrelevant
364  void SetAnalysisDiBlockMasking(bool f) {_analysisDiBlockMasking=f;} ///< set from fcl: do we want to use the analysis rules when we mask (not for custom masking)?
365  void SetIfCustomMasking(bool f) {_customMasking=f;} ///< set from fcl: do we want to use a custom mask?
366  void SetCustomMask(std::vector<bool> f) {for(unsigned int i=0; i<14; i++) if(f[i]) _customMask+=1<<i;} ///< set from fcl: what is our custom mask?
367  void SetGetDiBlockMaskFromCondb(bool f) {_getDiBlockMaskFromCondb = f;}
368  bool GetDiBlockMaskFromCondb() const { return _getDiBlockMaskFromCondb; }
369 
370  void SetSubrunDiBlockMask(int isr, int m) { _subrunList[isr].goodDiBlockMask=m; }
371  int ApplyAnalysisDiBlockMask(const int mask) const; ///< converts normal mask to analysis rules mask (any continuous chunk of four or more diblocks kept)
372  std::string DiBlockMaskToString(const int mask) const;
373 
374  int RunNumber() const { return _runNumber; }
375  int NSubruns() { LoadDAQRunHistory(); return _nsubrun; }
376  std::string Detector() const { return _detector; }
377 
378  int Partition() { LoadDAQRunHistory(); return _partition;}
379  std::string RunType() { LoadDAQRunHistory(); return _runType; }
380 
381  time_t TStart();
382  time_t TStop();
383  std::string TStartAsString() { LoadDAQRunHistory(); return _tStart;}
384  std::string TStopAsString() { LoadDAQRunHistory(); return _tEnd;}
385 
386  time_t SubrunTStart(int isr);
387  time_t SubrunTStop(int isr);
388 
389  int Duration() { LoadDAQRunHistory(); return TStop()-TStart(); } ///< in units of seconds
390  int NTriggers() { LoadDAQRunHistory(); return _nTotTrig; }
391  float NPOT() { LoadPOT(); return _npot; }
392  float AvgPOTPerSpill() { LoadPOT(); return _avgpot; }
393 
394  int NDiBlocks() { LoadDAQRunHistory(); return _dbList.size(); } ///< gives number of active diblocks only, may be less than 14
395  int NDCMs();
396  int NLiveDCMs();
397  int NBNEVBs() { LoadDAQRunHistory(); return _bnevbList.size(); }
398  std::vector<BNEVB> GetBNEVBList() { return _bnevbList; }
399 
400  int NAnalysisChannels(int sr=0);
401  int NAnalysisDiBlocks(int sr=0);
402  int NActiveChannels() { LoadDAQRunHistory(); return _nActiveChannels; }
403  int NTotalChannels() { LoadDAQRunHistory(); return _nTotalChannels; }
404  int NFEBs() { LoadPixelInfo(); return _nTotalFEBs; }
405 
406  int GoodDiBlockMask(int subrun=-1, bool reload=false);
407  int GetConfiguration();
408  void SetGoodDiBlockMask(int newmask) {for (size_t isr=0; isr<64; ++isr) _subrunList[isr].goodDiBlockMask=newmask; _gotGoodDiBlockMask=true;}
409  bool IsGoodDiBlock(int idb, int subrun=-1);
410 
411  DiBlock GetDiBlock(int i, bool loadAll=true); ///< get ith diblock is RH list (which only includes diblocks with activity), starting with i=0. Set loadAll = false to prevent loading in pixel masks if not needed, as it can be very slow
412 
413  int NAPDInstalled() { LoadHardwareInfo(); return _nInstalledAPDs; }
414 
415  bool IsDiBlockFullyInstrumented(int idb); ///< returns true if nInstrumentedFEBs in diblock (which counts FEBs that are instrumented, active, and unmasked only) is >= 700
416 
417  bool HasAPD(const geo::OfflineChan&); ///< basic check for if a channel should be live. Used by BadChannels. Checks if channel has instrumented APD, is active in run, and is not masked
418  bool HasAPD(const daqchannelmap::dchan&);
419 
420  bool IsCooled(const geo::OfflineChan&);
421  bool IsCooled(const daqchannelmap::dchan&);
422 
423  int GetThreshold(const geo::OfflineChan&, bool&);
424  int GetThreshold(const daqchannelmap::dchan&, bool&);
425 
426  int GetPedestal(const geo::OfflineChan&, bool&);
427  int GetPedestal(const daqchannelmap::dchan&, bool&);
428 
429 
430  FEB GetFEB(geo::OfflineChan const&,
431  bool &);
432  FEB GetFEB(daqchannelmap::dchan const&,
433  bool &);
434 
435  float GetGain(const geo::OfflineChan&, bool&);
436  float GetGain(const daqchannelmap::dchan&, bool&);
437  float GetPixelGain(geo::OfflineChan const&,
438  bool &);
439  float GetPixelGain(daqchannelmap::dchan const&,
440  bool &);
441  std::vector<float> GetPixelGains(geo::OfflineChan const&,
442  bool &);
443  std::vector<float> GetPixelGains(daqchannelmap::dchan const&,
444  bool &);
445 
446  std::vector<DQSubrunInfo> GetDQSubrunInfo();
447 
448  void SetDataType(nova::dbi::DataType dt) { _dataType = dt; }
449  void SetAbort(bool abort) { _abort=abort; }
450  void SetAbortIfMissingRunInDB(bool abort) { _abortIfMissingRunInDB=abort; }
451 
452  nova::dbi::DataType GetDataType() { return _dataType; }
453 
454  void SetIsBad(geo::OfflineChan, bool, time_t);
455  bool IsBad(geo::OfflineChan, time_t);
456  void ClearBadChan() { _badChan.clear(); }
457 
458  void SetChanInfo(geo::OfflineChan, float, float, time_t);
459  float Occupancy(geo::OfflineChan, time_t);
460  float Coincidence(geo::OfflineChan, time_t);
461  void ClearChanInfo() { _chanInfo.clear(); }
462  void PrintChanInfo();
463 
464  std::string BadChanVersion() { return _badChanVersion;}
465  void SetBadChanVersion(std::string v) { _badChanVersion=v;}
466 
467  int NRetryLoads() { return _nRetryLoads; }
468  void SetNRetryLoads(int n) { _nRetryLoads = n;}
469 
470  void SetDiBlockMaskTag(std::string s) { _dbMaskTag = s; }
471 
472  int DetGainSetting();
473  void SetGainSettingTag(std::string tag) {_detGainTag = tag;}
474  std::string GainSettingTag() {return _detGainTag;}
475 
476  bool DetFineTimingSetting() const;
477 
478  void SetVerbosity(int i) { _verbosity = i; }
479  int Verbosity() const { return _verbosity; }
480 
481  void SetCurrentSubrun(int isr) { _currentSR = isr; }
482  int CurrentSubrun() const { return _currentSR; }
483 
484  DataEpoch GetDataEpoch() { LoadDataEpoch(); return _dataEpoch; }
485 
486  protected:
489 
490  private:
491  /// Call at new run/detector etc
492  void InvalidateCaches();
493  void BuildMC();
494 
495  std::map<int,int> _diblockIndex;
496  std::map<uint32_t, APDInfo> PullAPDInfoFromDB();
497  std::map<HardwareLocation, std::pair<FEBInfo, APDInfo>> PullFEBInfoFromDB(std::map<uint32_t, APDInfo> apdinfomap);
498  void MapHardwareToLocation();
499 
500 #endif // __GCCXML__
510  bool _gotPOT;
517  bool _isMC;
518  bool _abort;
522 
525  int _nsubrun;
531  int _detId;
534  int _nDCMs;
539 
540  float _npot;
541  float _avgpot;
542 
549 
554  std::vector<int> _nEvtTrig;
555  std::vector<DiBlock> _dbList;
556  std::vector<BNEVB> _bnevbList;
557  std::map<geo::OfflineChan,std::vector<BadChan_t> > _badChan;
558  std::map<geo::OfflineChan,std::vector<ChanInfo_t> > _chanInfo;
559  std::vector<Subrun> _subrunList;
560  std::vector<DQSubrunInfo> _dqSRInfo;
561  std::vector<int> _ndRHCRunStart;
562  std::vector<int> _ndRHCRunStop;
563  std::vector<int> _fdRHCRunStart;
564  std::vector<int> _fdRHCRunStop;
565 
566  int64_t _gCfgId;
567 
569 
570  }; // end of class RunHistory
571 
573 
574  } // end of namespace dbi
575 } // end of namespace nova
576 
577 #endif
const XML_Char * name
Definition: expat.h:151
void SetTimeQueries(bool f)
Definition: RunHistory.h:361
bool operator!=(const FEBInfo &febi) const
Definition: RunHistory.h:177
std::vector< DQSubrunInfo > _dqSRInfo
Definition: RunHistory.h:560
int NDiBlocks()
gives number of active diblocks only, may be less than 14
Definition: RunHistory.h:394
float _intercept
intercept for voltage setting
Definition: RunHistory.h:163
diblock
print "ROW IS " print row
Definition: geo2elec.py:31
void SetBadChanVersion(std::string v)
Definition: RunHistory.h:465
std::string _tStart
Definition: RunHistory.h:551
uint32_t _layerPos
position in the layer
Definition: RunHistory.h:203
void SetAbort(bool abort)
Definition: RunHistory.h:449
bool operator<(const HardwareLocation &hl) const
Definition: RunHistory.h:208
std::string _runType
Definition: RunHistory.h:547
uint32_t _modcon
module connection id
Definition: RunHistory.h:133
std::string _detGainTag
Definition: RunHistory.h:548
std::string _dbuser
Definition: RunHistory.h:545
std::vector< float > _pixelGain
pixel gain map for APD
Definition: RunHistory.h:136
void SetGetDiBlockMaskFromCondb(bool f)
Definition: RunHistory.h:367
void SetIfCustomMasking(bool f)
set from fcl: do we want to use a custom mask?
Definition: RunHistory.h:365
std::string BadChanVersion()
Definition: RunHistory.h:464
bool operator!=(const HardwareLocation &hl) const
Definition: RunHistory.h:227
bool operator==(const FEBInfo &febi) const
Definition: RunHistory.h:174
bool gotNAnalysisChannels
Definition: RunHistory.h:49
std::vector< BNEVB > _bnevbList
Definition: RunHistory.h:556
bool operator!=(const APDInfo &apdi) const
Definition: RunHistory.h:144
uint32_t _diblock
Diblock.
Definition: RunHistory.h:198
uint32_t _batch
APD batch number.
Definition: RunHistory.h:129
std::vector< int16_t > pixelThresh
Definition: RunHistory.h:269
std::vector< float > pixelGain
each entry is the gain for the pixel with the number of the index
Definition: RunHistory.h:276
void SetAbortIfMissingRunInDB(bool abort)
Definition: RunHistory.h:450
std::string TStopAsString()
Definition: RunHistory.h:384
const XML_Char * s
Definition: expat.h:262
Definition: Cand.cxx:23
::xsd::cxx::tree::duration< char, simple_type > duration
Definition: Database.h:188
bool operator==(const APDInfo &apdi) const
Definition: RunHistory.h:141
std::vector< FEB > feb
Definition: RunHistory.h:291
uint32_t _modcon
module connection id
Definition: RunHistory.h:167
std::string _dbhost
Definition: RunHistory.h:544
std::string _badChanVersion
Definition: RunHistory.h:553
bool SortDiBlocks(RunHistory::DiBlock db1, RunHistory::DiBlock db2)
Definition: RunHistory.cxx:72
uint32_t _layer
layer in the block
Definition: RunHistory.h:202
std::map< int, int > _diblockIndex
Definition: RunHistory.h:495
float _slope
slope for voltage setting
Definition: RunHistory.h:164
uint32_t _module
module APD is connected to
Definition: RunHistory.h:132
std::vector< int > _nEvtTrig
Definition: RunHistory.h:554
std::vector< DiBlock > _dbList
Definition: RunHistory.h:555
std::string _detector
Definition: RunHistory.h:550
std::vector< BNEVB > GetBNEVBList()
Definition: RunHistory.h:398
void SetDataType(nova::dbi::DataType dt)
Definition: RunHistory.h:448
std::string GainSettingTag()
Definition: RunHistory.h:474
int Duration()
in units of seconds
Definition: RunHistory.h:389
caf::StandardRecord * sr
bool gotNAnalysisDiBlocks
Definition: RunHistory.h:48
void SetGainSettingTag(std::string tag)
Definition: RunHistory.h:473
nova::dbi::DataType _dataType
Definition: RunHistory.h:532
void SetCustomMask(std::vector< bool > f)
set from fcl: what is our custom mask?
Definition: RunHistory.h:366
void SetNDRHCRunStart(std::vector< int > r)
Definition: RunHistory.h:356
void SetCurrentSubrun(int isr)
Definition: RunHistory.h:481
std::string _dbport
Definition: RunHistory.h:546
void SetNRetryLoads(int n)
Definition: RunHistory.h:468
Hold drift constants from current run.
Definition: DriftCache.h:17
void SetNDRHCRunStop(std::vector< int > r)
Definition: RunHistory.h:357
uint32_t _module
module FEB is connected to
Definition: RunHistory.h:166
Definition: run.py:1
std::vector< int > _fdRHCRunStart
Definition: RunHistory.h:563
std::string name
Definition: RunHistory.h:59
bool hasAPD
true if instrumented and active in run, and not masked
Definition: RunHistory.h:263
void SetSubrunDiBlockMask(int isr, int m)
Definition: RunHistory.h:370
bool operator<(const FEBInfo &febi) const
Definition: RunHistory.h:171
void SetDiBlockMaskTag(std::string s)
Definition: RunHistory.h:470
void SetTimeParsing(bool f)
Definition: RunHistory.h:362
std::map< geo::OfflineChan, std::vector< BadChan_t > > _badChan
Definition: RunHistory.h:557
int CurrentSubrun() const
Definition: RunHistory.h:482
std::vector< DCM > dcm
Definition: RunHistory.h:311
::xsd::cxx::tree::string< char, simple_type > string
Definition: Database.h:154
std::vector< int > _fdRHCRunStop
Definition: RunHistory.h:564
bool operator<(const APDInfo &apdi) const
Definition: RunHistory.h:138
std::vector< Subrun > _subrunList
Definition: RunHistory.h:559
bool operator==(const HardwareLocation &hl) const
Definition: RunHistory.h:220
uint32_t _block
installed block
Definition: RunHistory.h:201
uint32_t _feb
FEB port.
Definition: RunHistory.h:200
std::string RunType()
Definition: RunHistory.h:379
void SetFDRHCRunStop(std::vector< int > r)
Definition: RunHistory.h:359
std::vector< int > _ndRHCRunStart
Definition: RunHistory.h:561
int num
Definition: f2_nu.C:119
std::vector< int > _ndRHCRunStop
Definition: RunHistory.h:562
A (plane, cell) pair.
Definition: OfflineChan.h:17
int32_t _temp
operating temperature
Definition: RunHistory.h:130
std::ostream & operator<<(std::ostream &stream, const Column &col)
Definition: Column.h:177
std::map< geo::OfflineChan, std::vector< ChanInfo_t > > _chanInfo
Definition: RunHistory.h:558
TRandom3 r(0)
bool GetDiBlockMaskFromCondb() const
Definition: RunHistory.h:368
std::string _dbname
Definition: RunHistory.h:543
std::string _sn
APD SN.
Definition: RunHistory.h:127
void SetVerbosity(int i)
Definition: RunHistory.h:478
void SetGoodDiBlockMask(int newmask)
Definition: RunHistory.h:408
uint32_t _barcode
barcoded_item_id from barcoded_item table
Definition: RunHistory.h:165
nova::dbi::DataType GetDataType()
Definition: RunHistory.h:452
DataEpoch GetDataEpoch()
Definition: RunHistory.h:484
std::string comment
Definition: RunHistory.h:66
uint32_t dchan
< DAQ Channel Map Package
int nInstrumentedFEBs
number of FEBs that were instrumented and active in run and not masked
Definition: RunHistory.h:287
std::string timing_mode
Definition: RunHistory.h:65
int nInstrumentedFEBs
number of FEBs that were intrumented and active in run and not masked
Definition: RunHistory.h:310
int port
Definition: client_test.C:9
void SetFDRHCRunStart(std::vector< int > r)
Definition: RunHistory.h:358
DiBlock(unsigned int ndcm=12)
Definition: RunHistory.h:297
float _voltage
operating voltage
Definition: RunHistory.h:131
uint32_t _barcode
barcode id from barcoded_item table
Definition: RunHistory.h:128
Simple object representing a (plane, cell) pair.
void SetAnalysisDiBlockMasking(bool f)
set from fcl: do we want to use the analysis rules when we mask (not for custom masking)?
Definition: RunHistory.h:364
std::string _sn
FEB SN.
Definition: RunHistory.h:162
int RunNumber() const
Definition: RunHistory.h:374
std::string TStartAsString()
Definition: RunHistory.h:383
DiBlock(int dbnum, unsigned int ndcm=12)
Definition: RunHistory.h:299
int32_t _detid
Detector ID.
Definition: RunHistory.h:197
int Verbosity() const
Definition: RunHistory.h:479
std::string Detector() const
Definition: RunHistory.h:376
void SetIfAnyMasking(bool f)
set from fcl: do we want to use any masking at all? If no, other masking options irrelevant ...
Definition: RunHistory.h:363
std::string _dbMaskTag
Definition: RunHistory.h:488