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

#include <ECLHitRateCounter.h>

Inheritance diagram for ECLHitRateCounter:

Classes
struct	TreeStruct
	tree structure More...

Public Member Functions
	ECLHitRateCounter ()
	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
void	segmentECL ()
	Performs ECL segmentation; Done once per run; Populates a map which connects each ECL crystal with a segment number (0-15); Segments 0-3 are in the forward endcap, 4-7 are in the barrel with z<0, 8-11 are in the barrel with z>0, 12-15 are in the backward endcap; Segment 0 contains crystals with 45deg < phi < 135deg, Segment 1 contains crystals with 135deg < phi < 225deg, Segment 2 contains crystals with 225deg < phi < 315deg, Segment 3 contains crystals with phi < 45deg or phi > 315deg, With the same angular patter continuing for barrel and BWD encap segments.

int	findECLSegment (int cellid)
	Find the correcsponding ECL segment based on the cellID.

void	findElectronicsNoise ()
	Find the electronics noise correction for each cellID Reads a file with a histogram containing electronics noise level of each crystal.

Private Attributes
TreeStruct	m_rates
	tree variables

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

StoreArray< ECLDigit >	m_digits
	collection of digits

StoreArray< ECLDsp >	m_dsps
	collection of ECL waveforms

std::vector< float >	m_ADCtoEnergy
	vector used to store ECL calibration constants for each crystal

std::vector< float >	m_waveformNoise
	vector used to store ECL electronic noise constants foe each crystal

Belle2::ECL::ECLGeometryPar *	m_geometry {nullptr}
	pointer to ECLGeometryPar

std::map< int, int >	m_segmentMap
	map with keys containing ECL CellID and values containing segment number

int	m_crystalsInSegment [16] = {0}
	array cotaining the number of crystals in given segment

Detailed Description

Class for monitoring beam background hit rates of ECL.

Definition at line 28 of file ECLHitRateCounter.h.

Constructor & Destructor Documentation

◆ ECLHitRateCounter()

ECLHitRateCounter ( )

inline

Constructor.

Definition at line 59 of file ECLHitRateCounter.h.

60 {}

Member Function Documentation

◆ accumulate()

void accumulate ( unsigned timeStamp )

overridevirtual

Accumulate hits.

Parameters

timeStamp time stamp

Implements HitRateBase.

Definition at line 52 of file ECLHitRateCounter.cc.

    {
      // check if data are available
      if (not m_dsps.isValid()) return;
 
      //calculate rates using waveforms
      //The background rate for a crystal is calculated as
      //rate = rms_pedestal_squared / (average_photon_energy_squared * time_constant)
      //where time_constant=2.53 us and average_photon_energy_squared = 1 MeV
      if (m_dsps.getEntries() == 8736) {
 
        // get buffer element
        auto& rates = m_buffer[timeStamp];
 
        // increment event counter
        rates.numEvents++;
 
        for (auto& aECLDsp : m_dsps) {
 
          int nadc = aECLDsp.getNADCPoints();
          int cellID = aECLDsp.getCellId();
          int segmentNumber = findECLSegment(cellID);
          int crysID = cellID - 1;
          std::vector<int> dspAv = aECLDsp.getDspA();
 
          //finding the pedestal value
          double dspMean = (std::accumulate(dspAv.begin(), dspAv.begin() + nadc, 0.0)) / nadc;
          double wpsum = 0;
          for (int v = 0; v < nadc; v++) {
            wpsum += pow(dspAv[v] - dspMean, 2);
          }
          double dspRMS = sqrt(wpsum / nadc);
          double dspSigma = dspRMS * abs(m_ADCtoEnergy[crysID]);
 
          //calculating the background rate per second
          double dspBkgRate = ((pow(dspSigma, 2)) - (pow(m_waveformNoise[crysID], 2))) / (2.53 * 1e-12);
          if (dspBkgRate < 0) {
            dspBkgRate = 0;
          }
 
          //hit rate for segment in ECL, which is later normalized per 1Hz
          rates.averageDspBkgRate[segmentNumber] += dspBkgRate;
 
        }
 
        // set flag to true to indicate the rates are valid
        rates.validDspRate = true;
      }
    }

◆ clear()

void clear ( )

overridevirtual

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

Implements HitRateBase.

Definition at line 47 of file ECLHitRateCounter.cc.

    {
      m_buffer.clear();
    }

◆ findECLSegment()

int findECLSegment ( int cellid )

inlineprivate

Find the correcsponding ECL segment based on the cellID.

Parameters

cellid ECL crystal CellID

Definition at line 108 of file ECLHitRateCounter.h.

      {
        return m_segmentMap.find(cellid)->second;
      }

◆ 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 28 of file ECLHitRateCounter.cc.

    {
      segmentECL();
      // register collection(s) as optional, your detector might be excluded in DAQ
      m_dsps.isOptional();
 
      // set branch address
      tree->Branch("ecl", &m_rates, "averageDspBkgRate[16]/F:numEvents/I:validDspRate/O");
 
      //ECL calibration
      DBObjPtr<ECLCrystalCalib> ECLElectronicsCalib("ECLCrystalElectronics"), ECLECalib("ECLCrystalEnergy"),
               ECLWaveformNoise("ECLWaveformRMS");
      m_ADCtoEnergy.resize(8736);
      if (ECLElectronicsCalib) for (int i = 0; i < 8736; i++) m_ADCtoEnergy[i] = ECLElectronicsCalib->getCalibVector()[i];
      if (ECLECalib) for (int i = 0; i < 8736; i++) m_ADCtoEnergy[i] *= ECLECalib->getCalibVector()[i];
      m_waveformNoise.resize(8736);
      if (ECLWaveformNoise) for (int i = 0; i < 8736; i++) m_waveformNoise[i] = ECLWaveformNoise->getCalibVector()[i];
    }

◆ normalize()

void normalize ( unsigned timeStamp )

overridevirtual

Normalize accumulated hits (e.g.

transform to rates)

Parameters

timeStamp time stamp

Implements HitRateBase.

Definition at line 102 of file ECLHitRateCounter.cc.

    {
      // copy buffer element
      m_rates = m_buffer[timeStamp];
 
      if (not m_rates.validDspRate) return;
 
      // normalize
      m_rates.normalize();
 
      //get average ret per crystal in segment
      for (int i = 0; i < 16; i++) {
        m_rates.averageDspBkgRate[i] /= m_crystalsInSegment[i];
      }
    }

◆ segmentECL()

void segmentECL ( )

private

Performs ECL segmentation; Done once per run; Populates a map which connects each ECL crystal with a segment number (0-15); Segments 0-3 are in the forward endcap, 4-7 are in the barrel with z<0, 8-11 are in the barrel with z>0, 12-15 are in the backward endcap; Segment 0 contains crystals with 45deg < phi < 135deg, Segment 1 contains crystals with 135deg < phi < 225deg, Segment 2 contains crystals with 225deg < phi < 315deg, Segment 3 contains crystals with phi < 45deg or phi > 315deg, With the same angular patter continuing for barrel and BWD encap segments.

Definition at line 119 of file ECLHitRateCounter.cc.

    {
      m_geometry = Belle2::ECL::ECLGeometryPar::Instance();
      for (int cid = 1; cid < 8737; cid++) {
        m_geometry->Mapping(cid);
        const B2Vector3D position = m_geometry->GetCrystalPos(cid - 1);
        const double phi = position.Phi();
        const double z = position.Z();
 
        if (cid < 1297) {
          if (phi > 0.7853 && phi < 2.356) {
            m_segmentMap.insert(std::pair<int, int>(cid, 0));
            m_crystalsInSegment[0] += 1;
          } else if (phi >= 2.356 || phi <= -2.356) {
            m_segmentMap.insert(std::pair<int, int>(cid, 1));
            m_crystalsInSegment[1] += 1;
          } else if (phi > -2.356 && phi < -0.7853) {
            m_segmentMap.insert(std::pair<int, int>(cid, 2));
            m_crystalsInSegment[2] += 1;
          } else {
            m_segmentMap.insert(std::pair<int, int>(cid, 3));
            m_crystalsInSegment[3] += 1;
          }
        } else if (cid < 7777) {
          if (z > 0) {
            if (phi > 0.7853 && phi < 2.356) {
              m_segmentMap.insert(std::pair<int, int>(cid, 4));
              m_crystalsInSegment[4] += 1;
            } else if (phi >= 2.356 || phi <= -2.356) {
              m_segmentMap.insert(std::pair<int, int>(cid, 5));
              m_crystalsInSegment[5] += 1;
            } else if (phi > -2.356 && phi < -0.7853) {
              m_segmentMap.insert(std::pair<int, int>(cid, 6));
              m_crystalsInSegment[6] += 1;
            } else {
              m_segmentMap.insert(std::pair<int, int>(cid, 7));
              m_crystalsInSegment[7] += 1;
            }
          } else {
            if (phi > 0.7853 && phi < 2.356) {
              m_segmentMap.insert(std::pair<int, int>(cid, 8));
              m_crystalsInSegment[8] += 1;
            } else if (phi >= 2.356 || phi <= -2.356) {
              m_segmentMap.insert(std::pair<int, int>(cid, 9));
              m_crystalsInSegment[9] += 1;
            } else if (phi > -2.356 && phi < -0.7853) {
              m_segmentMap.insert(std::pair<int, int>(cid, 10));
              m_crystalsInSegment[10] += 1;
            } else {
              m_segmentMap.insert(std::pair<int, int>(cid, 11));
              m_crystalsInSegment[11] += 1;
            }
          }
        } else {
          if (phi > 0.7853 && phi < 2.356) {
            m_segmentMap.insert(std::pair<int, int>(cid, 12));
            m_crystalsInSegment[12] += 1;
          } else if (phi >= 2.356 || phi <= -2.356) {
            m_segmentMap.insert(std::pair<int, int>(cid, 13));
            m_crystalsInSegment[13] += 1;
          } else if (phi > -2.356 && phi < -0.7853) {
            m_segmentMap.insert(std::pair<int, int>(cid, 14));
            m_crystalsInSegment[14] += 1;
          } else {
            m_segmentMap.insert(std::pair<int, int>(cid, 15));
            m_crystalsInSegment[15] += 1;
          }
        }
      }
    }

Member Data Documentation

◆ m_ADCtoEnergy

std::vector<float> m_ADCtoEnergy

private

vector used to store ECL calibration constants for each crystal

Definition at line 129 of file ECLHitRateCounter.h.

◆ m_buffer

std::map<unsigned, TreeStruct> m_buffer

private

average rates in time stamps

Definition at line 123 of file ECLHitRateCounter.h.

◆ m_crystalsInSegment

int m_crystalsInSegment[16] = {0}

private

array cotaining the number of crystals in given segment

Definition at line 135 of file ECLHitRateCounter.h.

◆ m_digits

StoreArray<ECLDigit> m_digits

private

collection of digits

Definition at line 126 of file ECLHitRateCounter.h.

◆ m_dsps

StoreArray<ECLDsp> m_dsps

private

collection of ECL waveforms

Definition at line 127 of file ECLHitRateCounter.h.

◆ m_geometry

Belle2::ECL::ECLGeometryPar* m_geometry {nullptr}

private

pointer to ECLGeometryPar

Definition at line 133 of file ECLHitRateCounter.h.

◆ m_rates

TreeStruct m_rates

private

tree variables

Definition at line 120 of file ECLHitRateCounter.h.

◆ m_segmentMap

std::map<int, int> m_segmentMap

private

map with keys containing ECL CellID and values containing segment number

Definition at line 134 of file ECLHitRateCounter.h.

◆ m_waveformNoise

std::vector<float> m_waveformNoise

private

vector used to store ECL electronic noise constants foe each crystal

Definition at line 130 of file ECLHitRateCounter.h.

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

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ECLHitRateCounter()

Member Function Documentation

◆ accumulate()

◆ clear()

◆ findECLSegment()

◆ initialize()

◆ normalize()

◆ segmentECL()

Member Data Documentation

◆ m_ADCtoEnergy

◆ m_buffer

◆ m_crystalsInSegment

◆ m_digits

◆ m_dsps

◆ m_geometry

◆ m_rates

◆ m_segmentMap

◆ m_waveformNoise