Belle II Software  release-05-02-19
SVDHitRateCounter Class Reference

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

#include <SVDHitRateCounter.h>

Inheritance diagram for SVDHitRateCounter:
Collaboration 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. 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, TreeStructm_buffer
 average strip occupancies in time stamps
 
std::map< unsigned, TreeStructm_bufferU
 average U-strip occupancies in time stamps
 
std::map< unsigned, TreeStructm_bufferV
 average V-strip occupancies in time stamps
 
std::map< unsigned, TreeStructm_buffer_highE
 average cluster occupancies (high energy) in time stamps
 
std::map< unsigned, TreeStructm_buffer_lowE
 average cluster occupancies (low energy) in time stamps
 
std::map< unsigned, TreeStructm_buffer_clustersU
 average cluster occupancies (U-side) in time stamps
 
std::map< unsigned, TreeStructm_buffer_clustersV
 average cluster occupancies (V-side) in time stamps
 
std::map< unsigned, TreeStructm_buffer_energyU
 Average deposited energy (U-side) per event in time stamps.
 
std::map< unsigned, TreeStructm_buffer_energyV
 Average deposited energy (V-side) per event in time stamps.
 
StoreArray< SVDShaperDigitm_digits
 collection of digits
 
StoreArray< SVDClusterm_clusters
 collection of clusters
 
StoreObjPtr< SoftwareTriggerResultm_resultStoreObjectPointer
 trigger decision
 
StoreObjPtr< SVDEventInfom_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
 
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 44 of file SVDHitRateCounter.h.

Constructor & Destructor Documentation

◆ SVDHitRateCounter()

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

Constructor.

Parameters
svdShaperDigitsNamename of the input SVDShaperDigits collection
thrChargecut on cluster energy in electrons
ignoreHotStripsPayloadCount also hot strips as active
ignoreMaskedStripsPayloadCount also FADC-masked strips as active

Definition at line 93 of file SVDHitRateCounter.h.

143  {

Member Function Documentation

◆ accumulate()

void accumulate ( unsigned  timeStamp)
overridevirtual

Accumulate hits.

Parameters
timeStamptime stamp

Implements HitRateBase.

Definition at line 144 of file SVDHitRateCounter.cc.

145  {
146  B2DEBUG(10, "SVDHitRateCounter: accumulate()");
147 
148  // check if the event has passed HLT filter
149  if (m_resultStoreObjectPointer.isValid()) {
151  if (!eventAccepted) return;
152  }
153 
154  // check if data are available
155  if (m_digits.isValid()) {
156 
157  // get buffer element
158  auto& rates = m_buffer[timeStamp];
159  auto& ratesU = m_bufferU[timeStamp];
160  auto& ratesV = m_bufferV[timeStamp];
161 
162  // increment event counter
163  rates.numEvents++;
164  ratesU.numEvents++;
165  ratesV.numEvents++;
166 
167  // accumulate hits
168  for (const auto& digit : m_digits) {
169  // select digits to count (usualy only good ones)
170  VxdID sensorID = digit.getSensorID();
171  int layer = sensorID.getLayerNumber() - 3;
172  int ladder = sensorID.getLadderNumber() - 1;
173  int sensor = sensorID.getSensorNumber() - 1;
174  rates.layerAverageRates[layer] ++;
175  rates.layerLadderAverageRates[layer][ladder] ++;
176  rates.layerSensorAverageRates[layer][sensor] ++;
177  rates.averageRate ++;
178  if (layer == 0)
179  rates.l3LadderSensorAverageRates[ladder][sensor] ++;
180 
181  if (digit.isUStrip()) {
182  ratesU.layerAverageRates[layer]++;
183  ratesU.layerLadderAverageRates[layer][ladder]++;
184  ratesU.layerSensorAverageRates[layer][sensor]++;
185  ratesU.averageRate++;
186  if (layer == 0)
187  ratesU.l3LadderSensorAverageRates[ladder][sensor]++;
188  } else {
189  ratesV.layerAverageRates[layer]++;
190  ratesV.layerLadderAverageRates[layer][ladder]++;
191  ratesV.layerSensorAverageRates[layer][sensor]++;
192  ratesV.averageRate++;
193  if (layer == 0)
194  ratesV.l3LadderSensorAverageRates[ladder][sensor]++;
195  }
196  }
197 
198  // set flag to true to indicate the rates are valid
199  rates.valid = true;
200  ratesU.valid = true;
201  ratesV.valid = true;
202  }
203 
204  // check if data are available
205  if (m_clusters.isValid()) {
206 
207  // get buffer element
208  auto& rates_highE = m_buffer_highE[timeStamp];
209  auto& rates_lowE = m_buffer_lowE[timeStamp];
210  auto& clustersU = m_buffer_clustersU[timeStamp];
211  auto& clustersV = m_buffer_clustersV[timeStamp];
212  auto& rates_energyU = m_buffer_energyU[timeStamp];
213  auto& rates_energyV = m_buffer_energyV[timeStamp];
214 
215  // increment event counter
216  rates_highE.numEvents++;
217  rates_lowE.numEvents++;
218  clustersU.numEvents++;
219  clustersV.numEvents++;
220  rates_energyU.numEvents++;
221  rates_energyV.numEvents++;
222 
223  // accumulate clusters
224  for (const auto& cluster : m_clusters) {
225  VxdID sensorID = cluster.getSensorID();
226  int layer = sensorID.getLayerNumber() - 3;
227  int ladder = sensorID.getLadderNumber() - 1;
228  int sensor = sensorID.getSensorNumber() - 1;
229  if (cluster.getCharge() > m_thrCharge) {
230  rates_highE.layerAverageRates[layer] ++;
231  rates_highE.layerLadderAverageRates[layer][ladder] ++;
232  rates_highE.layerSensorAverageRates[layer][sensor] ++;
233  rates_highE.averageRate ++;
234  if (layer == 0)
235  rates_highE.l3LadderSensorAverageRates[ladder][sensor] ++;
236  } else {
237  rates_lowE.layerAverageRates[layer] ++;
238  rates_lowE.layerLadderAverageRates[layer][ladder] ++;
239  rates_lowE.layerSensorAverageRates[layer][sensor] ++;
240  rates_lowE.averageRate ++;
241  if (layer == 0)
242  rates_lowE.l3LadderSensorAverageRates[ladder][sensor] ++;
243  }
244  int nSamp = m_eventInfo.isValid() ? m_eventInfo->getNSamples() : 6; // Assume 6 samples if real value unknown
245  if (nSamp < 2) nSamp = 2; // Avoid division by zero if nSamp = 1. Not sure it's correct, but I don't expect nSamp = 1 to happen.
246  double integrationTimeSeconds = (nSamp - 1) / c_SVDSamplingClockFrequency / Unit::s;
247  double chargePerUnitTime = cluster.getCharge() / integrationTimeSeconds;
248  if (cluster.isUCluster()) {
249  rates_energyU.layerAverageRates[layer] += chargePerUnitTime;
250  rates_energyU.layerLadderAverageRates[layer][ladder] += chargePerUnitTime;
251  rates_energyU.layerSensorAverageRates[layer][sensor] += chargePerUnitTime;
252  rates_energyU.averageRate += chargePerUnitTime;
253  if (layer == 0)
254  rates_energyU.l3LadderSensorAverageRates[ladder][sensor] += chargePerUnitTime;
255  clustersU.layerAverageRates[layer]++;
256  clustersU.layerLadderAverageRates[layer][ladder]++;
257  clustersU.layerSensorAverageRates[layer][sensor]++;
258  clustersU.averageRate++;
259  if (layer == 0)
260  clustersU.l3LadderSensorAverageRates[ladder][sensor]++;
261  } else {
262  rates_energyV.layerAverageRates[layer] += chargePerUnitTime;
263  rates_energyV.layerLadderAverageRates[layer][ladder] += chargePerUnitTime;
264  rates_energyV.layerSensorAverageRates[layer][sensor] += chargePerUnitTime;
265  rates_energyV.averageRate += chargePerUnitTime;
266  if (layer == 0)
267  rates_energyV.l3LadderSensorAverageRates[ladder][sensor] += chargePerUnitTime;
268  clustersV.layerAverageRates[layer]++;
269  clustersV.layerLadderAverageRates[layer][ladder]++;
270  clustersV.layerSensorAverageRates[layer][sensor]++;
271  clustersV.averageRate++;
272  if (layer == 0)
273  clustersV.l3LadderSensorAverageRates[ladder][sensor]++;
274  }
275  }
276 
277  // set flag to true to indicate the rates are valid
278  rates_highE.valid = true;
279  rates_lowE.valid = true;
280  clustersU.valid = true;
281  clustersV.valid = true;
282  rates_energyU.valid = true;
283  rates_energyV.valid = true;
284  }
285 
286  }

◆ initialize()

void initialize ( TTree *  tree)
overridevirtual

Class initializer: set branch addresses and other staf.

Parameters
treea valid TTree pointer

Implements HitRateBase.

Definition at line 32 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
sensorIDThe VxdID of the sensor
isUThe side of the sensor
stripThe strip index

Definition at line 383 of file SVDHitRateCounter.cc.

◆ massOfSensor()

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

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

Parameters
layertha layer number (starting from 0, not 3)
ladderthe ladder number (starting from 0, not 1)
sensorthe sensor number (starting from 0, not 1)

Definition at line 373 of file SVDHitRateCounter.cc.

◆ normalize()

void normalize ( unsigned  timeStamp)
overridevirtual

Normalize accumulated hits (e.g.

transform to rates)

Parameters
timeStamptime stamp

Implements HitRateBase.

Definition at line 288 of file SVDHitRateCounter.cc.

◆ normalizeEnergyRates()

void normalizeEnergyRates ( TreeStruct rates)

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

Parameters
ratesTreeStruct 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 349 of file SVDHitRateCounter.cc.

◆ normalizeRates()

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

Normalize TreeStruct.

Parameters
ratesTreeStruct to be normalized
isUWhether the TreeStruct only contains U-side hits
isVWhether the TreeStruct only contains V-side hits

Definition at line 313 of file SVDHitRateCounter.cc.

◆ nStripsOnLayerSide()

int nStripsOnLayerSide ( int  layer,
bool  isU 
)
inline

Return number of strips on a sensor.

Parameters
layerlayer number of the sensor (starting from 0)
isUtrue if the sensor is U side, false if V.

Definition at line 150 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 a temporary patch for release/05-02. On master, I used HardwareClockSettings to get the exact frequency, but it is not available in this branch.

Definition at line 253 of file SVDHitRateCounter.h.


The documentation for this class was generated from the following files:
Belle2::Unit::s
static const double s
[second]
Definition: Unit.h:105
Belle2::Background::SVDHitRateCounter::m_buffer_energyV
std::map< unsigned, TreeStruct > m_buffer_energyV
Average deposited energy (V-side) per event in time stamps.
Definition: SVDHitRateCounter.h:201
Belle2::Background::SVDHitRateCounter::m_resultStoreObjectPointer
StoreObjPtr< SoftwareTriggerResult > m_resultStoreObjectPointer
trigger decision
Definition: SVDHitRateCounter.h:208
Belle2::Background::SVDHitRateCounter::c_SVDSamplingClockFrequency
static constexpr double c_SVDSamplingClockFrequency
SVD Sampling Clock frequency (approximated) in GHz (standard unit of frequency in basf2).
Definition: SVDHitRateCounter.h:253
Belle2::Background::SVDHitRateCounter::m_eventInfo
StoreObjPtr< SVDEventInfo > m_eventInfo
For number of APV samples taken (3 or 6).
Definition: SVDHitRateCounter.h:209
Belle2::Background::SVDHitRateCounter::m_thrCharge
double m_thrCharge
cut on cluster energy in electrons
Definition: SVDHitRateCounter.h:236
Belle2::Background::SVDHitRateCounter::m_clusters
StoreArray< SVDCluster > m_clusters
collection of clusters
Definition: SVDHitRateCounter.h:205
Belle2::Background::SVDHitRateCounter::m_buffer_clustersV
std::map< unsigned, TreeStruct > m_buffer_clustersV
average cluster occupancies (V-side) in time stamps
Definition: SVDHitRateCounter.h:199
Belle2::Background::SVDHitRateCounter::m_digits
StoreArray< SVDShaperDigit > m_digits
collection of digits
Definition: SVDHitRateCounter.h:204
Belle2::SoftwareTrigger::FinalTriggerDecisionCalculator::getFinalTriggerDecision
static bool getFinalTriggerDecision(const SoftwareTriggerResult &result, bool forgetTotalResult=false)
Calculate the final cut decision using all "total_results" of all sub triggers in the software trigge...
Definition: FinalTriggerDecisionCalculator.cc:17
Belle2::Background::SVDHitRateCounter::m_buffer_highE
std::map< unsigned, TreeStruct > m_buffer_highE
average cluster occupancies (high energy) in time stamps
Definition: SVDHitRateCounter.h:196
Belle2::Background::SVDHitRateCounter::m_buffer_clustersU
std::map< unsigned, TreeStruct > m_buffer_clustersU
average cluster occupancies (U-side) in time stamps
Definition: SVDHitRateCounter.h:198
Belle2::Background::SVDHitRateCounter::m_buffer
std::map< unsigned, TreeStruct > m_buffer
average strip occupancies in time stamps
Definition: SVDHitRateCounter.h:193
Belle2::StoreArray::isValid
bool isValid() const
Check wether the array was registered.
Definition: StoreArray.h:298
Belle2::Background::SVDHitRateCounter::m_bufferV
std::map< unsigned, TreeStruct > m_bufferV
average V-strip occupancies in time stamps
Definition: SVDHitRateCounter.h:195
Belle2::Background::SVDHitRateCounter::m_buffer_energyU
std::map< unsigned, TreeStruct > m_buffer_energyU
Average deposited energy (U-side) per event in time stamps.
Definition: SVDHitRateCounter.h:200
Belle2::Background::SVDHitRateCounter::m_buffer_lowE
std::map< unsigned, TreeStruct > m_buffer_lowE
average cluster occupancies (low energy) in time stamps
Definition: SVDHitRateCounter.h:197
Belle2::Background::SVDHitRateCounter::m_bufferU
std::map< unsigned, TreeStruct > m_bufferU
average U-strip occupancies in time stamps
Definition: SVDHitRateCounter.h:194