RunHistory.h

Go to the documentation of this file.

#ifndef _RUNHISTORY_H
#define _RUNHISTORY_H

#include <string>
#include <vector>
#include <map>
#include <list>
#include <ctime>
#include <climits>
#include <stdint.h>
#include <memory>

#include <GeometryObjects/OfflineChan.h>
#include <DAQChannelMap/DAQChannelMap.h>
#include <NovaDAQConventions/DAQConventions.h>
#ifdef NOVACMAKE
#include <Database/cxx/include/DataType.h>
#else
#include <Database/DataType.h>
#endif

namespace nova {
  namespace dbi {

    class ChanInfo_t {
    public:
      ChanInfo_t() { occ=-6.; coinc=0.; tstart=0;}
      ~ChanInfo_t() {};

      float occ;
      float coinc;
      time_t tstart;
    };

    class BadChan_t {
    public:
      BadChan_t() { isBad = false; tstart=0;}
      ~BadChan_t() {};
      
      bool isBad;
      time_t tstart;
    };

    struct Subrun {
      time_t tstart;
      time_t tstop;
      bool gotNAnalysisDiBlocks;
      bool gotNAnalysisChannels;
      int nAnalysisDiBlocks;
      int nAnalysisChannels;
      int goodDiBlockMask;
    };

    class DataEpoch {
    public:
      DataEpoch() : name(""), run_start(0), run_end(0), duration(0), timing_mode(""),
                  comment("") {}
      ~DataEpoch() {};
      
      std::string name;
      int run_start;
      int run_end;
      uint64_t duration;
      std::string timing_mode;
      std::string comment;
      
      friend std::ostream& operator << (std::ostream &o, const DataEpoch & ep)
      {
        o << ep.name << ", " 
          << ep.run_start << ", "
          << ep.run_end << ", "
          << ep.duration << ", "
          << ep.timing_mode << ", "
          << ep.comment;
        return o;
      }
    };

    struct DQSubrunInfo {
      
      DQSubrunInfo() : _run(0), _subrun(-1), _flag(0), _version(0),
                       _miprate(0.), _ngooddb(0), _numslc(0.), _trkfrac(0.)
      {
      }

      int _run;
      short _subrun;
      int _flag;
      int _version;
      float _miprate;
      int _ngooddb;
      float _numslc;
      float _trkfrac;

      friend std::ostream& operator << (std::ostream &o, const DQSubrunInfo & sri)
      {
        o << sri._run << " " 
          << sri._subrun << " " 
          << sri._flag << " "
          << sri._version << " "
          << sri._miprate << " "
          << sri._ngooddb << " "
          << sri._numslc << " "
          << sri._trkfrac;
        return o;
      }

    };

        
    struct APDInfo {
      
      APDInfo()
      : _sn       ("")    
      , _barcode  (UINT_MAX)
      , _batch    (UINT_MAX)
      , _temp     (INT_MAX)
      , _voltage  (UINT_MAX)
      , _module   (UINT_MAX)
      , _modcon   (UINT_MAX)
      , _installed(0.)
      {
        _pixelGain.resize(32, 100.);
      }

      std::string _sn;               ///< APD SN                                                
      uint32_t    _barcode;          ///< barcode id from barcoded_item table                   
      uint32_t    _batch;            ///< APD batch number                                      
      int32_t     _temp;             ///< operating temperature                         
      float       _voltage;          ///< operating voltage                                     
      uint32_t    _module;           ///< module APD is connected to                            
      uint32_t    _modcon;           ///< module connection id                                  
      double      _installed;        ///< time the APD was installed on the 
                                     ///< detector in seconds since 1970
      std::vector<float> _pixelGain; ///< pixel gain map for APD

      bool operator<( const APDInfo& apdi ) const
      { return _installed < apdi._installed; }

      bool operator==( const APDInfo& apdi ) const
      { return _sn == apdi._sn; }

      bool operator!=( const APDInfo& apdi ) const
      { return _sn != apdi._sn; }
        
      friend std::ostream& operator << (std::ostream &o, const APDInfo & apdi)
      {
        o << "APD: " << apdi._sn << " " 
          << apdi._barcode << " " 
          << apdi._batch << " " 
          << apdi._temp << " " 
          << apdi._voltage << " " 
          << apdi._module << " " 
          << apdi._modcon << " " 
          << apdi._installed << std::endl;
        return o;
      }
    };

    struct FEBInfo {
      std::string _sn;        ///< FEB SN
      float       _intercept; ///< intercept for voltage setting
      float       _slope;     ///< slope for voltage setting
      uint32_t    _barcode;   ///< barcoded_item_id from barcoded_item table
      uint32_t    _module;    ///< module FEB is connected to
      uint32_t    _modcon;    ///< module connection id
      double      _installed; ///< time the FEB was installed on the 
                              ///< detector in seconds since 1970

      bool operator<( const FEBInfo& febi ) const
      { return _installed < febi._installed; }

      bool operator==( const FEBInfo& febi) const
      { return _sn == febi._sn; }

      bool operator!=( const FEBInfo& febi) const
      { return _sn != febi._sn; }

      friend std::ostream& operator << (std::ostream &o, const FEBInfo & febi)
      {
        o << "FEB: " 
          << febi._sn        << " " 
          << febi._barcode   << " " 
          << febi._module    << " " 
          << febi._intercept << " " 
          << febi._slope     << " " 
          << febi._modcon    << " " 
          << febi._installed << std::endl;
        return o;
      }
        
    };   

    struct HardwareLocation {

      int32_t   _detid;    ///< Detector ID
      uint32_t  _diblock;  ///< Diblock
      uint32_t  _dcm;      ///< DCM
      uint32_t  _feb;      ///< FEB port
      uint32_t  _block;    ///< installed block
      uint32_t  _layer;    ///< layer in the block
      uint32_t  _layerPos; ///< position in the layer

      // it is assumed that each RunHistory object is only for 
      // 1 detector so no need to test on _detid in the 
      // comparison operators
      bool operator<( const HardwareLocation& hl ) const
      {
        if     ( _diblock <  hl._diblock ) return true;
        else if( _diblock == hl._diblock && 
                 _dcm     <  hl._dcm     ) return true;
        else if( _diblock == hl._diblock && 
                 _dcm     == hl._dcm     && 
                 _feb     <  hl._feb     ) return true;

        return false;
      }

      bool operator==( const HardwareLocation& hl ) const
      {
        return ( _diblock == hl._diblock &&
                 _dcm     == hl._dcm     &&
                 _feb     == hl._feb);
      }

      bool operator!=( const HardwareLocation& hl ) const
      {
        return ( _diblock != hl._diblock ||
                 _dcm     != hl._dcm     ||
                 _feb     != hl._feb);
      }

      friend std::ostream& operator << (std::ostream &o, const HardwareLocation & hl)
      {
        o << "dcm-"
          << hl._detid    << "-" 
          << hl._diblock  << "-" 
          << hl._dcm      << "-" 
          << hl._feb      << std::endl;
        return o;
      }

    };

    /**
     * Utilities for accessing run history, calib. constants, etc.
     *
     * @author Jonathan Paley
     * @version $Revision: 1.9 $ $Date: 2013/02/11 15:36:10 $
     */
    
    class RunHistory {
      
    public:
     
      class FEB {
      public:
        FEB();
        ~FEB() {};
        
        std::string hwid;
        bool hasAPD;  ///< true if instrumented and active in run, and not masked
        short block;
        short layer;
        short pos_in_layer;
        int nActivePix;
        int32_t pixelMask;
        std::vector<int16_t> pixelThresh;
        int apdV;
        bool isEnabled;
        bool isCooled;
        bool tempEnabled;
        float temperature;
        float gain;
        std::vector<float> pixelGain;  ///< each entry is the gain for the pixel with the number of the index
      };
      
      class DCM {
      public:
        DCM() {feb.clear(); isActive=false; nInstrumentedFEBs=0; diblock=-1;};
        ~DCM() {};

        bool isActive; ///< if it was active in run according to DAQ
        short diblock;
        short position;
        int nInstrumentedFEBs; ///< number of FEBs that were instrumented and active in run and not masked
        std::string hwid;
        std::string appname;
        int64_t febMask;
        std::vector<FEB> feb;

      };
      
      class DiBlock {
      public:
        DiBlock(unsigned int ndcm=12) {dcm.resize(ndcm); nInstrumentedFEBs=0; 
          for (unsigned int i=0; i<ndcm; ++i) dcm[i].position=i+1;};
        DiBlock(int dbnum, unsigned int ndcm=12) {
          dcm.resize(ndcm); nInstrumentedFEBs=0; num=dbnum;
          for (unsigned int i=0; i<ndcm; ++i) {
            dcm[i].position=i+1;
            dcm[i].diblock=dbnum;
          }
        };
        ~DiBlock() {};

        bool  hasNoAPDs;
        short num;
        int   nInstrumentedFEBs; ///< number of FEBs that were intrumented and active in run and not masked
        std::vector<DCM> dcm;
      };
      
      class BNEVB {
      public:
        BNEVB() {};
        ~BNEVB() {};
        
        std::string hwid;
        std::string appname;
      };
      
      RunHistory();

      virtual ~RunHistory();
#ifndef __GCCXML__
      RunHistory(int run, std::string det);
      RunHistory(int run, novadaq::cnv::DetId detid);
      
      void SetDBInfo(std::string dbname="", std::string dbhost="", 
                     std::string user="",   std::string port="");
      void SetRunNumber(int run);
      void SetDetector(novadaq::cnv::DetId det);
      void SetDetector(const std::string& det);
      
      bool LoadDAQRunHistory();
      bool LoadHardwareInfo();
      bool LoadDCSAlarms(int subrun=-1);
      bool LoadCoolingInfo();
      bool LoadPixelInfo(int nAttempt=0); // slow!  from DAQ database
      bool LoadPixelMasks(); // fast! from conditions database
      bool LoadFEBMasks(); // fast!  from conditions database
      bool LoadFEBMasksFromDAQDB(); // slow!  from DAQ database
      bool LoadPedestals(); // fast!  fromc conditions database
      bool LoadAPDSettings();
      bool LoadPOT();
      bool LoadGoodDiBlockMask();
      bool LoadDataEpoch();
      bool LoadAllDetInfo() { return (LoadDAQRunHistory() && 
                                      LoadHardwareInfo() &&
                                      LoadPixelInfo() && 
                                      LoadAPDSettings()); };
      bool IsRHC();
      void Dump();

      void SetNDRHCRunStart(std::vector<int> r) { _ndRHCRunStart = r; }
      void SetNDRHCRunStop(std::vector<int> r) { _ndRHCRunStop = r; }
      void SetFDRHCRunStart(std::vector<int> r) { _fdRHCRunStart = r; }
      void SetFDRHCRunStop(std::vector<int> r) { _fdRHCRunStop = r; }

      void SetTimeQueries(bool f) {_timeQueries=f;}
      void SetTimeParsing(bool f) {_timeParsing=f;}
      void SetIfAnyMasking(bool f) {_useMasking=f;} ///< set from fcl: do we want to use any masking at all?  If no, other masking options irrelevant
      void SetAnalysisDiBlockMasking(bool f) {_analysisDiBlockMasking=f;} ///< set from fcl: do we want to use the analysis rules when we mask (not for custom masking)?
      void SetIfCustomMasking(bool f) {_customMasking=f;} ///< set from fcl: do we want to use a custom mask?
      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?
      void SetGetDiBlockMaskFromCondb(bool f) {_getDiBlockMaskFromCondb = f;}
      bool GetDiBlockMaskFromCondb() const { return _getDiBlockMaskFromCondb; }
      
      void SetSubrunDiBlockMask(int isr, int m) { _subrunList[isr].goodDiBlockMask=m; }     
      int  ApplyAnalysisDiBlockMask(const int mask) const; ///< converts normal mask to analysis rules mask (any continuous chunk of four or more diblocks kept)
      std::string DiBlockMaskToString(const int mask) const;

      int  RunNumber() const { return _runNumber; }
      int  NSubruns()  { LoadDAQRunHistory(); return _nsubrun; }
      std::string Detector() const { return _detector; }
      
      int  Partition() { LoadDAQRunHistory(); return _partition;}
      std::string RunType() { LoadDAQRunHistory(); return _runType; }

      time_t TStart();
      time_t TStop();
      std::string TStartAsString() { LoadDAQRunHistory(); return _tStart;}
      std::string TStopAsString() { LoadDAQRunHistory(); return _tEnd;}

      time_t SubrunTStart(int isr);
      time_t SubrunTStop(int isr);

      int Duration()  { LoadDAQRunHistory(); return TStop()-TStart(); }  ///< in units of seconds
      int NTriggers()  { LoadDAQRunHistory(); return _nTotTrig; }
      float NPOT() { LoadPOT(); return _npot; }
      float AvgPOTPerSpill() { LoadPOT(); return _avgpot; }

      int NDiBlocks()  { LoadDAQRunHistory(); return _dbList.size(); } ///< gives number of active diblocks only, may be less than 14
      int NDCMs();
      int NLiveDCMs();
      int NBNEVBs()  { LoadDAQRunHistory(); return _bnevbList.size(); }
      std::vector<BNEVB> GetBNEVBList() { return _bnevbList; }
      
      int NAnalysisChannels(int sr=0);
      int NAnalysisDiBlocks(int sr=0);
      int NActiveChannels()  { LoadDAQRunHistory(); return _nActiveChannels; }
      int NTotalChannels()  { LoadDAQRunHistory(); return _nTotalChannels; }
      int NFEBs()  { LoadPixelInfo(); return _nTotalFEBs; }

      int GoodDiBlockMask(int subrun=-1, bool reload=false);
      int GetConfiguration();
      void SetGoodDiBlockMask(int newmask) {for (size_t isr=0; isr<64; ++isr) _subrunList[isr].goodDiBlockMask=newmask; _gotGoodDiBlockMask=true;}
      bool IsGoodDiBlock(int idb, int subrun=-1);
      
      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

      int NAPDInstalled()  { LoadHardwareInfo(); return _nInstalledAPDs; }

      bool IsDiBlockFullyInstrumented(int idb); ///< returns true if nInstrumentedFEBs in diblock (which counts FEBs that are instrumented, active, and unmasked only) is >= 700

      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
      bool HasAPD(const daqchannelmap::dchan&);

      bool IsCooled(const geo::OfflineChan&);
      bool IsCooled(const daqchannelmap::dchan&);

      int GetThreshold(const geo::OfflineChan&, bool&);
      int GetThreshold(const daqchannelmap::dchan&, bool&);

      int GetPedestal(const geo::OfflineChan&, bool&);
      int GetPedestal(const daqchannelmap::dchan&, bool&);

      
      FEB   GetFEB(geo::OfflineChan const&,
                   bool &);
      FEB   GetFEB(daqchannelmap::dchan const&,
                   bool &);

      float GetGain(const geo::OfflineChan&, bool&);
      float GetGain(const daqchannelmap::dchan&, bool&);
      float GetPixelGain(geo::OfflineChan const&,
                         bool &);
      float GetPixelGain(daqchannelmap::dchan const&,
                         bool &);
      std::vector<float> GetPixelGains(geo::OfflineChan const&,
                                       bool &);
      std::vector<float> GetPixelGains(daqchannelmap::dchan const&,
                                       bool &);

      std::vector<DQSubrunInfo> GetDQSubrunInfo();

      void SetDataType(nova::dbi::DataType dt) { _dataType = dt; }
      void SetAbort(bool abort) { _abort=abort; }
      void SetAbortIfMissingRunInDB(bool abort) { _abortIfMissingRunInDB=abort; }

      nova::dbi::DataType GetDataType() { return _dataType; }

      void SetIsBad(geo::OfflineChan, bool, time_t);
      bool IsBad(geo::OfflineChan, time_t);
      void ClearBadChan() { _badChan.clear(); }

      void SetChanInfo(geo::OfflineChan, float, float, time_t);
      float Occupancy(geo::OfflineChan, time_t);
      float Coincidence(geo::OfflineChan, time_t);
      void ClearChanInfo() { _chanInfo.clear(); }
      void PrintChanInfo();

      std::string BadChanVersion()  { return _badChanVersion;}
      void SetBadChanVersion(std::string v) { _badChanVersion=v;}

      int  NRetryLoads() { return _nRetryLoads; }
      void SetNRetryLoads(int n) { _nRetryLoads = n;}

      void SetDiBlockMaskTag(std::string s) { _dbMaskTag = s; }

      int  DetGainSetting();
      void SetGainSettingTag(std::string tag) {_detGainTag = tag;}
      std::string GainSettingTag() {return _detGainTag;}

      bool DetFineTimingSetting() const;

      void SetVerbosity(int i) { _verbosity = i; }
      int Verbosity() const { return _verbosity; }

      void SetCurrentSubrun(int isr) { _currentSR = isr; }
      int CurrentSubrun() const { return _currentSR; }

      DataEpoch GetDataEpoch() { LoadDataEpoch(); return _dataEpoch; }
      
    protected:
      bool _getDiBlockMaskFromCondb;
      std::string _dbMaskTag;
      
    private:
      /// Call at new run/detector etc
      void InvalidateCaches();
      void BuildMC();

      std::map<int,int> _diblockIndex;
      std::map<uint32_t, APDInfo> PullAPDInfoFromDB();
      std::map<HardwareLocation, std::pair<FEBInfo, APDInfo>> PullFEBInfoFromDB(std::map<uint32_t, APDInfo> apdinfomap);
      void MapHardwareToLocation();  

#endif // __GCCXML__
      bool _failedToFindRun;
      bool _gotDAQRunHistory;
      bool _gotPixelInfo;
      bool _gotFEBMasks;
      bool _gotPixelMasks;
      bool _gotPedestals;
      bool _gotHardwareInfo;
      bool _gotAPDSettings;
      bool _gotCoolingInfo;
      bool _gotPOT;
      bool _gotGoodDiBlockMask;
      bool _timeQueries;
      bool _timeParsing;
      bool _analysisDiBlockMasking;
      bool _useMasking;
      bool _customMasking;
      bool _isMC;
      bool _abort;
      bool _abortIfMissingRunInDB;
      bool _gotDQSubrunInfo;
      bool _gotDataEpoch;
      
      int _customMask;
      int _runNumber;
      int _nsubrun;
      int _nTotTrig;
      int _nActiveChannels;
      int _nTotalChannels;
      int _nTotalFEBs;
      int _nInstalledAPDs;
      int _detId;
      nova::dbi::DataType _dataType;
      int _partition;
      int _nDCMs;
      int _nRetryLoads;
      int _detGainSetting;
      int _verbosity;
      int _currentSR;
      
      float _npot;
      float _avgpot;

      std::string _dbname;
      std::string _dbhost;
      std::string _dbuser;
      std::string _dbport;
      std::string _runType;
      std::string _detGainTag;

      std::string _detector;
      std::string _tStart;
      std::string _tEnd;
      std::string _badChanVersion;
      std::vector<int> _nEvtTrig;
      std::vector<DiBlock> _dbList;
      std::vector<BNEVB> _bnevbList;
      std::map<geo::OfflineChan,std::vector<BadChan_t> > _badChan;
      std::map<geo::OfflineChan,std::vector<ChanInfo_t> > _chanInfo;
      std::vector<Subrun> _subrunList;
      std::vector<DQSubrunInfo> _dqSRInfo;
      std::vector<int> _ndRHCRunStart;
      std::vector<int> _ndRHCRunStop;
      std::vector<int> _fdRHCRunStart;
      std::vector<int> _fdRHCRunStop;

      int64_t _gCfgId;

      DataEpoch _dataEpoch;
      
    };  // end of class RunHistory
    
    bool SortDiBlocks(RunHistory::DiBlock, RunHistory::DiBlock);
  
  }  // end of namespace dbi
} // end of namespace nova
  
#endif