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

#include <SVDHitRateCounter.h>

Inheritance diagram for SVDHitRateCounter:

Collaboration diagram for SVDHitRateCounter:

[legend]

Classes
struct	TreeStruct
	tree structure More...

Public Member Functions
	SVDHitRateCounter (const std::string &svdShaperDigitsName, double thrCharge, bool ignoreHotStripsPayload=false, bool ignoreMaskedStripsPayload=false)
	Constructor. More...

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

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

void	normalizeEnergyRates (TreeStruct &rates)
	Normalize a TreeStruct that stores charge/energy, not hits. More...

int	nStripsOnLayerSide (int layer, bool isU)
	Return number of strips on a sensor. More...

double	massOfSensor (int layer, int ladder, int sensor)
	Returns the (active) mass of the given sensor in Kg. More...

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

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). More...

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;
       }
  
     }

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

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

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

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

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

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

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

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.

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

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

Classes

Public Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SVDHitRateCounter()

Member Function Documentation

◆ accumulate()

◆ initialize()

◆ isStripActive()

◆ massOfSensor()

◆ normalize()

◆ normalizeEnergyRates()

◆ normalizeRates()

◆ nStripsOnLayerSide()

Member Data Documentation

◆ c_SVDSamplingClockFrequency