CDCHitRateCounter.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <background/modules/BeamBkgHitRateMonitor/HitRateBase.h>
#include <framework/datastore/StoreArray.h>
#include <cdc/dataobjects/CDCHit.h>
#include <TTree.h>
#include <map>
 
 
namespace Belle2 {
  namespace Background {
 
    class CDCHitRateCounter: public HitRateBase {
 
    private:
      static const int f_nSuperLayer = 9; 
      static const int f_nLayer = 56; 
      static const int f_nPhiDivision = 8; 
    public:
 
      struct TreeStruct {
        float averageRate = 0; 
        float superLayerHitRate[f_nSuperLayer] = {0}; 
        float layerHitRate[f_nLayer] = {0}; 
        float layerPhiHitRate[f_nLayer][f_nPhiDivision] = {{0}}; 
        int   timeWindowForSmallCell  = -1;
        int   timeWindowForNormalCell = -1;
        int   nActiveWireInTotal = 0; 
        int   nActiveWireInSuperLayer[f_nSuperLayer] = {0}; 
        int   nActiveWireInLayer[f_nLayer] = {0}; 
        int   nActiveWireInLayerPhi[f_nLayer][f_nPhiDivision] = {{0}}; 
        int   numEvents = 0; 
        bool  valid = false;  
        TreeStruct()
        {
          for (int i = 0 ; i < f_nLayer ; ++i) {
            for (int j = 0 ; j < f_nPhiDivision ; ++j) {
              layerPhiHitRate[i][j] = 0;
              nActiveWireInLayerPhi[i][j] = 0;
            }
          }
        }
 
        void normalize()
        {
          if (numEvents == 0) return;
          averageRate /= (numEvents * timeWindowForNormalCell * 0.982536 * 1e-6);
 
          for (int iSL = 0 ; iSL < f_nSuperLayer ; ++iSL) {
            if (iSL == 0)
              superLayerHitRate[iSL] /= (numEvents * timeWindowForSmallCell * 0.982536 * 1e-6);
            else
              superLayerHitRate[iSL] /= (numEvents * timeWindowForNormalCell * 0.982536 * 1e-6);
          }
 
          for (int iL = 0 ; iL < f_nLayer ; ++iL) {
            if (iL <= 7) { 
              layerHitRate[iL] /= (numEvents * timeWindowForSmallCell * 0.982536 * 1e-6);
              for (int iPhi = 0 ; iPhi < f_nPhiDivision ; ++iPhi)
                layerPhiHitRate[iL][iPhi] /= (numEvents * timeWindowForSmallCell * 0.982536 * 1e-6);
            } else {
              layerHitRate[iL] /= (numEvents * timeWindowForNormalCell * 0.982536 * 1e-6);
              for (int iPhi = 0 ; iPhi < f_nPhiDivision ; ++iPhi)
                layerPhiHitRate[iL][iPhi] /= (numEvents * timeWindowForNormalCell * 0.982536 * 1e-6);
            }
          }
        }
      };
 
      CDCHitRateCounter(const int  timeWindowLowerEdge_smallCell,
                        const int  timeWindowUpperEdge_smallCell,
                        const int  timeWindowLowerEdge_normalCell,
                        const int  timeWindowUpperEdge_normalCell,
                        const bool enableBadWireTreatment,
                        const bool enableBackgroundHitFilter,
                        const bool enableMarkBackgroundHit):
        m_timeWindowLowerEdge_smallCell(timeWindowLowerEdge_smallCell),
        m_timeWindowUpperEdge_smallCell(timeWindowUpperEdge_smallCell),
        m_timeWindowLowerEdge_normalCell(timeWindowLowerEdge_normalCell),
        m_timeWindowUpperEdge_normalCell(timeWindowUpperEdge_normalCell),
        m_enableBadWireTreatment(enableBadWireTreatment),
        m_enableBackgroundHitFilter(enableBackgroundHitFilter),
        m_enableMarkBackgroundHit(enableMarkBackgroundHit)
      {
        if (m_timeWindowUpperEdge_smallCell  - m_timeWindowLowerEdge_smallCell  <= 0 ||
            m_timeWindowUpperEdge_normalCell - m_timeWindowLowerEdge_normalCell <= 0) {
          B2FATAL("invalid seting of CDC time window");
        }
      }
      virtual void initialize(TTree* tree) override;
 
      virtual void clear() override;
 
      virtual void accumulate(unsigned timeStamp) override;
 
      virtual void normalize(unsigned timeStamp) override;
 
    private:
 
      // class parameters: to be set via constructor or setters
 
      // tree structure
      TreeStruct m_rates; 
      // buffer
      std::map<unsigned, TreeStruct> m_buffer; 
      // collections
      StoreArray<CDCHit> m_digits;  
      const int m_timeWindowLowerEdge_smallCell;  
      const int m_timeWindowUpperEdge_smallCell;  
      const int m_timeWindowLowerEdge_normalCell; 
      const int m_timeWindowUpperEdge_normalCell; 
      bool isInTimeWindow(const int SL, const short tdc)
      {
        if (SL == 0) {
          return (m_timeWindowLowerEdge_smallCell < tdc && tdc <= m_timeWindowUpperEdge_smallCell);
        } else {
          return (m_timeWindowLowerEdge_normalCell < tdc && tdc <= m_timeWindowUpperEdge_normalCell);
        }
      }
 
      // DB payloads
 
      // other
      const bool m_enableBadWireTreatment;    
      const bool m_enableBackgroundHitFilter; 
      const bool
      m_enableMarkBackgroundHit;   
      int m_nActiveWireInTotal =
        0;                             
      int m_nActiveWireInSuperLayer[f_nSuperLayer] = {0};       
      int m_nActiveWireInLayer[f_nLayer] = {0};                 
      int m_nActiveWireInLayerPhi[f_nLayer][f_nPhiDivision] = {{0}}; 
      void countActiveWires_countAll();
 
      void countActiveWires();
 
 
      unsigned short getIPhiBin(unsigned short iSL, unsigned short iWireInLayer);
 
    };
 
  } // Background namespace
} // Belle2 namespace