PXDHitRateCounter Class Reference

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

#include <PXDHitRateCounter.h>

Inheritance 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.
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
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 33 of file PXDHitRateCounter.h.

Constructor & Destructor Documentation

PXDHitRateCounter()

PXDHitRateCounter ( )

inline

Constructor.

Definition at line 59 of file PXDHitRateCounter.h.

      {}

Member Function Documentation

accumulate()

void accumulate ( unsigned  timeStamp )

overridevirtual

Accumulate hits.

Parameters

timeStamp

time stamp

Implements HitRateBase.

Definition at line 61 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;
    }

clear()

void clear ( )

overridevirtual

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

Implements HitRateBase.

Definition at line 56 of file PXDHitRateCounter.cc.

    {
      m_buffer.clear();
    }

getInfo()

const PXD::SensorInfo & getInfo ( VxdID  sensorID ) const

inlineprivate

Get PXD::SensorInfo.

Definition at line 121 of file PXDHitRateCounter.h.

    {
      return dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::getInstance().getSensorInfo(sensorID));
    }

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

    {
      //Pointer to GeoTools instance
      auto gTools = VXD::GeoCache::getInstance().getGeoTools();
      if (gTools->getNumberOfPXDLayers() == 0) {
        B2FATAL("Missing geometry for PXD.");
      }
 
      m_nPXDSensors = gTools->getNumberOfPXDSensors();
 
      // register collection(s) as optional, your detector might be excluded in DAQ
      m_digits.isOptional();
 
      // register collection(s) as optional, your detector might be excluded in DAQ
      m_clusters.isOptional();
 
      string leaflist =
        "meanOccupancies[40]/F:maxOccupancies[40]/F:doseRates[40]/F:softPhotonFluxes[40]/F:hardPhotonFluxes[40]/F:chargedFluxes[40]/F:segmentDoseRates[240]/F:segmentSoftPhotonFluxes[240]/F:segmentHardPhotonFluxes[240]/F:segmentChargedFluxes[240]/F:averageRate/F:numEvents/I:valid/O";
 
      // set branch address
      tree->Branch("pxd", &m_rates, leaflist.c_str());
 
      // check parameters
      if (m_integrationTime <= 0) B2FATAL("invalid integration time window for PXD: " << m_integrationTime);
 
      // set fractions of active channels
      setActivePixels();
    }

normalize()

void normalize ( unsigned  timeStamp )

overridevirtual

Normalize accumulated hits (e.g.

transform to rates)

Parameters

timeStamp

time stamp

Implements HitRateBase.

Definition at line 131 of file PXDHitRateCounter.cc.

    {
      // copy buffer element
      m_rates = m_buffer[timeStamp];
 
      if (not m_rates.valid) return;
 
      if (m_rates.numEvents == 0) return;
 
      // Average number of PXDDigits per 1Hz
      m_rates.averageRate /= m_rates.numEvents;
 
      // Total integration time of PXD per 1Hz
      double currentComponentTime = m_rates.numEvents * m_integrationTime;
 
      //Pointer to GeoTools instance
      auto gTools = VXD::GeoCache::getInstance().getGeoTools();
 
      // Compute sensor level averages per 1Hz
      for (int index = 0; index < m_nPXDSensors; index++) {
        VxdID sensorID = gTools->getSensorIDFromPXDIndex(index);
        auto info = getInfo(sensorID);
        double currentSensorMass = m_activeAreas[index] * info.getThickness() * c_densitySi;
        double currentSensorArea = m_activeAreas[index];
 
        m_rates.meanOccupancies[index] /= m_rates.numEvents;
        if (currentSensorArea > 0) {
          m_rates.doseRates[index] *= (1.0 / (currentComponentTime / Unit::s)) * (1000 / currentSensorMass);
          m_rates.softPhotonFluxes[index] *= (1.0 / currentSensorArea) * (1.0 / (currentComponentTime / Unit::s));
          m_rates.hardPhotonFluxes[index] *= (1.0 / currentSensorArea) * (1.0 / (currentComponentTime / Unit::s));
          m_rates.chargedFluxes[index] *= (1.0 / currentSensorArea) * (1.0 / (currentComponentTime / Unit::s));
 
          // Loop over v segements
          for (int vBin = 0; vBin < 6; ++vBin)  {
            double currentSegmentMass = m_segmentActiveAreas[vBin + index * 6] * info.getThickness() * c_densitySi;
            double currentSegmentArea = m_segmentActiveAreas[vBin + index * 6];
            if (currentSegmentArea > 0) {
              m_rates.segmentDoseRates[vBin + index * 6] *= (1.0 / (currentComponentTime / Unit::s)) * (1000 / currentSegmentMass);
              m_rates.segmentSoftPhotonFluxes[vBin + index * 6] *= (1.0 / currentSegmentArea) * (1.0 / (currentComponentTime / Unit::s));
              m_rates.segmentHardPhotonFluxes[vBin + index * 6] *= (1.0 / currentSegmentArea) * (1.0 / (currentComponentTime / Unit::s));
              m_rates.segmentChargedFluxes[vBin + index * 6] *= (1.0 / currentSegmentArea) * (1.0 /
                                                                (currentComponentTime / Unit::s));
            }
          }
        }
      }
    }

setActivePixels()

void setActivePixels ( )

private

Sets fractions of active channels.

Definition at line 179 of file PXDHitRateCounter.cc.

    {
      //Pointer to GeoTools instance
      auto gTools = VXD::GeoCache::getInstance().getGeoTools();
 
      // Initialize active areas and active fractions for all sensors
      for (int index = 0; index < m_nPXDSensors; index++) {
        VxdID sensorID = gTools->getSensorIDFromPXDIndex(index);
        auto info = getInfo(sensorID);
 
        // Compute nominal number of pixel per sensor
        m_activePixels[index] = info.getUCells() * info.getVCells();
        // Compute nominal area of sensor
        m_activeAreas[index] = info.getWidth() * info.getLength();
 
        // Loop over v segements
        for (int vBin = 0; vBin < 6; ++vBin)  {
          // Compute nominal number of pixel per segment
          // Sgements have same number of rows, but due to pitch change a different length
          m_segmentActivePixels[vBin + index * 6] = info.getUCells() * info.getVCells() / 6;
          // Compute position of v segment
          double v = info.getVCellPosition(vBin * info.getVCells() / 6);
          // Compute nominal area of segment
          m_segmentActiveAreas[vBin + index * 6] = info.getWidth() * info.getVPitch(v) * info.getVCells() / 6;
        }
 
        if (m_maskDeadPixels) {
          for (int ui = 0; ui < info.getUCells(); ++ui) {
            for (int vi = 0; vi < info.getVCells(); ++vi) {
              if (PXD::PXDPixelMasker::getInstance().pixelDead(sensorID, ui, vi)
                  || !PXD::PXDPixelMasker::getInstance().pixelOK(sensorID, ui, vi)) {
                m_activePixels[index] -= 1;
                m_activeAreas[index] -= info.getVPitch(info.getVCellPosition(vi)) * info.getUPitch();
                int vBin = PXD::PXDGainCalibrator::getInstance().getBinV(sensorID, vi, 6);
                m_segmentActivePixels[vBin + index * 6] -= 1;
                m_segmentActiveAreas[vBin + index * 6] -= info.getVPitch(info.getVCellPosition(vi)) * info.getUPitch();
              }
            }
          }
        }
      }
    }

Member Data Documentation

c_densitySi

const double c_densitySi = 2.3290 * Unit::g_cm3

private

Density of crystalline Silicon.

Definition at line 102 of file PXDHitRateCounter.h.

m_activeAreas

double m_activeAreas[40] = {0}

private

area of active pixels in sensor

Definition at line 116 of file PXDHitRateCounter.h.

m_activePixels

double m_activePixels[40] = {0}

private

number of active pixels in sensor

Definition at line 115 of file PXDHitRateCounter.h.

m_buffer

std::map<unsigned, TreeStruct> m_buffer

private

average rates in time stamps

Definition at line 108 of file PXDHitRateCounter.h.

m_clusters

StoreArray<PXDCluster> m_clusters

private

collection of clusters

Definition at line 112 of file PXDHitRateCounter.h.

m_digits

StoreArray<PXDDigit> m_digits

private

collection of digits

Definition at line 111 of file PXDHitRateCounter.h.

m_integrationTime

double m_integrationTime = 20 * Unit::us

private

Integration time of PXD in ns.

Definition at line 98 of file PXDHitRateCounter.h.

m_maskDeadPixels

bool m_maskDeadPixels = true

private

Correct bg rates by taking into account masked pixels.

Definition at line 99 of file PXDHitRateCounter.h.

m_nPXDSensors

int m_nPXDSensors = 0

private

number of sensors

Definition at line 100 of file PXDHitRateCounter.h.

m_rates

TreeStruct m_rates

private

tree variables

Definition at line 105 of file PXDHitRateCounter.h.

m_segmentActiveAreas

double m_segmentActiveAreas[240] = {0}

private

area of active pixels in v segments

Definition at line 118 of file PXDHitRateCounter.h.

m_segmentActivePixels

double m_segmentActivePixels[240] = {0}

private

number of active pixels in v segements

Definition at line 117 of file PXDHitRateCounter.h.

---

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

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