TdcProcessor.h

#ifndef HADAQ_TDCPROCESSOR_H
#define HADAQ_TDCPROCESSOR_H
 
#include "hadaq/SubProcessor.h"
 
#include "hadaq/TdcMessage.h"
#include "hadaq/TdcIterator.h"
#include "hadaq/TdcSubEvent.h"
 
#include <vector>
#include <cmath>
#include <string>
 
namespace hadaq {
 
   enum { FineCounterBins = 600, TotBins = 3000, ToTvalue = 20, ToThmin = 15, ToThmax = 60 };
 
   class TdcProcessor : public SubProcessor {
 
      friend class TrbProcessor;
 
      protected:
 
         struct ChannelRec {
            unsigned refch;                
            unsigned reftdc;               
            bool refabs;                   
            unsigned doublerefch;          
            unsigned doublereftdc;         
            unsigned refch_tmds;           
            bool docalibr;                 
            bool hascalibr;                
            bool check_calibr;             
            base::H1handle fRisingFine;    
            base::H1handle fRisingMult;    
            base::H1handle fRisingRef;     
            base::C1handle fRisingRefCond; 
            base::H1handle fRisingCalibr;  
            base::H2handle fRisingRef2D;   
            base::H1handle fRisingRefRef;  
            base::H2handle fRisingDoubleRef; 
            base::H1handle fRisingTmdsRef; 
            base::H1handle fFallingFine;   
            base::H1handle fFallingMult;   
            base::H1handle fTot;           
            base::H1handle fTot0D;         
            base::H1handle fFallingCalibr; 
            int rising_cnt;                
            int falling_cnt;               
            double rising_hit_tm;          
            double rising_last_tm;         
            bool rising_new_value;         
            double rising_ref_tm;          
            double rising_tmds;            
            unsigned rising_coarse;        
            unsigned rising_fine;          
            unsigned last_rising_fine;     
            unsigned last_falling_fine;    
            long all_rising_stat;          
            long all_falling_stat;         
            std::vector<uint32_t> rising_stat;  
            std::vector<float> rising_calibr;   
            std::vector<uint32_t> falling_stat;  
            std::vector<float> falling_calibr;   
            float last_tot;                 
            long tot0d_cnt;                 
            std::vector<uint32_t> tot0d_hist;  
            float tot_shift;                
            float tot_dev;                  
            float time_shift_per_grad;      
            float trig0d_coef;              
            int rising_cond_prnt;           
            float calibr_quality_rising;    
            float calibr_quality_falling;    
            long calibr_stat_rising;        
            long calibr_stat_falling;       
 
            ChannelRec() :
               refch(0xffffff),
               reftdc(0xffffffff),
               refabs(false),
               doublerefch(0xffffff),
               doublereftdc(0xffffff),
               refch_tmds(0xffffff),
               docalibr(true),
               hascalibr(false),
               check_calibr(false),
               fRisingFine(0),
               fRisingMult(0),
               fRisingRef(0),
               fRisingRefCond(0),
               fRisingCalibr(0),
               fRisingRef2D(0),
               fRisingRefRef(0),
               fRisingDoubleRef(0),
               fRisingTmdsRef(0),
               fFallingFine(0),
               fFallingMult(0),
               fTot(0),
               fTot0D(0),
               fFallingCalibr(0),
               rising_cnt(0),
               falling_cnt(0),
               rising_hit_tm(0.),
               rising_last_tm(0),
               rising_new_value(false),
               rising_ref_tm(0.),
               rising_tmds(0.),
               rising_coarse(0),
               rising_fine(0),
               last_rising_fine(0),
               last_falling_fine(0),
               all_rising_stat(0),
               all_falling_stat(0),
               rising_stat(),
               rising_calibr(),
               falling_stat(),
               falling_calibr(),
               last_tot(0.),
               tot0d_cnt(0),
               tot0d_hist(),
               tot_shift(0.),
               tot_dev(0.),
               time_shift_per_grad(0.),
               trig0d_coef(0.),
               rising_cond_prnt(-1),
               calibr_quality_rising(-1.),
               calibr_quality_falling(-1.),
               calibr_stat_rising(0),
               calibr_stat_falling(0)
            {
            }
 
            void CreateCalibr(unsigned numfine, double coarse_unit = -1.)
            {
               rising_stat.resize(numfine);
               falling_stat.resize(numfine);
 
               FillCalibr(numfine, coarse_unit);
            }
 
            void FillCalibr(unsigned numfine, double coarse_unit = -1.)
            {
               for (unsigned n=0;n<numfine;n++)
                  falling_stat[n] = rising_stat[n] = 0;
 
               SetLinearCalibr(hadaq::TdcMessage::GetFineMinValue(), hadaq::TdcMessage::GetFineMaxValue(), coarse_unit);
            }
 
            void SetLinearCalibr(unsigned finemin, unsigned finemax, double coarse_unit = -1)
            {
               rising_calibr.resize(5,0);
               falling_calibr.resize(5,0);
 
               // to support old API where factor for default coarse unit was possible to specify
               if (coarse_unit < 0)
                  coarse_unit = hadaq::TdcMessage::CoarseUnit();
               else if (coarse_unit > 0.01)
                  coarse_unit = coarse_unit * hadaq::TdcMessage::CoarseUnit();
 
               rising_calibr[0] = 2; // 2 values
               rising_calibr[1] = finemin;
               rising_calibr[2] = 0.;
               rising_calibr[3] = finemax;
               rising_calibr[4] = coarse_unit;
 
               for (int n=0;n<5;++n)
                  falling_calibr[n] = rising_calibr[n];
            }
 
            void ReleaseCalibr()
            {
               rising_stat.clear();
               rising_calibr.clear();
               falling_stat.clear();
               falling_calibr.clear();
            }
 
            void CreateToTHist()
            {
               tot0d_hist.resize(TotBins);
               for (unsigned n=0;n<TotBins;n++)
                  tot0d_hist[n] = 0;
            }
 
            void ReleaseToTHist()
            {
               tot0d_hist.clear();
 
            }
         };
 
         bool fVersion4{false};         
 
         TdcIterator fIter1;         
         TdcIterator fIter2;         
 
         base::H1handle fChannels;   
         base::H1handle fHits;       
         base::H1handle fErrors;     
         base::H1handle fUndHits;    
         base::H1handle fCorrHits;   
         base::H1handle fMsgsKind;   
         base::H2handle fAllFine;    
         base::H2handle fAllCoarse;  
         base::H2handle fRisingCalibr;
         base::H2handle fFallingCalibr; 
         base::H1handle fHitsRate;    
         base::H1handle fTotShifts;  
         base::H1handle fTempDistr;   
 
         base::H2handle fhRaisingFineCalibr; 
         base::H2handle fhTotVsChannel; 
         base::H1handle fhTotMoreCounter; 
         base::H1handle fhTotMinusCounter; 
 
         unsigned fHldId;               
         base::H1handle *fHitsPerHld;   
         base::H1handle *fErrPerHld;    
         base::H2handle *fChHitsPerHld; 
         base::H2handle *fChErrPerHld;  
         base::H2handle *fChCorrPerHld;  
         base::H2handle *fQaFinePerHld;  
         base::H2handle *fQaToTPerHld;  
         base::H2handle *fQaEdgesPerHld;  
         base::H2handle *fQaErrorsPerHld;  
 
         unsigned                 fNumChannels;       
         unsigned                 fNumFineBins;       
         std::vector<ChannelRec>  fCh;                
         float                    fCalibrTemp;        
         float                    fCalibrTempCoef;    
         bool                     fCalibrUseTemp;     
         unsigned                 fCalibrTriggerMask; 
 
         bool                     fToTdflt;        
         double                   fToTvalue;       
         double                   fToThmin;        
         double                   fToThmax;        
         double                   fTotUpperLimit;  
         int                      fTotStatLimit;   
         double                   fTotRMSLimit;    
 
         long   fCalibrAmount;        
         double fCalibrProgress;      
         std::string fCalibrStatus;   
         double fCalibrQuality;       
                                      //  0         - not exists
                                      //  0..0.3    - bad (red color)
                                      //  0.3..0.7  - poor (yellow color)
                                      //  0.7..0.8  - accumulating (blue color)
                                      //  0.8..1.0  - ok (green color)
 
         float                    fTempCorrection; 
         float                    fCurrentTemp;    
         unsigned                 fDesignId;       
         double                   fCalibrTempSum0; 
         double                   fCalibrTempSum1; 
         double                   fCalibrTempSum2; 
 
         std::vector<hadaq::TdcMessageExt>  fDummyVect; 
         std::vector<hadaq::TdcMessageExt> *pStoreVect; 
 
         std::vector<hadaq::MessageFloat> fDummyFloat;  
         std::vector<hadaq::MessageFloat> *pStoreFloat; 
 
         std::vector<hadaq::MessageDouble> fDummyDouble;  
         std::vector<hadaq::MessageDouble> *pStoreDouble; 
 
         unsigned    fEdgeMask;        
         long        fCalibrCounts;    
         bool        fAutoCalibr;      
         bool        fAutoCalibrOnce;  
         int         fAllCalibrMode;   
         int         fAllTotMode;      
         int         fAllDTrigCnt;     
 
         std::string fWriteCalibr;    
         bool        fWriteEveryTime; 
         bool        fUseLinear;      
         int         fLinearNumPoints; 
 
         bool      fEveryEpoch;       
 
         bool      fUseLastHit;       
 
         bool      fUseNativeTrigger;  
 
         bool      fCompensateEpochReset; 
 
         unsigned  fCompensateEpochCounter;  
 
         bool      fCh0Enabled;           
 
         TdcMessage fLastTdcHeader;      
         TdcMessage fLastTdcTrailer;      
 
         long      fRateCnt;             
         double    fLastRateTm;          
 
         unsigned  fSkipTdcMessages;     
         bool      f400Mhz;              
         double    fCustomMhz;           
 
         std::vector<std::string> fCalibrLog; 
 
         virtual bool doTriggerSelection() const { return false; }
 
         static unsigned gNumFineBins;   
         static unsigned gTotRange;      
         static unsigned gHist2dReduce;  
         static unsigned gErrorMask;     
         static bool gAllHistos;         
         static double gTrigDWindowLow;  
         static double gTrigDWindowHigh; 
         static bool gUseDTrigForRef;    
         static bool gUseAsDTrig;        
         static int gHadesMonitorInterval; 
         static int gTotStatLimit;         
         static double gTotRMSLimit;       
         static int gDefaultLinearNumPoints;      
         static bool gIgnoreCalibrMsgs;    
         static bool gStoreCalibrTables;   
 
         virtual void AppendTrbSync(uint32_t syncid);
 
         virtual double MaximumDisorderTm() const { return 2e-6; }
 
         bool DoBufferScan(const base::Buffer &buf, bool isfirst);
         bool DoBuffer4Scan(const base::Buffer &buf, bool isfirst);
 
         double DoTestToT(int iCh);
         double DoTestErrors(int iCh);
         double DoTestEdges(int iCh);
         double DoTestFineTimeH2(int iCh, base::H2handle h);
         double DoTestFineTime(double hRebin[], int nBinsRebin, int nEntries);
 
         virtual void BeforeFill();
         virtual void AfterFill(SubProcMap* = 0);
 
         long CheckChannelStat(unsigned ch);
 
         double CalibrateChannel(unsigned nch, bool rising, const std::vector<uint32_t> &statistic, std::vector<float> &calibr, bool use_linear = false, bool preliminary = false);
         void CopyCalibration(const std::vector<float> &calibr, base::H1handle hcalibr, unsigned ch = 0, base::H2handle h2calibr = 0);
 
         bool CalibrateTot(unsigned ch, std::vector<uint32_t> &hist, float &tot_shift, float &tot_dev, float cut = 0.);
 
         bool CheckPrintError();
 
         bool CreateChannelHistograms(unsigned ch);
 
         double TestCanCalibrate(bool fillhist = false, std::string *status = nullptr);
 
         bool PerformAutoCalibrate();
 
         void ClearChannelStat(unsigned ch);
 
         float ExtractCalibr(const std::vector<float> &func, unsigned bin);
 
         inline float ExtractCalibrDirect(const std::vector<float> &func, unsigned bin)
         {
            if (func.size() > 100) return func[bin];
 
            // here only two-point linear approximation is supported
            // later one can extend approximation for N-points linear function
            if (bin <= func[1]) return func[2];
            int pnt = func.size() - 2;  // 3 for simple linear point
            if (bin >= func[pnt]) return func[pnt+1];
 
            if (pnt > 3) {
               int segm = std::ceil((bin - func[1]) / (func[pnt] - func[1]) * (func[0] - 1)); // segment in linear approx
               pnt = 1 + segm*2; // first segment should have pnt = 3, second segment pnt = 5 and so on
            }
 
            return func[pnt-1] + (bin - func[pnt-2]) / (func[pnt] - func[pnt-2]) * (func[pnt+1] - func[pnt-1]);
         }
 
         void CreateV4CalibrTable(unsigned ch, uint32_t *table);
         void SetTable(uint32_t *table, unsigned addr, uint32_t value);
 
         void FindFMinMax(const std::vector<float> &func, int nbin, int &fmin, int &fmax);
 
         virtual void CreateBranch(TTree*);
 
         void AddError(unsigned code, const char *args, ...);
 
      public:
 
         enum EErrors {
            errNoHeader,       
            errChId,           
            errEpoch,          
            errFine,           
            err3ff,            
            errCh0,            
            errMismatchDouble, 
            errUncknHdr,       
            errDesignId,       
            errMisc            
         };
 
         enum EEdgesMasks {
            edge_Rising = 1,        
            edge_BothIndepend = 2,  
            edge_ForceRising  = 3,  
            edge_CommonStatistic = 4  
         };
 
         TdcProcessor(TrbProcessor* trb, unsigned tdcid, unsigned numchannels = MaxNumTdcChannels, unsigned edge_mask = 1, bool ver4 = false);
         virtual ~TdcProcessor();
 
         static void SetMaxBoardId(unsigned);
 
         static void SetDefaults(unsigned numfinebins = 600, unsigned totrange = 100, unsigned hist2dreduced = 10);
 
         static void SetErrorMask(unsigned mask = 0xffffffffU);
 
         static void SetAllHistos(bool on = true);
 
         static void SetIgnoreCalibrMsgs(bool on = true);
 
         static void SetHadesMonitorInterval(int tm = -1);
         static int GetHadesMonitorInterval();
 
         static void SetUseDTrigForRef(bool on = true);
 
         static void SetTriggerDWindow(double low = -25, double high = 50);
 
         static void SetToTCalibr(int minstat = 100, double rms = 0.15);
 
         static void SetDefaultLinearNumPoints(int cnt = 2);
 
         static void SetUseAsDTrig(bool on = true);
 
         static void SetStoreCalibrTables(bool on = true);
 
         void SetSkipTdcMessages(unsigned cnt = 0) { fSkipTdcMessages = cnt; }
 
         void Set400Mhz(bool on = true);
 
         void SetCustomMhz(float freq = 400.);
 
         void SetTotStatLimit(int minstat = 100) { fTotStatLimit = minstat; }
         void SetTotRMSLimit(double rms = 0.15) { fTotRMSLimit = rms; }
 
         inline unsigned NumChannels() const { return fNumChannels; }
         inline bool DoRisingEdge() const { return true; }
         inline bool DoFallingEdge() const { return fEdgeMask > 1; }
         inline unsigned GetEdgeMask() const { return fEdgeMask; }
 
         double GetCalibrProgress() const { return fCalibrProgress; }
         std::string GetCalibrStatus() const { return fCalibrStatus; }
         double GetCalibrQuality() const { return fCalibrQuality; }
         void AcknowledgeCalibrQuality(double lvl = 1.)
         {
            if (fCalibrQuality < lvl) {
               fCalibrQuality = lvl;
               fCalibrProgress = 1.;
               fCalibrStatus = "Ready";
            }
         }
         std::vector<std::string> TakeCalibrLog()
         {
            std::vector<std::string> res;
            std::swap(res, fCalibrLog);
            return res;
         }
 
         int GetNumHist() const { return 9; }
 
         const char* GetHistName(int k) const
         {
            switch(k) {
               case 0: return "RisingFine";
               case 1: return "RisingCoarse";
               case 2: return "RisingRef";
               case 3: return "FallingFine";
               case 4: return "FallingCoarse";
               case 5: return "Tot";
               case 6: return "RisingMult";
               case 7: return "FallingMult";
               case 8: return "RisingTmdsRef";
            }
            return "";
         }
 
         base::H1handle GetHist(unsigned ch, int k = 0)
         {
            if (ch>=NumChannels()) return 0;
            switch (k) {
               case 0: return fCh[ch].fRisingFine;
               case 1: return 0;
               case 2: return fCh[ch].fRisingRef;
               case 3: return fCh[ch].fFallingFine;
               case 4: return 0;
               case 5: return fCh[ch].fTot;
               case 6: return fCh[ch].fRisingMult;
               case 7: return fCh[ch].fFallingMult;
               case 8: return fCh[ch].fRisingTmdsRef;
            }
            return 0;
         }
 
         void CreateHistograms(int *arr = 0);
 
         void AssignPerHldHistos(unsigned id, base::H1handle *hHits, base::H1handle *hErrs,
                                              base::H2handle *hChHits, base::H2handle *hChErrs,
                                              base::H2handle *hChCorr,
                                              base::H2handle *hQaFine, base::H2handle *hQaToT,
                                              base::H2handle *hQaEdges, base::H2handle *hQaErrors)
         {
            fHldId = id;
            fHitsPerHld = hHits;
            fErrPerHld = hErrs;
            fChHitsPerHld = hChHits;
            fChErrPerHld = hChErrs;
            fChCorrPerHld = hChCorr;
            fQaFinePerHld = hQaFine;
            fQaToTPerHld = hQaToT;
            fQaEdgesPerHld = hQaEdges;
            fQaErrorsPerHld = hQaErrors;
         }
 
         void SetCalibrTrigger(int typ1 = 0xFFFF, unsigned typ2 = 0, unsigned typ3 = 0, unsigned typ4 = 0)
         {
            fCalibrTriggerMask = 0;
            if (typ1<0) return;
            if (typ1 >= 0xFFFF) { fCalibrTriggerMask = 0xFFFF; return; }
            if (typ1 && (typ1<=0xF)) fCalibrTriggerMask |= (1 << typ1);
            if (typ2 && (typ2<=0xF)) fCalibrTriggerMask |= (1 << typ2);
            if (typ3 && (typ3<=0xF)) fCalibrTriggerMask |= (1 << typ3);
            if (typ4 && (typ4<=0xF)) fCalibrTriggerMask |= (1 << typ4);
         }
 
         void SetCalibrTriggerMask(unsigned trigmask)
         {
            fCalibrTriggerMask = trigmask & 0x3FFF;
            fCalibrUseTemp = (trigmask & 0x80000000) != 0;
         }
 
         void SetCalibrTempCoef(float coef)
         {
            fCalibrTempCoef = coef;
         }
 
         void SetChannelTempShift(unsigned ch, float shift_per_grad)
         {
            if (ch < fCh.size()) fCh[ch].time_shift_per_grad = shift_per_grad;
         }
 
         void SetChannelTotShift(unsigned ch, float tot_shift)
         {
            if (ch < fCh.size()) fCh[ch].tot_shift = tot_shift;
         }
 
         void DisableCalibrationFor(unsigned firstch, unsigned lastch = 0);
 
         void SetRefChannel(unsigned ch, unsigned refch, unsigned reftdc = 0xffff, int npoints = 5000, double left = -10., double right = 10., bool twodim = false);
 
 
         void SetRefTmds(unsigned ch, unsigned refch, int npoints, double left, double right);
 
         bool SetDoubleRefChannel(unsigned ch1, unsigned ch2,
                                  int npx = 200, double xmin = -10., double xmax = 10.,
                                  int npy = 200, double ymin = -10., double ymax = 10.);
 
         void CreateRateHisto(int np = 1000, double xmin = 0., double xmax = 1e5);
 
         void SetTotUpperLimit(double lmt = 20) { fTotUpperLimit = lmt; }
 
         double GetTotUpperLimit() const { return fTotUpperLimit; }
 
         bool EnableRefCondPrint(unsigned ch, double left = -10, double right = 10, int numprint = 0);
 
         void SetEveryEpoch(bool on) { fEveryEpoch = on; }
         bool IsEveryEpoch() const { return fEveryEpoch; }
 
         void SetLinearCalibration(unsigned nch, unsigned finemin=30, unsigned finemax=500);
 
         void SetAutoCalibration(long cnt = 100000) { fCalibrCounts = cnt % 1000000000L; fAutoCalibrOnce = (cnt>1000000000L); fAutoCalibr = (cnt >= 0); }
 
         void UseExplicitCalibration() { fAllCalibrMode = 0; }
 
         int GetExplicitCalibrationMode() { return fAllCalibrMode; }
 
         void BeginCalibration(long cnt);
 
         void CompleteCalibration(bool dummy = false, const std::string &filename = "", const std::string &subdir = "");
 
         bool LoadCalibration(const std::string& fprefix);
 
         void SetWriteCalibration(const std::string &fprefix, bool every_time = false, bool use_linear = false)
         {
            fWriteCalibr = fprefix;
            fWriteEveryTime = every_time;
            fUseLinear = use_linear;
         }
 
         void SetUseLinear(bool on = true) { fUseLinear = on; }
 
         bool IsUseLinear() const { return fUseLinear; }
 
         void SetLinearNumPoints(int cnt = 2) { fLinearNumPoints = (cnt < 2) ? 2 : ((cnt > 100) ? 100 : cnt); }
         int GetLinearNumPoints() const { return fLinearNumPoints; }
 
         void SetToTRange(double tot_0xd, double hmin, double hmax);
 
         void ConfigureToTByHwType(unsigned hwtype);
 
         void SetUseLastHit(bool on = true) { fUseLastHit = on; }
 
         bool IsUseLastHist() const { return fUseLastHit; }
 
         const TdcMessage& GetLastTdcHeader() const { return fLastTdcHeader; }
 
         const TdcMessage& GetLastTdcTrailer() const { return fLastTdcTrailer; }
 
         virtual void UserPostLoop();
 
         base::H1handle GetChannelRefHist(unsigned ch, bool = true)
            { return ch < fCh.size() ? fCh[ch].fRisingRef : 0; }
 
         void ClearChannelRefHist(unsigned ch, bool rising = true)
            { ClearH1(GetChannelRefHist(ch, rising)); }
 
         void SetCh0Enabled(bool on = true) { fCh0Enabled = on; }
 
         virtual bool FirstBufferScan(const base::Buffer& buf)
         {
            return fVersion4 ? DoBuffer4Scan(buf, true) : DoBufferScan(buf, true);
         }
 
         virtual bool SecondBufferScan(const base::Buffer& buf)
         {
            return fVersion4 ? DoBuffer4Scan(buf, false) : DoBufferScan(buf, false);
         }
 
         void IncCalibration(unsigned ch, bool rising, unsigned fine, unsigned value);
 
         void ProduceCalibration(bool clear_stat = true, bool use_linear = false, bool dummy = false, bool preliminary = false);
 
         float GetCalibrTemp() const { return fCalibrTemp; }
 
         void SetCalibrTemp(float v) { fCalibrTemp = v; }
 
         void StoreCalibration(const std::string& fname, unsigned fileid = 0);
 
         virtual void Store(base::Event*);
 
         virtual void ResetStore();
 
         unsigned TransformTdcData(hadaqs::RawSubevent* sub, uint32_t *rawdata, unsigned indx, unsigned datalen, hadaqs::RawSubevent* tgt = 0, unsigned tgtindx = 0);
 
         void EmulateTransform(int dummycnt);
 
         void DoHadesHistAnalysis();
 
         void FillToTHistogram();
   };
 
}
 
#endif