SVDHitRateCounter Class Reference

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

#include <SVDHitRateCounter.h>

Inheritance diagram for SVDHitRateCounter:

Classes
struct	TreeStruct
	tree structure More...

Public Member Functions
	SVDHitRateCounter (const std::string &svdShaperDigitsName, double thrCharge, bool ignoreHotStripsPayload=false, bool ignoreMaskedStripsPayload=false)
	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.
void	normalizeRates (TreeStruct &rates, bool isU=false, bool isV=false)
	Normalize TreeStruct.
void	normalizeEnergyRates (TreeStruct &rates)
	Normalize a TreeStruct that stores charge/energy, not hits.
int	nStripsOnLayerSide (int layer, bool isU)
	Return number of strips on a sensor.
double	massOfSensor (int layer, int ladder, int sensor)
	Returns the (active) mass of the given sensor in Kg.
bool	isStripActive (const VxdID &sensorID, const bool &isU, const unsigned short &strip)
	Returns wether a strips is active (neither hot nor masked), taking into account the ignoreHotStrips and ignoreMaskedStrips settings.

Private Attributes
int	m_nLayers = 4
	number of layers
int	m_nLadders [4] = {7, 10, 12, 16}
	number of ladders on each layer
int	m_nSensors [4] = {2, 3, 4, 5}
	number of sensors on a ladder on each layer
TreeStruct	m_rates
	tree variables for fired strips
TreeStruct	m_ratesU
	tree variables for fired U-strips
TreeStruct	m_ratesV
	tree variables for fired V-strips
TreeStruct	m_rates_highE
	tree variables for high-energy clusters
TreeStruct	m_rates_lowE
	tree variables for low-energy clusters
TreeStruct	m_clustersU
	tree variables for U-side clusters
TreeStruct	m_clustersV
	tree variables for V-side clusters
TreeStruct	m_rates_energyU
	Tree variables for deposited charge per unit time, then converted to dose rate (U-side)
TreeStruct	m_rates_energyV
	Tree variables for deposited charge per unit time, then converted to dose rate (V-side)
std::map< unsigned, TreeStruct >	m_buffer
	average strip occupancies in time stamps
std::map< unsigned, TreeStruct >	m_bufferU
	average U-strip occupancies in time stamps
std::map< unsigned, TreeStruct >	m_bufferV
	average V-strip occupancies in time stamps
std::map< unsigned, TreeStruct >	m_buffer_highE
	average cluster occupancies (high energy) in time stamps
std::map< unsigned, TreeStruct >	m_buffer_lowE
	average cluster occupancies (low energy) in time stamps
std::map< unsigned, TreeStruct >	m_buffer_clustersU
	average cluster occupancies (U-side) in time stamps
std::map< unsigned, TreeStruct >	m_buffer_clustersV
	average cluster occupancies (V-side) in time stamps
std::map< unsigned, TreeStruct >	m_buffer_energyU
	Average deposited energy (U-side) per event in time stamps.
std::map< unsigned, TreeStruct >	m_buffer_energyV
	Average deposited energy (V-side) per event in time stamps.
StoreArray< SVDShaperDigit >	m_digits
	collection of digits
StoreArray< SVDCluster >	m_clusters
	collection of clusters
StoreObjPtr< SoftwareTriggerResult >	m_resultStoreObjectPointer
	trigger decision
StoreObjPtr< SVDEventInfo >	m_eventInfo
	For number of APV samples taken (3 or 6).
SVDHotStripsCalibrations	m_HotStripsCalib
	payload for hot strips
SVDFADCMaskedStrips	m_FADCMaskedStrips
	payload for strips masked on FADC level
OptionalDBObjPtr< HardwareClockSettings >	m_clockSettings
	hardware clock settings
std::string	m_svdShaperDigitsName
	name of the input SVDShaperDigits collection
int	m_activeStrips = 0
	number of active strips
int	m_layerActiveStrips [4] = {0}
	number of active strips in each layer
int	m_layerLadderActiveStrips [4][16] = {{0}}
	number of active strips in each layer, ladder
int	m_layerSensorActiveStrips [4][5] = {{0}}
	number of active strips in each layer, sensor position
int	m_l3LadderSensorActiveStrips [7][2] = {{0}}
	number of active strips in each sensor in Layer 3
int	m_activeStripsU = 0
	number of active U-strips
int	m_layerActiveStripsU [4] = {0}
	number of active U-strips in each layer
int	m_layerLadderActiveStripsU [4][16] = {{0}}
	number of active U-strips in each layer, ladder
int	m_layerSensorActiveStripsU [4][5] = {{0}}
	number of active U-strips in each layer, sensor position
int	m_l3LadderSensorActiveStripsU [7][2] = {{0}}
	number of active U-strips in each sensor in Layer 3
int	m_activeStripsV = 0
	number of active V-strips
int	m_layerActiveStripsV [4] = {0}
	number of active V-strips in each layer
int	m_layerLadderActiveStripsV [4][16] = {{0}}
	number of active V-strips in each layer, ladder
int	m_layerSensorActiveStripsV [4][5] = {{0}}
	number of active V-strips in each layer, sensor position
int	m_l3LadderSensorActiveStripsV [7][2] = {{0}}
	number of active V-strips in each sensor in Layer 3
double	m_thrCharge = 0
	cut on cluster energy in electrons
bool	m_ignoreHotStripsPayload
	count hot strips as active
bool	m_ignoreMaskedStripsPayload
	SVD: count FAD-masked strips as active.
double	m_massKg = 0
	Active mass of the whole SVD in Kg.
double	m_layerMassKg [4] = {0}
	Active mass of each layer in Kg.
double	m_layerLadderMassKg [4][16] = {{0}}
	Active mass of each ladder of each layer, in Kg.
double	m_layerSensorMassKg [4][5] = {{0}}
	Active mass of each ladder/sensor position, in Kg.

Static Private Attributes
static constexpr double	c_SVDSamplingClockFrequency = 0.03175
	SVD Sampling Clock frequency (approximated) in GHz (standard unit of frequency in basf2).

Detailed Description

Class for monitoring beam background hit rates of SVD.

Definition at line 36 of file SVDHitRateCounter.h.

Constructor & Destructor Documentation

SVDHitRateCounter()

SVDHitRateCounter ( const std::string &  svdShaperDigitsName, double  thrCharge, bool  ignoreHotStripsPayload = false, bool  ignoreMaskedStripsPayload = false  )

inline

Constructor.

Parameters

svdShaperDigitsName	name of the input SVDShaperDigits collection
thrCharge	cut on cluster energy in electrons
ignoreHotStripsPayload	Count also hot strips as active
ignoreMaskedStripsPayload	Count also FADC-masked strips as active

Definition at line 85 of file SVDHitRateCounter.h.

                                                               :
        m_svdShaperDigitsName(svdShaperDigitsName), m_thrCharge(thrCharge),
        m_ignoreHotStripsPayload(ignoreHotStripsPayload),
        m_ignoreMaskedStripsPayload(ignoreMaskedStripsPayload)
      {}

Member Function Documentation

accumulate()

void accumulate ( unsigned  timeStamp )

overridevirtual

Accumulate hits.

Parameters

timeStamp

time stamp

Implements HitRateBase.

Definition at line 144 of file SVDHitRateCounter.cc.

    {
      B2DEBUG(10, "SVDHitRateCounter: accumulate()");
 
      // check if the event has passed HLT filter
      if (m_resultStoreObjectPointer.isValid()) {
        const bool eventAccepted = SoftwareTrigger::FinalTriggerDecisionCalculator::getFinalTriggerDecision(*m_resultStoreObjectPointer);
        if (!eventAccepted) return;
      }
 
      // check if data are available
      if (m_digits.isValid()) {
 
        // get buffer element
        auto& rates = m_buffer[timeStamp];
        auto& ratesU = m_bufferU[timeStamp];
        auto& ratesV = m_bufferV[timeStamp];
 
        // increment event counter
        rates.numEvents++;
        ratesU.numEvents++;
        ratesV.numEvents++;
 
        // accumulate hits
        for (const auto& digit : m_digits) {
          // select digits to count (usualy only good ones)
          VxdID sensorID = digit.getSensorID();
          int layer = sensorID.getLayerNumber() - 3;
          int ladder = sensorID.getLadderNumber() - 1;
          int sensor = sensorID.getSensorNumber() - 1;
          rates.layerAverageRates[layer] ++;
          rates.layerLadderAverageRates[layer][ladder] ++;
          rates.layerSensorAverageRates[layer][sensor] ++;
          rates.averageRate ++;
          if (layer == 0)
            rates.l3LadderSensorAverageRates[ladder][sensor] ++;
 
          if (digit.isUStrip()) {
            ratesU.layerAverageRates[layer]++;
            ratesU.layerLadderAverageRates[layer][ladder]++;
            ratesU.layerSensorAverageRates[layer][sensor]++;
            ratesU.averageRate++;
            if (layer == 0)
              ratesU.l3LadderSensorAverageRates[ladder][sensor]++;
          } else {
            ratesV.layerAverageRates[layer]++;
            ratesV.layerLadderAverageRates[layer][ladder]++;
            ratesV.layerSensorAverageRates[layer][sensor]++;
            ratesV.averageRate++;
            if (layer == 0)
              ratesV.l3LadderSensorAverageRates[ladder][sensor]++;
          }
        }
 
        // set flag to true to indicate the rates are valid
        rates.valid = true;
        ratesU.valid = true;
        ratesV.valid = true;
      }
 
      // check if data are available
      if (m_clusters.isValid()) {
 
        // get buffer element
        auto& rates_highE = m_buffer_highE[timeStamp];
        auto& rates_lowE = m_buffer_lowE[timeStamp];
        auto& clustersU = m_buffer_clustersU[timeStamp];
        auto& clustersV = m_buffer_clustersV[timeStamp];
        auto& rates_energyU = m_buffer_energyU[timeStamp];
        auto& rates_energyV = m_buffer_energyV[timeStamp];
 
        // increment event counter
        rates_highE.numEvents++;
        rates_lowE.numEvents++;
        clustersU.numEvents++;
        clustersV.numEvents++;
        rates_energyU.numEvents++;
        rates_energyV.numEvents++;
 
        // accumulate clusters
        for (const auto& cluster : m_clusters) {
          VxdID sensorID = cluster.getSensorID();
          int layer = sensorID.getLayerNumber() - 3;
          int ladder = sensorID.getLadderNumber() - 1;
          int sensor = sensorID.getSensorNumber() - 1;
          if (cluster.getCharge() > m_thrCharge) {
            rates_highE.layerAverageRates[layer] ++;
            rates_highE.layerLadderAverageRates[layer][ladder] ++;
            rates_highE.layerSensorAverageRates[layer][sensor] ++;
            rates_highE.averageRate ++;
            if (layer == 0)
              rates_highE.l3LadderSensorAverageRates[ladder][sensor] ++;
          } else {
            rates_lowE.layerAverageRates[layer] ++;
            rates_lowE.layerLadderAverageRates[layer][ladder] ++;
            rates_lowE.layerSensorAverageRates[layer][sensor] ++;
            rates_lowE.averageRate ++;
            if (layer == 0)
              rates_lowE.l3LadderSensorAverageRates[ladder][sensor] ++;
          }
 
          // Compute integration time for obtaining the dose rate
          int nSamp = 6; // Fallback value
          double svdSamplingClock = c_SVDSamplingClockFrequency; // Fallback value
          // Replace number of samples with real value if available
          if (m_eventInfo.isValid())
            nSamp = m_eventInfo->getNSamples();
          else
            B2WARNING("SVDEventInfo not available: assuming 6 samples were taken.");
          // Avoid division by zero if nSamp = 1. Valid values are only 6 and 3,
          // so this line is only meant to prevent a crash in case of corrupted data.
          if (nSamp < 2) nSamp = 2;
          // Replace sampling frequency with real value if available
          if (m_clockSettings.isValid())
            svdSamplingClock = m_clockSettings->getClockFrequency(Const::SVD, "sampling");
          else
            B2WARNING("HardwareClockSettings not available: using approximated SVD sampling clock frequency.");
          double integrationTimeSeconds = (nSamp - 1) / svdSamplingClock / Unit::s;
          double chargePerUnitTime = cluster.getCharge() / integrationTimeSeconds;
          if (cluster.isUCluster()) {
            rates_energyU.layerAverageRates[layer] += chargePerUnitTime;
            rates_energyU.layerLadderAverageRates[layer][ladder] += chargePerUnitTime;
            rates_energyU.layerSensorAverageRates[layer][sensor] += chargePerUnitTime;
            rates_energyU.averageRate += chargePerUnitTime;
            if (layer == 0)
              rates_energyU.l3LadderSensorAverageRates[ladder][sensor] += chargePerUnitTime;
            clustersU.layerAverageRates[layer]++;
            clustersU.layerLadderAverageRates[layer][ladder]++;
            clustersU.layerSensorAverageRates[layer][sensor]++;
            clustersU.averageRate++;
            if (layer == 0)
              clustersU.l3LadderSensorAverageRates[ladder][sensor]++;
          } else {
            rates_energyV.layerAverageRates[layer] += chargePerUnitTime;
            rates_energyV.layerLadderAverageRates[layer][ladder] += chargePerUnitTime;
            rates_energyV.layerSensorAverageRates[layer][sensor] += chargePerUnitTime;
            rates_energyV.averageRate += chargePerUnitTime;
            if (layer == 0)
              rates_energyV.l3LadderSensorAverageRates[ladder][sensor] += chargePerUnitTime;
            clustersV.layerAverageRates[layer]++;
            clustersV.layerLadderAverageRates[layer][ladder]++;
            clustersV.layerSensorAverageRates[layer][sensor]++;
            clustersV.averageRate++;
            if (layer == 0)
              clustersV.l3LadderSensorAverageRates[ladder][sensor]++;
          }
        }
 
        // set flag to true to indicate the rates are valid
        rates_highE.valid = true;
        rates_lowE.valid = true;
        clustersU.valid = true;
        clustersV.valid = true;
        rates_energyU.valid = true;
        rates_energyV.valid = true;
      }
 
    }

clear()

void clear ( )

overridevirtual

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

Implements HitRateBase.

Definition at line 139 of file SVDHitRateCounter.cc.

    {
      m_buffer.clear();
    }

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 30 of file SVDHitRateCounter.cc.

    {
      // register collection(s) as optional, your detector might be excluded in DAQ
      m_digits.isOptional(m_svdShaperDigitsName);
      m_clusters.isOptional();
      m_resultStoreObjectPointer.isOptional();
      m_eventInfo.isOptional();
 
      B2DEBUG(10, "SVDHitRateCounter: initialize()");
      // set branch address
      tree->Branch("svd", &m_rates,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svdU", &m_ratesU,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svdV", &m_ratesV,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svd_highE", &m_rates_highE,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svd_lowE", &m_rates_lowE,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svd_clustersU", &m_clustersU,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svd_clustersV", &m_clustersV,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svd_energyU", &m_rates_energyU,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
      tree->Branch("svd_energyV", &m_rates_energyV,
                   "layerAverageRates[4]/F:layerLadderAverageRates[4][16]/F:layerSensorAverageRates[4][5]:averageRate/F:l3LadderSensorAverageRates[7][2]/F:numEvents/I:valid/O");
 
      // count active strips
      for (int layer = 0; layer < m_nLayers; layer++) {
        for (int ladder = 0; ladder < m_nLadders[layer]; ladder++) {
          for (int sensor = 0; sensor < m_nSensors[layer]; sensor++) {
            VxdID sensorID(layer + 3, ladder + 1, sensor + 1);
            for (bool isU : {true, false}) {
              int nStrips = nStripsOnLayerSide(layer, isU);
              for (int strip = 0; strip < nStrips; strip++) {
                if (isStripActive(sensorID, isU, strip)) {
                  m_activeStrips ++;
                  m_layerActiveStrips[layer] ++;
                  m_layerLadderActiveStrips[layer][ladder] ++;
                  m_layerSensorActiveStrips[layer][sensor] ++;
                  if (isU) {
                    m_activeStripsU++;
                    m_layerActiveStripsU[layer]++;
                    m_layerLadderActiveStripsU[layer][ladder]++;
                    m_layerSensorActiveStripsU[layer][sensor]++;
                  } else {
                    m_activeStripsV++;
                    m_layerActiveStripsV[layer]++;
                    m_layerLadderActiveStripsV[layer][ladder]++;
                    m_layerSensorActiveStripsV[layer][sensor]++;
                  }
                }
              }
            }
          }
        }
      }
      int layer = 0;
      for (int ladder = 0; ladder < m_nLadders[layer]; ladder++) {
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++) {
          VxdID sensorID(layer + 3, ladder + 1, sensor + 1);
          for (bool isU : {true, false}) {
            int nStrips = nStripsOnLayerSide(layer, isU);
            for (int strip = 0; strip < nStrips; strip++) {
              if (isStripActive(sensorID, isU, strip)) {
                m_l3LadderSensorActiveStrips[ladder][sensor] ++;
                if (isU)
                  m_l3LadderSensorActiveStripsU[ladder][sensor]++;
                else
                  m_l3LadderSensorActiveStripsV[ladder][sensor]++;
              }
            }
          }
        }
      }
      B2INFO("SVD active strips = " << LOGRATIO(m_activeStrips, 223744));
      for (layer = 0; layer < m_nLayers; layer++)
        B2INFO("  Active strips L" << layer + 3 << ".X.X = "
               << LOGRATIO(m_layerActiveStrips[layer], m_nLadders[layer] * m_nSensors[layer] * (nStripsOnLayerSide(layer, false) + 768)));
      for (layer = 0; layer < m_nLayers; layer++)
        for (int ladder = 0; ladder < m_nLadders[layer]; ladder++)
          B2INFO("  Active strips L" << layer + 3 << "." << ladder + 1 << ".X = "
                 << LOGRATIO(m_layerLadderActiveStrips[layer][ladder], m_nSensors[layer] * (nStripsOnLayerSide(layer, false) + 768)));
      for (layer = 0; layer < m_nLayers; layer++)
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++)
          B2INFO("  Active strips L" << layer + 3 << ".X." << sensor + 1 << " = "
                 << LOGRATIO(m_layerSensorActiveStrips[layer][sensor], m_nLadders[layer] * (nStripsOnLayerSide(layer, false) + 768)));
      layer = 0;
      for (int ladder = 0; ladder < m_nLadders[layer]; ladder++)
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++)
          B2INFO("  Active strips L3." << ladder + 1 << "." << sensor + 1 << " = "
                 << LOGRATIO(m_l3LadderSensorActiveStrips[ladder][sensor], 2 * 768));
 
      // Compute active mass
      for (layer = 0; layer < m_nLayers; layer++) {
        for (int ladder = 0; ladder < m_nLadders[layer]; ladder++) {
          for (int sensor = 0; sensor < m_nSensors[layer]; sensor++) {
            double mass = massOfSensor(layer, ladder, sensor);
            m_massKg += mass;
            m_layerMassKg[layer] += mass;
            m_layerLadderMassKg[layer][ladder] += mass;
            m_layerSensorMassKg[layer][sensor] += mass;
          }
        }
      }
    }

isStripActive()

bool isStripActive	(	const VxdID &	sensorID,
		const bool &	isU,
		const unsigned short &	strip
	)

Returns wether a strips is active (neither hot nor masked), taking into account the ignoreHotStrips and ignoreMaskedStrips settings.

Parameters

sensorID	The VxdID of the sensor
isU	The side of the sensor
strip	The strip index

Definition at line 398 of file SVDHitRateCounter.cc.

    {
      return ((m_ignoreHotStripsPayload || !m_HotStripsCalib.isHot(sensorID, isU, strip))
              && (m_ignoreMaskedStripsPayload || !m_FADCMaskedStrips.isMasked(sensorID, isU, strip)));
    }

massOfSensor()

double massOfSensor	(	int	layer,
		int	ladder,
		int	sensor
	)

Returns the (active) mass of the given sensor in Kg.

Parameters

layer	tha layer number (starting from 0, not 3)
ladder	the ladder number (starting from 0, not 1)
sensor	the sensor number (starting from 0, not 1)

Definition at line 388 of file SVDHitRateCounter.cc.

    {
      static const double rho_Si = 2.329 * Unit::g_cm3;
      auto& sensorInfo = VXD::GeoCache::getInstance().getSensorInfo(VxdID(layer + 3, ladder + 1, sensor + 1));
      double length = sensorInfo.getLength();
      double width = (sensorInfo.getForwardWidth() + sensorInfo.getBackwardWidth()) / 2.0;
      double thickness = sensorInfo.getWSize();
      return length * width * thickness * rho_Si / 1e3;
    }

normalize()

void normalize ( unsigned  timeStamp )

overridevirtual

Normalize accumulated hits (e.g.

transform to rates)

Parameters

timeStamp

time stamp

Implements HitRateBase.

Definition at line 303 of file SVDHitRateCounter.cc.

    {
      B2DEBUG(10, "SVDHitRateCounter: normalize()");
      // copy buffer element
      m_rates = m_buffer[timeStamp];
      m_ratesU = m_bufferU[timeStamp];
      m_ratesV = m_bufferV[timeStamp];
      m_rates_highE = m_buffer_highE[timeStamp];
      m_rates_lowE = m_buffer_lowE[timeStamp];
      m_clustersU = m_buffer_clustersU[timeStamp];
      m_clustersV = m_buffer_clustersV[timeStamp];
      m_rates_energyU = m_buffer_energyU[timeStamp];
      m_rates_energyV = m_buffer_energyV[timeStamp];
 
      SVDHitRateCounter::normalizeRates(m_rates);
      SVDHitRateCounter::normalizeRates(m_ratesU, true);
      SVDHitRateCounter::normalizeRates(m_ratesV, false, true);
      SVDHitRateCounter::normalizeRates(m_rates_highE);
      SVDHitRateCounter::normalizeRates(m_rates_lowE);
      SVDHitRateCounter::normalizeRates(m_clustersU, true);
      SVDHitRateCounter::normalizeRates(m_clustersV, false, true);
      SVDHitRateCounter::normalizeEnergyRates(m_rates_energyU);
      SVDHitRateCounter::normalizeEnergyRates(m_rates_energyV);
    }

normalizeEnergyRates()

void normalizeEnergyRates

(

TreeStruct &

rates

)

Normalize a TreeStruct that stores charge/energy, not hits.

Parameters

rates

TreeStruct to be normalized.

Assumes the TreeStruct contains the total accumulated cluster charge (in e-), and uses Const::ehEnergy and the mass of the sensors to convert to the average dose rate per event in mrad/s.

Assumes the integration time is 155 ns (6 samples).

Definition at line 364 of file SVDHitRateCounter.cc.

    {
      static const double ehEnergyJoules = Const::ehEnergy / Unit::J;
      // Convert charge/s to mrad/s by multiplying by energy/pair and dividing by the mass
      static const double conv = ehEnergyJoules * 100e3;
 
      if (!rates.valid) return;
 
      rates.normalize(); // Divide by nEvents
      // Convert to dose rate [mrad/s]
      rates.averageRate *= conv / m_massKg;
      for (int layer = 0; layer < m_nLayers; layer++) {
        rates.layerAverageRates[layer] *= conv / m_layerMassKg[layer];
        for (int ladder = 0; ladder < m_nLadders[layer]; ladder++)
          rates.layerLadderAverageRates[layer][ladder] *= conv / m_layerLadderMassKg[layer][ladder];
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++)
          rates.layerSensorAverageRates[layer][sensor] *= conv / m_layerSensorMassKg[layer][sensor];
      }
      int layer = 0;
      for (int ladder = 0; ladder < m_nLadders[layer]; ladder++)
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++)
          rates.l3LadderSensorAverageRates[ladder][sensor] *= conv / massOfSensor(layer, ladder, sensor);
    }

normalizeRates()

void normalizeRates	(	TreeStruct &	rates,
		bool	isU = false,
		bool	isV = false
	)

Normalize TreeStruct.

Parameters

rates	TreeStruct to be normalized
isU	Whether the TreeStruct only contains U-side hits
isV	Whether the TreeStruct only contains V-side hits

Definition at line 328 of file SVDHitRateCounter.cc.

    {
      if (not rates.valid) return;
 
      // normalize -> nHits on each segment in single event
      rates.normalize();
 
      // Take the correct active strips counter
      const auto& activeStrips = isU ? m_activeStripsU : (isV ? m_activeStripsV : m_activeStrips);
      const auto& layerActiveStrips = isU ? m_layerActiveStripsU : (isV ? m_layerActiveStripsV : m_layerActiveStrips);
      const auto& layerLadderActiveStrips = isU ? m_layerLadderActiveStripsU
                                            : (isV ? m_layerLadderActiveStripsV : m_layerLadderActiveStrips);
      const auto& layerSensorActiveStrips = isU ? m_layerSensorActiveStripsU
                                            : (isV ? m_layerSensorActiveStripsV : m_layerSensorActiveStrips);
      const auto& l3LadderSensorActiveStrips = isU ? m_l3LadderSensorActiveStripsU
                                               : (isV ? m_l3LadderSensorActiveStripsV : m_l3LadderSensorActiveStrips);
 
      // convert to occupancy [%]
      rates.averageRate /= activeStrips / 100.0;
      for (int layer = 0; layer < m_nLayers; layer++) {
        rates.layerAverageRates[layer] /= layerActiveStrips[layer] / 100.0;
        for (int ladder = 0; ladder < m_nLadders[layer]; ladder++) {
          rates.layerLadderAverageRates[layer][ladder] /= layerLadderActiveStrips[layer][ladder] / 100.0;
        }
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++) {
          rates.layerSensorAverageRates[layer][sensor] /= layerSensorActiveStrips[layer][sensor] / 100.0;
        }
      }
      int layer = 0;
      for (int ladder = 0; ladder < m_nLadders[layer]; ladder++) {
        for (int sensor = 0; sensor < m_nSensors[layer]; sensor++) {
          rates.l3LadderSensorAverageRates[ladder][sensor] /= l3LadderSensorActiveStrips[ladder][sensor] / 100.0;
        }
      }
    }

nStripsOnLayerSide()

int nStripsOnLayerSide ( int  layer, bool  isU  )

inline

Return number of strips on a sensor.

Parameters

layer	layer number of the sensor (starting from 0)
isU	true if the sensor is U side, false if V.

Definition at line 142 of file SVDHitRateCounter.h.

      {
        if (!isU && layer > 0) return 512; // V side on Layer 4,5,6
        else return 768;
      }

Member Data Documentation

c_SVDSamplingClockFrequency

constexpr double c_SVDSamplingClockFrequency = 0.03175

staticconstexprprivate

SVD Sampling Clock frequency (approximated) in GHz (standard unit of frequency in basf2).

This is used as a fallback value when HardwareClockSettings' payload is not available.

Definition at line 245 of file SVDHitRateCounter.h.

m_activeStrips

int m_activeStrips = 0

private

number of active strips

Definition at line 211 of file SVDHitRateCounter.h.

m_activeStripsU

int m_activeStripsU = 0

private

number of active U-strips

Definition at line 217 of file SVDHitRateCounter.h.

m_activeStripsV

int m_activeStripsV = 0

private

number of active V-strips

Definition at line 223 of file SVDHitRateCounter.h.

m_buffer

std::map<unsigned, TreeStruct> m_buffer

private

average strip occupancies in time stamps

Definition at line 185 of file SVDHitRateCounter.h.

m_buffer_clustersU

std::map<unsigned, TreeStruct> m_buffer_clustersU

private

average cluster occupancies (U-side) in time stamps

Definition at line 190 of file SVDHitRateCounter.h.

m_buffer_clustersV

std::map<unsigned, TreeStruct> m_buffer_clustersV

private

average cluster occupancies (V-side) in time stamps

Definition at line 191 of file SVDHitRateCounter.h.

m_buffer_energyU

std::map<unsigned, TreeStruct> m_buffer_energyU

private

Average deposited energy (U-side) per event in time stamps.

Definition at line 192 of file SVDHitRateCounter.h.

m_buffer_energyV

std::map<unsigned, TreeStruct> m_buffer_energyV

private

Average deposited energy (V-side) per event in time stamps.

Definition at line 193 of file SVDHitRateCounter.h.

m_buffer_highE

std::map<unsigned, TreeStruct> m_buffer_highE

private

average cluster occupancies (high energy) in time stamps

Definition at line 188 of file SVDHitRateCounter.h.

m_buffer_lowE

std::map<unsigned, TreeStruct> m_buffer_lowE

private

average cluster occupancies (low energy) in time stamps

Definition at line 189 of file SVDHitRateCounter.h.

m_bufferU

std::map<unsigned, TreeStruct> m_bufferU

private

average U-strip occupancies in time stamps

Definition at line 186 of file SVDHitRateCounter.h.

m_bufferV

std::map<unsigned, TreeStruct> m_bufferV

private

average V-strip occupancies in time stamps

Definition at line 187 of file SVDHitRateCounter.h.

m_clockSettings

OptionalDBObjPtr<HardwareClockSettings> m_clockSettings

private

hardware clock settings

Definition at line 206 of file SVDHitRateCounter.h.

m_clusters

StoreArray<SVDCluster> m_clusters

private

collection of clusters

Definition at line 197 of file SVDHitRateCounter.h.

m_clustersU

TreeStruct m_clustersU

private

tree variables for U-side clusters

Definition at line 179 of file SVDHitRateCounter.h.

m_clustersV

TreeStruct m_clustersV

private

tree variables for V-side clusters

Definition at line 180 of file SVDHitRateCounter.h.

m_digits

StoreArray<SVDShaperDigit> m_digits

private

collection of digits

Definition at line 196 of file SVDHitRateCounter.h.

m_eventInfo

StoreObjPtr<SVDEventInfo> m_eventInfo

private

For number of APV samples taken (3 or 6).

Definition at line 201 of file SVDHitRateCounter.h.

m_FADCMaskedStrips

SVDFADCMaskedStrips m_FADCMaskedStrips

private

payload for strips masked on FADC level

Definition at line 205 of file SVDHitRateCounter.h.

m_HotStripsCalib

SVDHotStripsCalibrations m_HotStripsCalib

private

payload for hot strips

Definition at line 204 of file SVDHitRateCounter.h.

m_ignoreHotStripsPayload

bool m_ignoreHotStripsPayload

private

count hot strips as active

Definition at line 230 of file SVDHitRateCounter.h.

m_ignoreMaskedStripsPayload

bool m_ignoreMaskedStripsPayload

private

SVD: count FAD-masked strips as active.

Definition at line 231 of file SVDHitRateCounter.h.

m_l3LadderSensorActiveStrips

int m_l3LadderSensorActiveStrips[7][2] = {{0}}

private

number of active strips in each sensor in Layer 3

Definition at line 215 of file SVDHitRateCounter.h.

m_l3LadderSensorActiveStripsU

int m_l3LadderSensorActiveStripsU[7][2] = {{0}}

private

number of active U-strips in each sensor in Layer 3

Definition at line 221 of file SVDHitRateCounter.h.

m_l3LadderSensorActiveStripsV

int m_l3LadderSensorActiveStripsV[7][2] = {{0}}

private

number of active V-strips in each sensor in Layer 3

Definition at line 227 of file SVDHitRateCounter.h.

m_layerActiveStrips

int m_layerActiveStrips[4] = {0}

private

number of active strips in each layer

Definition at line 212 of file SVDHitRateCounter.h.

m_layerActiveStripsU

int m_layerActiveStripsU[4] = {0}

private

number of active U-strips in each layer

Definition at line 218 of file SVDHitRateCounter.h.

m_layerActiveStripsV

int m_layerActiveStripsV[4] = {0}

private

number of active V-strips in each layer

Definition at line 224 of file SVDHitRateCounter.h.

m_layerLadderActiveStrips

int m_layerLadderActiveStrips[4][16] = {{0}}

private

number of active strips in each layer, ladder

Definition at line 213 of file SVDHitRateCounter.h.

m_layerLadderActiveStripsU

int m_layerLadderActiveStripsU[4][16] = {{0}}

private

number of active U-strips in each layer, ladder

Definition at line 219 of file SVDHitRateCounter.h.

m_layerLadderActiveStripsV

int m_layerLadderActiveStripsV[4][16] = {{0}}

private

number of active V-strips in each layer, ladder

Definition at line 225 of file SVDHitRateCounter.h.

m_layerLadderMassKg

double m_layerLadderMassKg[4][16] = {{0}}

private

Active mass of each ladder of each layer, in Kg.

Definition at line 235 of file SVDHitRateCounter.h.

m_layerMassKg

double m_layerMassKg[4] = {0}

private

Active mass of each layer in Kg.

Definition at line 234 of file SVDHitRateCounter.h.

m_layerSensorActiveStrips

int m_layerSensorActiveStrips[4][5] = {{0}}

private

number of active strips in each layer, sensor position

Definition at line 214 of file SVDHitRateCounter.h.

m_layerSensorActiveStripsU

int m_layerSensorActiveStripsU[4][5] = {{0}}

private

number of active U-strips in each layer, sensor position

Definition at line 220 of file SVDHitRateCounter.h.

m_layerSensorActiveStripsV

int m_layerSensorActiveStripsV[4][5] = {{0}}

private

number of active V-strips in each layer, sensor position

Definition at line 226 of file SVDHitRateCounter.h.

m_layerSensorMassKg

double m_layerSensorMassKg[4][5] = {{0}}

private

Active mass of each ladder/sensor position, in Kg.

Definition at line 236 of file SVDHitRateCounter.h.

m_massKg

double m_massKg = 0

private

Active mass of the whole SVD in Kg.

Definition at line 233 of file SVDHitRateCounter.h.

m_nLadders

int m_nLadders[4] = {7, 10, 12, 16}

private

number of ladders on each layer

Definition at line 170 of file SVDHitRateCounter.h.

m_nLayers

int m_nLayers = 4

private

number of layers

Definition at line 169 of file SVDHitRateCounter.h.

m_nSensors

int m_nSensors[4] = {2, 3, 4, 5}

private

number of sensors on a ladder on each layer

Definition at line 171 of file SVDHitRateCounter.h.

m_rates

TreeStruct m_rates

private

tree variables for fired strips

Definition at line 174 of file SVDHitRateCounter.h.

m_rates_energyU

TreeStruct m_rates_energyU

private

Tree variables for deposited charge per unit time, then converted to dose rate (U-side)

Definition at line 181 of file SVDHitRateCounter.h.

m_rates_energyV

TreeStruct m_rates_energyV

private

Tree variables for deposited charge per unit time, then converted to dose rate (V-side)

Definition at line 182 of file SVDHitRateCounter.h.

m_rates_highE

TreeStruct m_rates_highE

private

tree variables for high-energy clusters

Definition at line 177 of file SVDHitRateCounter.h.

m_rates_lowE

TreeStruct m_rates_lowE

private

tree variables for low-energy clusters

Definition at line 178 of file SVDHitRateCounter.h.

m_ratesU

TreeStruct m_ratesU

private

tree variables for fired U-strips

Definition at line 175 of file SVDHitRateCounter.h.

m_ratesV

TreeStruct m_ratesV

private

tree variables for fired V-strips

Definition at line 176 of file SVDHitRateCounter.h.

m_resultStoreObjectPointer

StoreObjPtr<SoftwareTriggerResult> m_resultStoreObjectPointer

private

trigger decision

Definition at line 200 of file SVDHitRateCounter.h.

m_svdShaperDigitsName

std::string m_svdShaperDigitsName

private

name of the input SVDShaperDigits collection

Definition at line 209 of file SVDHitRateCounter.h.

m_thrCharge

double m_thrCharge = 0

private

cut on cluster energy in electrons

Definition at line 229 of file SVDHitRateCounter.h.

---

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

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