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
void	setActivePixels ()
	Sets fractions of active channels.

Static Private Member Functions
static const PXD::SensorInfo &	getInfo (VxdID sensorID)
	Get PXD::SensorInfo.

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 segments
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 )

inlinestaticprivate

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 segments
          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 segments
        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.

{0}; 

m_activePixels

double m_activePixels[40] = {0}

private

number of active pixels in sensor

Definition at line 115 of file PXDHitRateCounter.h.

{0}; 

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.

{0}; 

m_segmentActivePixels

double m_segmentActivePixels[240] = {0}

private

number of active pixels in v segments

Definition at line 117 of file PXDHitRateCounter.h.

{0}; 

---

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

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