Belle II Software  release-05-01-25
PXDPerformanceCollectorModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2020 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Qingyuan Liu *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <pxd/modules/pxdPerformanceCollector/PXDPerformanceCollectorModule.h>
12 
13 #include <framework/datastore/RelationArray.h>
14 
15 #include <vxd/geometry/GeoCache.h>
16 #include <pxd/geometry/SensorInfo.h>
17 #include <pxd/reconstruction/PXDGainCalibrator.h>
18 
19 #include <TTree.h>
20 #include <TH1I.h>
21 #include <TH2F.h>
22 //#include <TEfficiency.h>
23 
24 #include <boost/format.hpp>
25 
26 using namespace std;
27 using boost::format;
28 using namespace Belle2;
29 using namespace Belle2::PXD;
30 
31 //-----------------------------------------------------------------
32 // Register the Module
33 //-----------------------------------------------------------------
34 REG_MODULE(PXDPerformanceCollector)
35 
36 //-----------------------------------------------------------------
37 // Implementation
38 //-----------------------------------------------------------------
39 
41  , m_pxd2TrackEvent(), m_signal(0), m_estimated(0.0), m_run(0), m_exp(0)
42 {
43  // Set module properties
44  setDescription("Calibration collector module for CDST data.");
45  setPropertyFlags(c_ParallelProcessingCertified);
46 
47  addParam("minPt", m_minPt, "Minimum pt cut", float(1.0));
48  addParam("minClusterCharge", m_minClusterCharge, "Minimum cluster charge cut", int(0));
49  addParam("minClusterSize", m_minClusterSize, "Minimum cluster size cut ", int(2));
50  addParam("maxClusterSize", m_maxClusterSize, "Maximum cluster size cut ", int(6));
51  addParam("nBinsU", m_nBinsU, "Number of gain corrections per sensor along u side", int(4));
52  addParam("nBinsV", m_nBinsV, "Number of gain corrections per sensor along v side", int(6));
53  addParam("gainPayloadName", m_gainName, "Payload name for Gain to be read from DB", string(""));
54  addParam("fillChargeRatioHistogram", m_fillChargeRatioHistogram,
55  "Flag to fill Ratio (cluster charge to the expected MPV) histograms", bool(true));
56  addParam("fillChargeTree", m_fillChargeTree, "Flag to fill cluster charge with the estimated MPV to TTree", bool(false));
57  addParam("fillEventTree", m_fillEventTree, "Flag to fill event tree for validation", bool(false));
58 
59  // additional parameters for validation. Considering modularAnalysis for more flexible controls.
60  addParam("minPt4Eff", m_minPt4Eff, "Minimum pt cut for efficiency validation", float(2.0));
61  addParam("maxAbsVx", m_maxAbsVx, "Minimum abs(Vx) cut in cm for efficiency validation", float(0.03));
62  addParam("maxAbsVy", m_maxAbsVy, "Minimum abs(Vy) cut in cm for efficiency validation", float(0.03));
63  addParam("maxAbsVz", m_maxAbsVz, "Minimum abs(Vz) cut in cm for efficiency validation", float(0.155));
64 
65  addParam("minPt4Res", m_minPt4Res, "Minimum pt cut for resolution validation", float(1.0));
66  addParam("minSVDHits", m_minSVDHits, "Minimum number of SVD hits foor resolution validation", int(8));
67  addParam("minCDCHits", m_minCDCHits, "Minimum number of CDC hits foor resolution validation", int(21));
68  addParam("maxAbsLambda", m_maxAbsLambda, "Maximum absolute dip angle (lambda)", float(0.5));
69  addParam("minPBetaSinTheta3o2", m_minPBetaSinTheta3o2, "Minimum p*Beta*sin(theta_0)^{3/2}", float(2));
70  addParam("maxAbsZ0", m_maxAbsZ0, "Maximum abs(z0)", float(1));
71  addParam("maxAbsD0", m_maxAbsD0, "Maximum abs(d0)", float(0.3));
72 
73 
74 }
75 
76 void PXDPerformanceCollectorModule::prepare() // Do your initialise() stuff here
77 {
78  m_pxd2TrackEvents.isRequired(m_store2TrackEventsName);
79 
80  if (m_nBinsU == 0) {
81  B2WARNING("Number of bins along u side incremented from 0->1");
82  m_nBinsU = 1;
83  }
84 
85  if (m_nBinsV == 0) {
86  B2WARNING("Number of bins along v side incremented from 0->1");
87  m_nBinsV = 1;
88  }
89 
90  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
91  int nPXDSensors = gTools->getNumberOfPXDSensors();
92 
93  //-------------------------------------------------------------------------------------
94  // PXDClusterCounter: Count the number of PXDClusters and store charge for each uBin/vBin pair
95  //-------------------------------------------------------------------------------------
96 
97  auto hPXDClusterCounter = new TH1I("hPXDClusterCounter", "Number of clusters found in data sample",
98  m_nBinsU * m_nBinsV * nPXDSensors, 0,
99  m_nBinsU * m_nBinsV * nPXDSensors);
100  hPXDClusterCounter->GetXaxis()->SetTitle("bin id");
101  hPXDClusterCounter->GetYaxis()->SetTitle("Number of clusters");
102  auto hPXDClusterChargeRatio = new TH2F("hPXDClusterChargeRatio", "Charge ratio of clusters found in data sample",
103  m_nBinsU * m_nBinsV * nPXDSensors, 0,
104  m_nBinsU * m_nBinsV * nPXDSensors,
105  400, 0., 4.);
106  hPXDClusterChargeRatio->GetXaxis()->SetTitle("bin id");
107  hPXDClusterChargeRatio->GetYaxis()->SetTitle("Cluster charge ratio (relative to expected MPV)");
108  //auto hPXDTrackClusterCounter = new TH1I("hPXDTrackClusterCounter", "Number of clusters found in data sample",
109  //m_nBinsU * m_nBinsV * nPXDSensors, 0,
110  //m_nBinsU * m_nBinsV * nPXDSensors);
111  //hPXDTrackClusterCounter->GetXaxis()->SetTitle("bin id");
112  //hPXDTrackClusterCounter->GetYaxis()->SetTitle("Number of clusters");
113  //auto hPXDTrackPointCounter = new TH1I("hPXDTrackPointCounter", "Number of clusters found in data sample",
114  //m_nBinsU * m_nBinsV * nPXDSensors, 0,
115  //m_nBinsU * m_nBinsV * nPXDSensors);
116  //hPXDTrackPointCounter->GetXaxis()->SetTitle("bin id");
117  //hPXDTrackPointCounter->GetYaxis()->SetTitle("Number of clusters");
118  for (int iSensor = 0; iSensor < nPXDSensors; iSensor++) {
119  for (int uBin = 0; uBin < m_nBinsU; uBin++) {
120  for (int vBin = 0; vBin < m_nBinsV; vBin++) {
121  VxdID id = gTools->getSensorIDFromPXDIndex(iSensor);
122  string sensorDescr = id;
123  hPXDClusterCounter->GetXaxis()->SetBinLabel(iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin + 1,
124  str(format("%1%_%2%_%3%") % sensorDescr % uBin % vBin).c_str());
125  if (m_fillChargeRatioHistogram)
126  hPXDClusterChargeRatio->GetXaxis()->SetBinLabel(iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin + 1,
127  str(format("%1%_%2%_%3%") % sensorDescr % uBin % vBin).c_str());
128  //hPXDTrackClusterCounter->GetXaxis()->SetBinLabel(iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin + 1,
129  //str(format("%1%_%2%_%3%") % sensorDescr % uBin % vBin).c_str());
130  //hPXDTrackPointCounter->GetXaxis()->SetBinLabel(iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin + 1,
131  //str(format("%1%_%2%_%3%") % sensorDescr % uBin % vBin).c_str());
132  }
133  }
134  }
135 
136  registerObject<TH1I>("PXDClusterCounter", hPXDClusterCounter);
137  if (m_fillChargeRatioHistogram)
138  registerObject<TH2F>("PXDClusterChargeRatio", hPXDClusterChargeRatio);
139 
140  //-------------------------------------------------------------------------------------
141  // PXDTrackClusterCounter: Count the number of PXDClustersFrom tracks (the same track selection as for track points)
142  //-------------------------------------------------------------------------------------
143  auto hPXDTrackClusterCounter = (TH1I*)hPXDClusterCounter->Clone("hPXDTrackClusterCounter");
144  hPXDTrackClusterCounter->SetTitle("Number of track clusters");
145  hPXDTrackClusterCounter->GetYaxis()->SetTitle("Number of track clusters");
146  registerObject<TH1I>("PXDTrackClusterCounter", hPXDTrackClusterCounter);
147 
148  //-------------------------------------------------------------------------------------
149  // PXDTrackPointCounter: Count the number of PXDClustersFrom tracks (the same track selection as for track points)
150  //-------------------------------------------------------------------------------------
151  auto hPXDTrackPointCounter = (TH1I*)hPXDClusterCounter->Clone("hPXDTrackPointCounter");
152  hPXDTrackPointCounter->SetTitle("Number of track points");
153  hPXDTrackPointCounter->GetYaxis()->SetTitle("Number of track points");
154  registerObject<TH1I>("PXDTrackPointCounter", hPXDTrackPointCounter);
155 
156  //----------------------------------------------------------------------
157  // PXDTrees for gain calibration: One tree to store the calibration data for each grid bin
158  //----------------------------------------------------------------------
159 
160  if (m_fillChargeTree) // only fill the tree when required
161  for (int iSensor = 0; iSensor < nPXDSensors; iSensor++) {
162  for (int uBin = 0; uBin < m_nBinsU; uBin++) {
163  for (int vBin = 0; vBin < m_nBinsV; vBin++) {
164  VxdID id = gTools->getSensorIDFromPXDIndex(iSensor);
165  auto layerNumber = id.getLayerNumber();
166  auto ladderNumber = id.getLadderNumber();
167  auto sensorNumber = id.getSensorNumber();
168  string treename = str(format("tree_%1%_%2%_%3%_%4%_%5%") % layerNumber % ladderNumber % sensorNumber % uBin % vBin);
169  auto tree = new TTree(treename.c_str(), treename.c_str());
170  tree->Branch<int>("signal", &m_signal);
171  tree->Branch<float>("estimated", &m_estimated);
172  registerObject<TTree>(treename, tree);
173  }
174  }
175  }
176 
177  // TEfficiency for validation, no Reset() and may be questionable for merging
178  //auto effPXDLayer1 = new TEfficiency("PXDLayer1Efficiency", "Efficiency of PXD innner layer;#phi;#z [cm];#epsilon", 730, -M_PI, M_PI, 400, -3.2, 6.2);
179  //auto effPXDLayer2 = new TEfficiency("PXDLayer2Efficiency", "Efficiency of PXD outer layer;#phi;#z [cm];#epsilon", 128, 1.4, 2.5, 400, -4.2, 8.2);
180  //registerObject<TEfficiency>("PXDLayer1Efficiency", effPXDLayer1);
181  //registerObject<TEfficiency>("PXDLayer2Efficiency", effPXDLayer2);
182  auto hTotalHitsLayer1 = new TH2F("hTotalHitsLayer1", "Total number of hits from layer 1;#phi;z [cm]", 730, -M_PI, M_PI, 400,
183  -3.2, 6.2);
184  auto hPassedHitsLayer1 = new TH2F("hPassedHitsLayer1", "Passed number of hits from layer 1;#phi;z [cm]", 730, -M_PI, M_PI, 400,
185  -3.2, 6.2);
186  auto hTotalHitsLayer2 = new TH2F("hTotalHitsLayer2", "Total number of hits from layer 2;#phi;z [cm]", 128, 1.4, 2.5, 400,
187  -4.2, 8.2);
188  auto hPassedHitsLayer2 = new TH2F("hPassedHitsLayer2", "Passed number of hits from layer 2;#phi;z [cm]", 128, 1.4, 2.5, 400,
189  -4.2, 8.2);
190  registerObject<TH2F>("hTotalHitsLayer1", hTotalHitsLayer1);
191  registerObject<TH2F>("hPassedHitsLayer1", hPassedHitsLayer1);
192  registerObject<TH2F>("hTotalHitsLayer2", hTotalHitsLayer2);
193  registerObject<TH2F>("hPassedHitsLayer2", hPassedHitsLayer2);
194 
195  // trees for correctd d0 and z0 to the IP
196  auto treeD0Z0 = new TTree("tree_d0z0", "TTree of corrected d0 and z0");
197  treeD0Z0->Branch<float>("d0", &m_deltaD0oSqrt2);
198  treeD0Z0->Branch<float>("z0", &m_deltaZ0oSqrt2);
199  registerObject<TTree>("tree_d0z0", treeD0Z0);
200 
201  // dbtree
202  auto dbtree = new TTree("dbtree", "dbtree");
203  dbtree->Branch<int>("run", &m_run);
204  dbtree->Branch<int>("exp", &m_exp);
205  dbtree->Branch<PXDGainMapPar>("gainMap", &m_gainMap);
206  registerObject<TTree>("dbtree", dbtree);
207 
208  if (m_fillEventTree) {
209  auto tree = new TTree("pxd", "PXD 2-track events");
210  tree->Branch<PXD2TrackEvent>("PXD2TrackEvent", &m_pxd2TrackEvent, 8000, 1);
211  registerObject<TTree>("pxd", tree);
212  }
213 }
214 
215 void PXDPerformanceCollectorModule::startRun() // Do your beginRun() stuff here
216 {
217  m_run = m_evtMetaData->getRun();
218  m_exp = m_evtMetaData->getExperiment();
219  if (m_gainName.length()) {
220  DBObjPtr<PXDGainMapPar> gainMap(m_gainName);
221  m_gainMap = *gainMap;
222  } else {
223  m_gainMap = PXDGainMapPar();
224  }
225  getObjectPtr<TTree>("dbtree")->Fill();
226 }
227 
228 void PXDPerformanceCollectorModule::collect() // Do your event() stuff here
229 {
230  // If no input, nothing to do
231  if (!m_pxd2TrackEvents) return;
232 
233  // Beam spot
234  DBObjPtr<BeamSpot> beamSpotDB;
235  auto ip = beamSpotDB->getIPPosition();
236 
237  // Actually only one event holder / event
238  for (auto& pxd2TrackEvent : m_pxd2TrackEvents) {
239  m_selectedRes = true;
240  m_selectedEff = true;
241 
242  auto vertex = pxd2TrackEvent.getVertex();
243  vertex -= ip; // correct vertex relative to ip
244  if (fabs(vertex.X()) > m_maxAbsVx ||
245  fabs(vertex.Y()) > m_maxAbsVy ||
246  fabs(vertex.Z()) > m_maxAbsVz)
247  m_selectedEff = false;
248 
249  // track level selection and collection
250  collectFromTrack(pxd2TrackEvent.getTrackP());
251  collectFromTrack(pxd2TrackEvent.getTrackM());
252 
253  // event level collection
254  collectDeltaIP(pxd2TrackEvent);
255 
256  if (m_fillEventTree) {
257  m_pxd2TrackEvent = pxd2TrackEvent;
258  getObjectPtr<TTree>("pxd")->Fill();
259  }
260  }
261 
262 }
263 
264 void PXDPerformanceCollectorModule::collectDeltaIP(const PXD2TrackEvent& event)
265 {
266  if (!m_selectedRes) return;
267  auto d0p_1 = event.getTrackP().d0p;
268  auto d0p_2 = event.getTrackM().d0p;
269  auto z0p_1 = event.getTrackP().z0p;
270  auto z0p_2 = event.getTrackM().z0p;
271  m_deltaD0oSqrt2 = (d0p_1 + d0p_2) / sqrt(2.);
272  m_deltaZ0oSqrt2 = (z0p_1 - z0p_2) / sqrt(2.);
273 
274  // Fill the tree of impact parameters
275  getObjectPtr<TTree>("tree_d0z0")->Fill();
276 }
277 
278 void PXDPerformanceCollectorModule::collectFromTrack(const PXD2TrackEvent::baseType& track)
279 {
280  auto gTools = VXD::GeoCache::getInstance().getGeoTools();
281  bool selected4Gain = true;
282  bool selected4Eff = true;
283 
284  if (track.pt < m_minPt) selected4Gain = false;
285  if (track.pt < m_minPt4Eff) selected4Eff = false; // just applied on track level
286 
287  // Track level filtering for resolution validation
288  if (track.pt < m_minPt4Res) m_selectedRes = false;
289  if (track.nPXDHits < 1 || track.nCDCHits < m_minCDCHits || track.nSVDHits < m_minSVDHits)
290  m_selectedRes = false;
291  if (fabs(track.d0p) > m_maxAbsD0 || fabs(track.z0p) > m_maxAbsZ0)
292  m_selectedRes = false;
293  auto lambda0 = atan(track.tanLambda);
294  if (fabs(lambda0) > m_maxAbsLambda)
295  m_selectedRes = false;
296  auto sinTheta0 = 1. / sqrt(1. + pow(track.tanLambda, 2));
297  auto pBetaSinTheta3o2 = track.pt * 1.0 * sqrt(sinTheta0);
298  if (pBetaSinTheta3o2 < m_minPBetaSinTheta3o2)
299  m_selectedRes = false;
300 
301  for (auto& trackCluster : track.trackClusters) {
302  bool selectedCluster = true;
303  auto cluster = trackCluster.cluster;
304  auto intersection = trackCluster.intersection;
305  auto usedInTrack = trackCluster.usedInTrack;
306 
307  // Check for valid cluster and intersection
308  if (!usedInTrack || intersection.chargeMPV <= 0)
309  selectedCluster = false;
310 
311  // Apply cluster selection cuts
312  if (cluster.charge < m_minClusterCharge || cluster.size < m_minClusterSize || cluster.size > m_maxClusterSize)
313  selectedCluster = false;
314 
315  if (cluster.pxdID <= 0) {
316  B2FATAL("Unexpected cluster module id : " << cluster.pxdID);
317 
318  }
319 
320  // Fill tree or histograms for gain calibration
321  if (selected4Gain && selectedCluster) {
322 
323  // Compute variables from cluster needed for gain estimation
324  m_signal = cluster.charge;
325  m_estimated = intersection.chargeMPV;
326 
327  VxdID sensorID = getVxdIDFromPXDModuleID(cluster.pxdID);
328  const PXD::SensorInfo& Info = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::get(sensorID));
329  auto uID = Info.getUCellID(cluster.posU);
330  auto vID = Info.getVCellID(cluster.posV);
331  auto iSensor = gTools->getPXDSensorIndex(sensorID);
332  auto layerNumber = sensorID.getLayerNumber();
333  auto ladderNumber = sensorID.getLadderNumber();
334  auto sensorNumber = sensorID.getSensorNumber();
335  auto uBin = PXD::PXDGainCalibrator::getInstance().getBinU(sensorID, uID, vID, m_nBinsU);
336  auto vBin = PXD::PXDGainCalibrator::getInstance().getBinV(sensorID, vID, m_nBinsV);
337  // Calculate bin ID based on iSensor, uBin, vBin and number of bins in u/v
338  int binID = iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin;
339 
340  // Increment the counter
341  getObjectPtr<TH1I>("PXDClusterCounter")->Fill(binID);
342 
343  // Fill variabels into tree
344  if (m_fillChargeTree) {
345  string treename = str(format("tree_%1%_%2%_%3%_%4%_%5%") % layerNumber % ladderNumber % sensorNumber % uBin % vBin);
346  getObjectPtr<TTree>(treename)->Fill();
347  }
348 
349  // Fill cluster charge ratio histogram if enabled
350  if (m_fillChargeRatioHistogram) {
351  double ratio = m_signal / m_estimated;
352  auto axis = getObjectPtr<TH2F>("PXDClusterChargeRatio")->GetYaxis();
353  double maxY = axis->GetBinCenter(axis->GetNbins());
354  // Manipulate too large ratio for better estimation on median.
355  getObjectPtr<TH2F>("PXDClusterChargeRatio")->Fill(binID, TMath::Min(ratio, maxY));
356  }
357  }
358 
359  // Fill effciency
360  if (m_selectedEff && selected4Eff) {
361  auto x = intersection.x;
362  auto y = intersection.y;
363  auto phi = atan2(y, x);
364  auto z = intersection.z;
365 
366  // Get uBin and vBin from a global point.
367  VxdID sensorID = getVxdIDFromPXDModuleID(cluster.pxdID);
368  const PXD::SensorInfo& Info = dynamic_cast<const PXD::SensorInfo&>(VXD::GeoCache::get(sensorID));
369  auto localPoint = Info.pointToLocal(TVector3(x, y, z));
370  auto uID = Info.getUCellID(localPoint.X());
371  auto vID = Info.getVCellID(localPoint.Y());
372  auto iSensor = gTools->getPXDSensorIndex(sensorID);
373  auto uBin = PXD::PXDGainCalibrator::getInstance().getBinU(sensorID, uID, vID, m_nBinsU);
374  auto vBin = PXD::PXDGainCalibrator::getInstance().getBinV(sensorID, vID, m_nBinsV);
375 
376  // Filling counters
377  getObjectPtr<TH1I>("PXDTrackPointCounter")->Fill(iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin);
378  if (usedInTrack)
379  getObjectPtr<TH1I>("PXDTrackClusterCounter")->Fill(iSensor * m_nBinsU * m_nBinsV + uBin * m_nBinsV + vBin);
380 
381  // Filling 2D histograms
382  if (cluster.pxdID < 2000) {
383  //getObjectPtr<TEfficiency>("PXDLayer1Efficiency")->Fill(usedInTrack,phi,z);
384  getObjectPtr<TH2F>("hTotalHitsLayer1")->Fill(phi, z);
385  if (usedInTrack)
386  getObjectPtr<TH2F>("hPassedHitsLayer1")->Fill(phi, z);
387  } else {
388  //getObjectPtr<TEfficiency>("PXDLayer2Efficiency")->Fill(usedInTrack,phi,z);
389  getObjectPtr<TH2F>("hTotalHitsLayer2")->Fill(phi, z);
390  if (usedInTrack)
391  getObjectPtr<TH2F>("hPassedHitsLayer2")->Fill(phi, z);
392  }
393  }
394 
395  } // end loop trackClusters
396 
397 }
Belle2::CalibrationCollectorModule
Calibration collector module base class.
Definition: CalibrationCollectorModule.h:44
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::VXD::SensorInfoBase::getUCellID
int getUCellID(double u, double v=0, bool clamp=false) const
Return the corresponding pixel/strip ID of a given u coordinate.
Definition: SensorInfoBase.h:203
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::VxdID::getLadderNumber
baseType getLadderNumber() const
Get the ladder id.
Definition: VxdID.h:108
Belle2::PXDGainMapPar
The payload class for PXD gain corrections.
Definition: PXDGainMapPar.h:53
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:31
Belle2::PXD::SensorInfo
Specific implementation of SensorInfo for PXD Sensors which provides additional pixel specific inform...
Definition: SensorInfo.h:34
Belle2::PXD::getVxdIDFromPXDModuleID
VxdID getVxdIDFromPXDModuleID(const unsigned short &id)
Helper function to get VxdID from DHE id like module iid.
Definition: PXDUtilities.h:97
Belle2::PXD
Namespace to encapsulate code needed for simulation and reconstrucion of the PXD.
Definition: PXDCalibrationUtilities.h:28
Belle2::VXD::SensorInfoBase::getVCellID
int getVCellID(double v, bool clamp=false) const
Return the corresponding pixel/strip ID of a given v coordinate.
Definition: SensorInfoBase.h:213
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::PXDPerformanceCollectorModule
Collector module for PXD gain calibration and PXD calibration validation.
Definition: PXDPerformanceCollectorModule.h:56
Belle2::VxdID::getSensorNumber
baseType getSensorNumber() const
Get the sensor id.
Definition: VxdID.h:110
Belle2::VXD::SensorInfoBase::pointToLocal
TVector3 pointToLocal(const TVector3 &global, bool reco=false) const
Convert a point from global to local coordinates.
Definition: SensorInfoBase.h:393
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:106
Belle2::PXD2TrackEvent
Class PXD2TrackEvent: Event data container for performance and calibration studies.
Definition: PXD2TrackEvent.h:41