PXDHitRateCounter Class Reference

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

#include <PXDHitRateCounter.h>

Inheritance diagram for PXDHitRateCounter:

Collaboration diagram for PXDHitRateCounter:

Classes
struct	TreeStruct
	tree structure More...

Public Member Functions
	PXDHitRateCounter ()
	Constructor.
virtual void	initialize (TTree *tree) override
	Class initializer: set branch addresses and other staf. More...
virtual void	clear () override
	Clear time-stamp buffer to prepare for 'accumulate'.
virtual void	accumulate (unsigned timeStamp) override
	Accumulate hits. More...
virtual void	normalize (unsigned timeStamp) override
	Normalize accumulated hits (e.g. More...

Private Member Functions
const PXD::SensorInfo &	getInfo (VxdID sensorID) const
	Get PXD::SensorInfo.
void	setActivePixels ()
	Sets fractions of active channels.

Private Attributes
double	m_integrationTime = 20 * Unit::us
	Integration time of PXD in ns.
bool	m_maskDeadPixels = true
	Correct bg rates by taking into account masked pixels.
int	m_nPXDSensors = 0
	number of sensors
const double	c_densitySi = 2.3290 * Unit::g_cm3
	Density of crystalline Silicon.
TreeStruct	m_rates
	tree variables
std::map< unsigned, TreeStruct >	m_buffer
	average rates in time stamps
StoreArray< PXDDigit >	m_digits
	collection of digits
StoreArray< PXDCluster >	m_clusters
	collection of clusters
double	m_activePixels [40] = {0}
	number of active pixels in sensor
double	m_activeAreas [40] = {0}
	area of active pixels in sensor
double	m_segmentActivePixels [240] = {0}
	number of active pixels in v segements
double	m_segmentActiveAreas [240] = {0}
	area of active pixels in v segments

Detailed Description

Class for monitoring beam background hit rates of PXD.

Definition at line 43 of file PXDHitRateCounter.h.

Member Function Documentation

accumulate()

void accumulate ( unsigned  timeStamp )

overridevirtual

Accumulate hits.

Parameters

timeStamp

time stamp

Implements HitRateBase.

Definition at line 63 of file PXDHitRateCounter.cc.

    {
      // check if data are available
      if ((not m_digits.isValid()) or (not m_clusters.isValid())) return;
 
      // get buffer element
      auto& rates = m_buffer[timeStamp];
 
      // increment event counter
      rates.numEvents++;
 
      // accumulate hits
      rates.averageRate += m_digits.getEntries();
 
      // Use the same indexing of sensors as for PXDDQM
      auto gTools = VXD::GeoCache::getInstance().getGeoTools();
 
      // accumulate dose rate and event occupancy
      float occupancies[40] = {0};
      for (const PXDDigit& storeDigit : m_digits) {
        VxdID sensorID = storeDigit.getSensorID();
        int index = gTools->getPXDSensorIndex(storeDigit.getSensorID());
        int vBin = PXD::PXDGainCalibrator::getInstance().getBinV(sensorID, storeDigit.getVCellID(), 6);
        double ADUToEnergy =  PXD::PXDGainCalibrator::getInstance().getADUToEnergy(sensorID, storeDigit.getUCellID(),
                              storeDigit.getVCellID());
        double hitEnergy = storeDigit.getCharge() * ADUToEnergy;
        rates.doseRates[index] += (hitEnergy / Unit::J);
        occupancies[index] += 1.0;
        rates.segmentDoseRates[vBin + index * 6] += (hitEnergy / Unit::J);
      }
 
      for (int index = 0; index < m_nPXDSensors; index++) {
        if (m_activePixels[index] > 0) {
          occupancies[index] /= m_activePixels[index];
        }
        rates.meanOccupancies[index] += occupancies[index];
        if (rates.maxOccupancies[index] < occupancies[index]) {
          rates.maxOccupancies[index] = occupancies[index];
        }
      }
 
      // accumulate fluxes
      for (const PXDCluster& cluster : m_clusters) {
        // Update if we have a new sensor
        VxdID sensorID = cluster.getSensorID();
        int index = gTools->getPXDSensorIndex(sensorID);
        auto info = getInfo(sensorID);
 
        auto cluster_uID = info.getUCellID(cluster.getU());
        auto cluster_vID = info.getVCellID(cluster.getV());
        int vBin = PXD::PXDGainCalibrator::getInstance().getBinV(sensorID, cluster_vID, 6);
        double ADUToEnergy =  PXD::PXDGainCalibrator::getInstance().getADUToEnergy(sensorID, cluster_uID, cluster_vID);
        double clusterEnergy = cluster.getCharge() * ADUToEnergy;
 
        if (cluster.getSize() == 1 && clusterEnergy < 10000 * Unit::eV && clusterEnergy > 6000 * Unit::eV) {
          rates.softPhotonFluxes[index] += 1.0;
          rates.segmentSoftPhotonFluxes[vBin + index * 6] += 1.0;
        } else if (cluster.getSize() == 1 && clusterEnergy > 10000 * Unit::eV) {
          rates.hardPhotonFluxes[index] += 1.0;
          rates.segmentHardPhotonFluxes[vBin + index * 6] += 1.0;
        } else if (cluster.getSize() > 1 && clusterEnergy > 10000 * Unit::eV) {
          rates.chargedFluxes[index] += 1.0;
          rates.segmentChargedFluxes[vBin + index * 6] += 1.0;
        }
      }
 
      // set flag to true to indicate the rates are valid
      rates.valid = true;
    }

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 29 of file PXDHitRateCounter.cc.

normalize()

void normalize ( unsigned  timeStamp )

overridevirtual

Normalize accumulated hits (e.g.

transform to rates)

Parameters

timeStamp

time stamp

Implements HitRateBase.

Definition at line 133 of file PXDHitRateCounter.cc.

---

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

• background/modules/BeamBkgHitRateMonitor/include/PXDHitRateCounter.h
• background/modules/BeamBkgHitRateMonitor/src/PXDHitRateCounter.cc