CDCHitRateCounter.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2019 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Marko Staric                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#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_nLayer = 56; 
      static const int f_nSuperLayer = 9; 
    public:
 
      struct TreeStruct {
        float layerHitRate[f_nLayer] = {0}; 
        float superLayerHitRate[f_nSuperLayer] = {0}; 
        float averageRate = 0; 
        int   timeWindowForSmallCell  = -1;
        int   timeWindowForNormalCell = -1;
        int   nActiveWireInLayer[f_nLayer] = {0}; 
        int   nActiveWireInSuperLayer[f_nSuperLayer] = {0}; 
        int   nActiveWireInTotal = 0; 
        int   numEvents = 0; 
        bool  valid = false;  
        void normalize()
        {
          if (numEvents == 0) return;
          averageRate /= (numEvents * timeWindowForNormalCell * 1e-6);
 
          for (int iSL = 0 ; iSL < f_nSuperLayer ; ++iSL) {
            if (iSL == 0)
              superLayerHitRate[iSL] /= (numEvents * timeWindowForSmallCell * 1e-6);
            else
              superLayerHitRate[iSL] /= (numEvents * timeWindowForNormalCell * 1e-6);
          }
 
          for (int iL = 0 ; iL < f_nLayer ; ++iL) {
            if (iL <= 7) 
              layerHitRate[iL] /= (numEvents * timeWindowForSmallCell * 1e-6);
            else
              layerHitRate[iL] /= (numEvents * timeWindowForNormalCell * 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};           
      void countActiveWires_countAll();
 
      void countActiveWires();
 
 
    };
 
  } // Background namespace
} // Belle2 namespace