Class for monitoring beam background hit rates of CDC. More...

#include <CDCHitRateCounter.h>

Inheritance diagram for CDCHitRateCounter:

Classes
struct	TreeStruct
	tree structure More...

Public Member Functions
	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)
	Constructor.

virtual void	initialize (TTree *tree) override
	Class initializer: set branch addresses and other staf.

virtual void	clear () override
	Clear time-stamp buffer to prepare for 'accumulate'.

virtual void	accumulate (unsigned timeStamp) override
	Accumulate hits.

virtual void	normalize (unsigned timeStamp) override
	Normalize accumulated hits (e.g.

Private Member Functions
bool	isInTimeWindow (const int SL, const short tdc)
	return true if the hit is in the given time window

void	countActiveWires_countAll ()
	set m_nActiveWireInTotal, m_nActiveWireInLayer[] and m_nActiveWireInSuperLayer[].

void	countActiveWires ()
	set m_nActiveWireInTotal, m_nActiveWireInLayer[] and m_nActiveWireInSuperLayer[].

unsigned short	getIPhiBin (unsigned short iSL, unsigned short iWireInLayer)
	get the bin ID of the division.

Private Attributes
TreeStruct	m_rates
	tree variables

std::map< unsigned, TreeStruct >	m_buffer
	average rates in time stamps

StoreArray< CDCHit >	m_digits
	collection of digits

const int	m_timeWindowLowerEdge_smallCell
	lower edge of the time window for small cells [tdc count = 0.982536 ns]

const int	m_timeWindowUpperEdge_smallCell
	upper edge of the time window for small cells [tdc count = 0.982536 ns]

const int	m_timeWindowLowerEdge_normalCell
	lower edge of the time window for normal cells [tdc count = 0.982536 ns]

const int	m_timeWindowUpperEdge_normalCell
	upper edge of the time window for normal cells [tdc count = 0.982536 ns]

const bool	m_enableBadWireTreatment
	flag to enable the bad wire treatment.

const bool	m_enableBackgroundHitFilter
	flag to enable the CDC background hit (crosstakl, noise) filter.

const bool	m_enableMarkBackgroundHit
	flag to enable to mark background flag on CDCHit (set 0x100 bit for CDCHit::m_status).

int	m_nActiveWireInTotal
	the number of wires used in this hit-rate calculation in the whole CDC

int	m_nActiveWireInSuperLayer [f_nSuperLayer] = {0}
	the number of wires used in this hit-rate calculation in each suler layer

int	m_nActiveWireInLayer [f_nLayer] = {0}
	the number of wires used in this hit-rate calculation in each layer

int	m_nActiveWireInLayerPhi [f_nLayer][f_nPhiDivision] = {{0}}
	the number of wires used in this hit-rate calculation in each phi bin in each layer

Static Private Attributes
static const int	f_nSuperLayer = 9
	the number of super layers

static const int	f_nLayer = 56
	the number of layers

static const int	f_nPhiDivision = 8
	the number of division in phi

Detailed Description

Class for monitoring beam background hit rates of CDC.

Definition at line 28 of file CDCHitRateCounter.h.

Constructor & Destructor Documentation

◆ CDCHitRateCounter()

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
	)

inline

Constructor.

Parameters

timeWindowLowerEdge_smallCell	lower edge of the timing window for the layers with small cells (SL0)
timeWindowUpperEdge_smallCell	upper edge of the timing window for the layers with small cells (SL0)
timeWindowLowerEdge_normalCell	lower edge of the timing window for the layers with normal cells (SL1-8)
timeWindowUpperEdge_normalCell	upper edge of the timing window for the layers with normal cells (SL1-8)
enableBadWireTreatment	flag to enable the bad wire treatment. default: true
enableBackgroundHitFilter	flag to enable the CDC background hit (crosstakl, noise) filter. default: true
enableMarkBackgroundHit	flag to enable to mark background flag on CDCHit (set 0x100 bit for CDCHit::m_status). default: false

Definition at line 108 of file CDCHitRateCounter.h.

                                                           :
        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 setting of CDC time window");
        }
      }

Member Function Documentation

◆ accumulate()

void accumulate ( unsigned timeStamp )

overridevirtual

Accumulate hits.

Parameters

timeStamp time stamp

Implements HitRateBase.

Definition at line 69 of file CDCHitRateCounter.cc.

    {
      // check if data are available
      if (not m_digits.isValid()) return;
 
      // get buffer element
      auto& rates = m_buffer[timeStamp];
 
      // increment event counter
      rates.numEvents++;
 
      std::map<const CDCHit*, bool> CDCHitToBackgroundFlag;
      if (m_enableBackgroundHitFilter) {
        StoreWrappedObjPtr<std::vector<CDCWireHit>> storeVector("CDCWireHitVector");
        if (not storeVector) {
          B2FATAL("CDCWireHitVector is unaccessible in DataStore."
                  "Need TFCDC_WireHitParameter module before.");
        }
        const std::vector<CDCWireHit>& cdcWireHitVector = *storeVector;
        for (const auto& cdcWireHit : cdcWireHitVector) {
          const CDCHit* cdcHit = cdcWireHit.getHit();
          CDCHitToBackgroundFlag[cdcHit] = cdcWireHit->hasBackgroundFlag(); 
        }
      }
 
      CDC::CDCGeometryPar& geometryPar = CDC::CDCGeometryPar::Instance();
 
      for (CDCHit& hit : m_digits) {
        const WireID wireID(hit.getID());
        if (m_enableBadWireTreatment && geometryPar.isBadWire(wireID))
          continue;
 
        const unsigned short iSuperLayer  = hit.getISuperLayer();
        const unsigned short iLayer       = hit.getICLayer();
        const unsigned short iWireInLayer = hit.getIWire();
        const unsigned short iPhiBin      = getIPhiBin(iSuperLayer, iWireInLayer);
        const unsigned short adc = hit.getADCCount();
        const short tdc          = hit.getTDCCount();
 
        if (m_enableBackgroundHitFilter) {
          if (CDCHitToBackgroundFlag[&hit]) {
            if (m_enableMarkBackgroundHit) {
              unsigned short newStatus = (hit.getStatus() | 0x100);
              hit.setStatus(newStatus);
            }
            continue;
          }
        } else {
          if (iSuperLayer == 0 && adc < 15)
            continue;
          if (iSuperLayer != 0 && adc < 18)
            continue;
        }
 
        if (not isInTimeWindow(iSuperLayer, tdc))
          continue;
 
 
        rates.averageRate += 1;
        rates.superLayerHitRate[iSuperLayer] += 1;
        rates.layerHitRate[iLayer] += 1;
        rates.layerPhiHitRate[iLayer][iPhiBin] += 1;
      }
 
      // set flag to true to indicate the rates are valid
      rates.valid = true;
    }

◆ clear()

void clear ( )

overridevirtual

Clear time-stamp buffer to prepare for 'accumulate'.

Implements HitRateBase.

Definition at line 64 of file CDCHitRateCounter.cc.

    {
      m_buffer.clear();
    }

◆ countActiveWires()

void countActiveWires ( )

private

set m_nActiveWireInTotal, m_nActiveWireInLayer[] and m_nActiveWireInSuperLayer[].

called in initialize function. count the number of wires excluding dead wires (bad channels).

end i loop

end iL loop

end iSL loop

Definition at line 228 of file CDCHitRateCounter.cc.

    {
      static const unsigned short nlayer_in_SL[f_nSuperLayer] = { 8, 6, 6,
                                                                  6, 6, 6,
                                                                  6, 6, 6
                                                                };
      static const unsigned short nwire_in_layer[f_nSuperLayer] = { 160, 160, 192,
                                                                    224, 256, 288,
                                                                    320, 352, 384
                                                                  };
 
      CDC::CDCGeometryPar& geometryPar = CDC::CDCGeometryPar::Instance();
 
      m_nActiveWireInTotal = 0; 
      int contLayerID = 0;
 
      for (int iSL = 0 ; iSL < f_nSuperLayer ; ++iSL) {
        m_nActiveWireInSuperLayer[iSL] = 0; 
        for (int iL = 0 ; iL < nlayer_in_SL[iSL] ; ++iL) { 
          m_nActiveWireInLayer[contLayerID] = 0;
          for (int iPhi = 0 ; iPhi < f_nPhiDivision ; ++iPhi)
            m_nActiveWireInLayerPhi[contLayerID][iPhi] = 0;
 
          for (int i = 0 ; i < nwire_in_layer[iSL] ; ++i) {
            WireID wireID(iSL, iL, i);
            if (not geometryPar.isBadWire(wireID)) {
              ++m_nActiveWireInLayerPhi[contLayerID][getIPhiBin(iSL, i)];
              ++m_nActiveWireInLayer[contLayerID];
            }
          }
          m_nActiveWireInSuperLayer[iSL] += m_nActiveWireInLayer[contLayerID];
          ++contLayerID;
        }
        m_nActiveWireInTotal += m_nActiveWireInSuperLayer[iSL];
      }
 
 
      //B2INFO("CDC, # of Active wires / # of total wires");
      std::cout << "CDC, # of Active wires / # of total wires" << std::endl;
      int contLayerID_2 = 0;
      for (int iSL = 0 ; iSL < f_nSuperLayer ; ++iSL) {
        for (int iL = 0 ; iL < nlayer_in_SL[iSL] ; ++iL) {
          //B2INFO("Layer "<< contLayerID_2 << ": "
          std::cout << "Layer " << contLayerID_2 << ": "
                    << m_nActiveWireInLayer[contLayerID_2] << " / "
                    //<< nwire_in_layer[iSL] );
                    << nwire_in_layer[iSL] << std::endl;
          ++contLayerID_2;
        }
      }
 
    }

◆ countActiveWires_countAll()

void countActiveWires_countAll ( )

private

set m_nActiveWireInTotal, m_nActiveWireInLayer[] and m_nActiveWireInSuperLayer[].

called in initialize function. count the number of all the wires including dead wires (bad channels).

Definition at line 200 of file CDCHitRateCounter.cc.

    {
      static const unsigned short nlayer_in_SL[f_nSuperLayer] = { 8, 6, 6,
                                                                  6, 6, 6,
                                                                  6, 6, 6
                                                                };
      static const unsigned short nwire_in_layer[f_nSuperLayer] = { 160, 160, 192,
                                                                    224, 256, 288,
                                                                    320, 352, 384
                                                                  };
 
      m_nActiveWireInTotal = 0; 
      int contLayerID = 0;
      for (int iSL = 0 ; iSL < f_nSuperLayer ; ++iSL) {
        m_nActiveWireInSuperLayer[iSL] = 0; 
        for (int i = 0 ; i < nlayer_in_SL[iSL] ; ++i) {
          m_nActiveWireInTotal             += nwire_in_layer[iSL];
          m_nActiveWireInSuperLayer[iSL]   += nwire_in_layer[iSL];
          m_nActiveWireInLayer[contLayerID] = nwire_in_layer[iSL];
          for (int j = 0 ; j < f_nPhiDivision ; ++j)
            m_nActiveWireInLayerPhi[contLayerID][j] = nwire_in_layer[iSL] / f_nPhiDivision;
          ++contLayerID;
        }
      }
    }

◆ getIPhiBin()

unsigned short getIPhiBin	(	unsigned short	iSL,
		unsigned short	iWireInLayer
	)

private

get the bin ID of the division.

Definition at line 282 of file CDCHitRateCounter.cc.

    {
      static const unsigned short nwire_in_layer[f_nSuperLayer] = { 160, 160, 192,
                                                                    224, 256, 288,
                                                                    320, 352, 384
                                                                  };
      return iWireInLayer / (nwire_in_layer[iSL] / f_nPhiDivision);
    }

◆ initialize()

void initialize ( TTree * tree )

overridevirtual

Class initializer: set branch addresses and other staf.

Parameters

tree	a valid TTree pointer

Implements HitRateBase.

Definition at line 34 of file CDCHitRateCounter.cc.

    {
      // register collection(s) as optional, your detector might be excluded in DAQ
      m_digits.isOptional();
 
      // set branch address
      //tree->Branch("cdc", &m_rates, "averageRate/F:numEvents/I:valid/O");
      stringstream leafList;
      leafList
          << "averageRate/F:"
          << "superLayerHitRate[" << f_nSuperLayer << "]/F:"
          << "layerHitRate[" << f_nLayer << "]/F:"
          << "layerPhiHitRate[" << f_nLayer << "][" << f_nPhiDivision << "]/F:"
          << "timeWindowForSmallCell/I:"
          << "timeWindowForNormalCell/I:"
          << "nActiveWireInTotal/I:"
          << "nActiveWireInSuperLayer[" << f_nSuperLayer << "]/I:"
          << "nActiveWireInLayer[" << f_nLayer << "]/I:"
          << "nActiveWireInLayerPhi[" << f_nLayer << "][" << f_nPhiDivision << "]/I:"
          << "numEvents/I:"
          << "valid/O";
      tree->Branch("cdc", &m_rates, leafList.str().c_str());
 
      if (m_enableBadWireTreatment) {
        countActiveWires();
      } else {
        countActiveWires_countAll();
      }
    }

◆ isInTimeWindow()

bool isInTimeWindow	(	const int	SL,
		const short	tdc
	)

inlineprivate

return true if the hit is in the given time window

Parameters

SL	super layer ID which the wire of the hit belongs to
tdc	TDC value of the hit

Definition at line 175 of file CDCHitRateCounter.h.

      {
        if (SL == 0) {
          return (m_timeWindowLowerEdge_smallCell < tdc && tdc <= m_timeWindowUpperEdge_smallCell);
        } else {
          return (m_timeWindowLowerEdge_normalCell < tdc && tdc <= m_timeWindowUpperEdge_normalCell);
        }
      }

◆ normalize()

void normalize ( unsigned timeStamp )

overridevirtual

Normalize accumulated hits (e.g.

transform to rates)

Parameters

timeStamp time stamp

copy nActiveWire

Implements HitRateBase.

Definition at line 145 of file CDCHitRateCounter.cc.

    {
      // copy buffer element
      m_rates = m_buffer[timeStamp];
 
      if (not m_rates.valid) return;
 
      m_rates.timeWindowForSmallCell  = m_timeWindowUpperEdge_smallCell  - m_timeWindowLowerEdge_smallCell;
      m_rates.timeWindowForNormalCell = m_timeWindowUpperEdge_normalCell - m_timeWindowLowerEdge_normalCell;
 
      // normalize : hit rate in the time stamp in kHz
      m_rates.normalize();
 
      if (m_nActiveWireInTotal == 0) {
        m_rates.averageRate = 0;
      } else {
        m_rates.averageRate /= m_nActiveWireInTotal;
      }
      for (int iSL = 0 ; iSL < f_nSuperLayer ; ++iSL)
        if (m_nActiveWireInSuperLayer[iSL] == 0) {
          m_rates.superLayerHitRate[iSL] = 0;
        } else {
          m_rates.superLayerHitRate[iSL] /= m_nActiveWireInSuperLayer[iSL];
        }
      for (int iLayer = 0 ; iLayer < f_nLayer ; ++iLayer)
        if (m_nActiveWireInLayer[iLayer] == 0) {
          m_rates.layerHitRate[iLayer] = 0;
        } else {
          m_rates.layerHitRate[iLayer] /= m_nActiveWireInLayer[iLayer];
        }
      for (int iLayer = 0 ; iLayer < f_nLayer ; ++iLayer)
        for (int iPhi = 0 ; iPhi < f_nPhiDivision ; ++iPhi)
          if (m_nActiveWireInLayerPhi[iLayer][iPhi] == 0) {
            m_rates.layerPhiHitRate[iLayer][iPhi] = 0;
          } else {
            m_rates.layerPhiHitRate[iLayer][iPhi] /= m_nActiveWireInLayerPhi[iLayer][iPhi];
          }
 
      m_rates.nActiveWireInTotal = m_nActiveWireInTotal;
      for (int i = 0 ; i < f_nSuperLayer ; ++i)
        m_rates.nActiveWireInSuperLayer[i] = m_nActiveWireInSuperLayer[i];
      for (int i = 0 ; i < f_nLayer ; ++i)
        m_rates.nActiveWireInLayer[i] = m_nActiveWireInLayer[i];
      for (int i = 0 ; i < f_nLayer ; ++i)
        for (int j = 0 ; j < f_nPhiDivision ; ++j)
          m_rates.nActiveWireInLayerPhi[i][j] = m_nActiveWireInLayerPhi[i][j];
    }

Member Data Documentation

◆ f_nLayer

const int f_nLayer = 56

staticprivate

the number of layers

Definition at line 32 of file CDCHitRateCounter.h.

◆ f_nPhiDivision

const int f_nPhiDivision = 8

staticprivate

the number of division in phi

Definition at line 33 of file CDCHitRateCounter.h.

◆ f_nSuperLayer

const int f_nSuperLayer = 9

staticprivate

the number of super layers

Definition at line 31 of file CDCHitRateCounter.h.

◆ m_buffer

std::map<unsigned, TreeStruct> m_buffer

private

average rates in time stamps

Definition at line 159 of file CDCHitRateCounter.h.

◆ m_digits

StoreArray<CDCHit> m_digits

private

collection of digits

Definition at line 162 of file CDCHitRateCounter.h.

◆ m_enableBackgroundHitFilter

const bool m_enableBackgroundHitFilter

private

flag to enable the CDC background hit (crosstakl, noise) filter.

default: true

Definition at line 188 of file CDCHitRateCounter.h.

◆ m_enableBadWireTreatment

const bool m_enableBadWireTreatment

private

flag to enable the bad wire treatment.

default: true

Definition at line 187 of file CDCHitRateCounter.h.

◆ m_enableMarkBackgroundHit

const bool m_enableMarkBackgroundHit

private

flag to enable to mark background flag on CDCHit (set 0x100 bit for CDCHit::m_status).

default: false

Definition at line 190 of file CDCHitRateCounter.h.

◆ m_nActiveWireInLayer

int m_nActiveWireInLayer[f_nLayer] = {0}

private

the number of wires used in this hit-rate calculation in each layer

Definition at line 195 of file CDCHitRateCounter.h.

◆ m_nActiveWireInLayerPhi

int m_nActiveWireInLayerPhi[f_nLayer][f_nPhiDivision] = {{0}}

private

the number of wires used in this hit-rate calculation in each phi bin in each layer

Definition at line 196 of file CDCHitRateCounter.h.

◆ m_nActiveWireInSuperLayer

int m_nActiveWireInSuperLayer[f_nSuperLayer] = {0}

private

the number of wires used in this hit-rate calculation in each suler layer

Definition at line 194 of file CDCHitRateCounter.h.

◆ m_nActiveWireInTotal

int m_nActiveWireInTotal

private

Initial value:

=

0

the number of wires used in this hit-rate calculation in the whole CDC

Definition at line 192 of file CDCHitRateCounter.h.

◆ m_rates

TreeStruct m_rates

private

tree variables

Definition at line 156 of file CDCHitRateCounter.h.

◆ m_timeWindowLowerEdge_normalCell

const int m_timeWindowLowerEdge_normalCell

private

lower edge of the time window for normal cells [tdc count = 0.982536 ns]

Definition at line 167 of file CDCHitRateCounter.h.

◆ m_timeWindowLowerEdge_smallCell

const int m_timeWindowLowerEdge_smallCell

private

lower edge of the time window for small cells [tdc count = 0.982536 ns]

Definition at line 165 of file CDCHitRateCounter.h.

◆ m_timeWindowUpperEdge_normalCell

const int m_timeWindowUpperEdge_normalCell

private

upper edge of the time window for normal cells [tdc count = 0.982536 ns]

Definition at line 168 of file CDCHitRateCounter.h.

◆ m_timeWindowUpperEdge_smallCell

const int m_timeWindowUpperEdge_smallCell

private

upper edge of the time window for small cells [tdc count = 0.982536 ns]

Definition at line 166 of file CDCHitRateCounter.h.

The documentation for this class was generated from the following files:

background/modules/BeamBkgHitRateMonitor/include/CDCHitRateCounter.h
background/modules/BeamBkgHitRateMonitor/src/CDCHitRateCounter.cc

Classes

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CDCHitRateCounter()

Member Function Documentation

◆ accumulate()

◆ clear()

◆ countActiveWires()

◆ countActiveWires_countAll()

◆ getIPhiBin()

◆ initialize()

◆ isInTimeWindow()

◆ normalize()

Member Data Documentation

◆ f_nLayer

◆ f_nPhiDivision

◆ f_nSuperLayer

◆ m_buffer

◆ m_digits

◆ m_enableBackgroundHitFilter

◆ m_enableBadWireTreatment

◆ m_enableMarkBackgroundHit

◆ m_nActiveWireInLayer

◆ m_nActiveWireInLayerPhi

◆ m_nActiveWireInSuperLayer

◆ m_nActiveWireInTotal

◆ m_rates

◆ m_timeWindowLowerEdge_normalCell

◆ m_timeWindowLowerEdge_smallCell

◆ m_timeWindowUpperEdge_normalCell

◆ m_timeWindowUpperEdge_smallCell