Belle II Software  release-05-01-25
PXDDQMEfficiencySelftrackModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2013 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Bjoern Spruck *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <pxd/modules/pxdDQM/PXDDQMEfficiencySelftrackModule.h>
12 #include <tracking/dataobjects/ROIid.h>
13 
14 #include <pxd/reconstruction/PXDPixelMasker.h>
15 #include <mdst/dataobjects/Track.h>
16 #include <framework/gearbox/Const.h>
17 
18 #include "TDirectory.h"
19 #include "TMatrixDSym.h"
20 using namespace Belle2;
21 
22 //-----------------------------------------------------------------
23 // Register the Module
24 //-----------------------------------------------------------------
25 REG_MODULE(PXDDQMEfficiencySelftrack)
26 
27 //-----------------------------------------------------------------
28 // Implementation
29 //-----------------------------------------------------------------
30 
31 PXDDQMEfficiencySelftrackModule::PXDDQMEfficiencySelftrackModule() : HistoModule(), m_vxdGeometry(VXD::GeoCache::getInstance())
32 {
33  // Set module properties
34  setDescription("Create basic histograms for PXD efficiency");
35 
36  // What exactly is needed for this to be true?
37  setPropertyFlags(c_ParallelProcessingCertified);
38 
39  // Parameter definitions
40  addParam("pxdClustersName", m_pxdClustersName, "name of StoreArray with PXD cluster", std::string(""));
41  addParam("tracksName", m_tracksName, "name of StoreArray with RecoTracks", std::string(""));
42  addParam("ROIsName", m_ROIsName, "name of the list of HLT ROIs, if available in output", std::string(""));
43  addParam("histogramDirectoryName", m_histogramDirectoryName, "Name of the directory where histograms will be placed",
44  std::string("PXDEFF"));
45  addParam("binsU", m_u_bins, "histogram bins in u direction", int(4));
46  addParam("binsV", m_v_bins, "histogram bins in v direction", int(6));
47  addParam("distCut", m_distcut, "max distance in [cm] for cluster to be counted to a track", double(0.0500));
48  addParam("pCut", m_pcut, "Set a cut on the track p-value", double(1e-20));
49  addParam("requireROIs", m_requireROIs, "require tracks to lie inside a ROI", bool(false));
50  addParam("useAlignment", m_useAlignment, "if true the alignment will be used", bool(true));
51  addParam("maskDeadPixels", m_maskDeadPixels, "Do not consider tracks going through known dead or hot pixels for the efficiency",
52  bool(false));
53  addParam("minSVDHits", m_minSVDHits, "Number of SVD hits required in a track to be considered", 0u);
54  addParam("momCut", m_momCut, "Set a cut on the track momentum in GeV/c, 0 disables", double(0));
55  addParam("pTCut", m_pTCut, "Set a cut on the track pT in GeV/c, 0 disables", double(1));
56  addParam("cutBorders", m_cutBorders, "Do not use tracks near the borders of the sensor", bool(true));
57  addParam("maskedDistance", m_maskedDistance, "Distance inside which no masked pixel or sensor border is allowed", int(10));
58  addParam("trackUFactorDistCut", m_uFactor, "Set a cut on u error of track (factor*err<dist), 0 disables", double(2.0));
59  addParam("trackVFactorDistCut", m_vFactor, "Set a cut on v error of track (factor*err<dist), 0 disables", double(2.0));
60  addParam("z0minCut", m_z0minCut, "Set a cut z0 minimum in cm (large negativ value eg -9999 disables)", double(-1));
61  addParam("z0maxCut", m_z0maxCut, "Set a cut z0 maximum in cm (large positiv value eg 9999 disables)", double(1));
62  addParam("d0Cut", m_d0Cut, "Set a cut abs(d0) in cm (and negativ value eg -9999 disables)", double(0.5));
63  addParam("verboseHistos", m_verboseHistos, "Add more verbose histograms for cuts (not for ereoc)", bool(false));
64 }
65 
66 
68 {
69  //calls the define histogram function
70  REG_HISTOGRAM;
71 
72  //register the required arrays
73  //Register as optional so validation for cases where they are not available still succeeds, but module will not do any meaningful work without them
74  m_pxdclusters.isOptional(m_pxdClustersName);
75  m_tracks.isOptional(m_tracksName);
76  m_ROIs.isOptional(m_ROIsName);
77 }
78 
80 {
81  for (auto& h : m_h_track_hits) if (h.second) h.second->Reset();
82  for (auto& h : m_h_matched_cluster) if (h.second) h.second->Reset();
83  for (auto& h : m_h_p) if (h.second) h.second->Reset();
84  for (auto& h : m_h_pt) if (h.second) h.second->Reset();
85  for (auto& h : m_h_su) if (h.second) h.second->Reset();
86  for (auto& h : m_h_sv) if (h.second) h.second->Reset();
87  for (auto& h : m_h_p2) if (h.second) h.second->Reset();
88  for (auto& h : m_h_pt2) if (h.second) h.second->Reset();
89  for (auto& h : m_h_su2) if (h.second) h.second->Reset();
90  for (auto& h : m_h_sv2) if (h.second) h.second->Reset();
91 }
92 
94 {
95  if (!m_pxdclusters.isValid()) {
96  B2INFO("PXDClusters array is missing, no efficiencies");
97  return;
98  }
99  if (!m_tracks.isValid()) {
100  B2INFO("RecoTrack array is missing, no efficiencies");
101  return;
102  }
103  if (!m_ROIs.isValid() && m_requireROIs) {
104  B2INFO("ROI array is missing but required hits in ROIs, aborting");
105  return;
106  }
107 
108 
109  for (auto& a_track : m_tracks) {
110 
111  //If fit failed assume position pointed to is useless anyway
112  if (!a_track.wasFitSuccessful()) continue;
113 
114  if (a_track.getNumberOfSVDHits() < m_minSVDHits) continue;
115 
116  const genfit::FitStatus* fitstatus = a_track.getTrackFitStatus();
117  if (fitstatus->getPVal() < m_pcut) continue;
118 
119  genfit::MeasuredStateOnPlane trackstate;
120  trackstate = a_track.getMeasuredStateOnPlaneFromFirstHit();
121  if (trackstate.getMom().Mag() < m_momCut) continue;
122  if (trackstate.getMom().Pt() < m_pTCut) continue;
123 
124  auto ptr = a_track.getRelated<Track>("Tracks");
125 
126  if (!ptr) {
127  B2ERROR("expect a track for fitted recotracks");
128  continue;
129  }
130  auto ptr2 = ptr->getTrackFitResultWithClosestMass(Const::pion);
131  if (!ptr2) {
132  B2ERROR("expect a track fit result for mass");
133  continue;
134  }
135 
136  // Vertex cut
137  if (ptr2->getZ0() < m_z0minCut || ptr2->getZ0() > m_z0maxCut || fabs(ptr2->getD0()) > m_d0Cut) continue;
138 
139  //loop over all PXD sensors to get the intersections
140  std::vector<VxdID> sensors = m_vxdGeometry.getListOfSensors();
141  for (VxdID& aVxdID : sensors) {
143  if (info.getType() != VXD::SensorInfoBase::PXD) continue;
144  //Search for intersections of the track with all PXD layers
145  //Traditional (aka the person before did it like this) method
146  //If there is a way to find out sensors crossed by a track directly, that would most likely be faster
147 
148  bool isgood = false;
149  //true = track intersects current sensor
150  double sigu(-9999);
151  double sigv(-9999);
152  TVector3 intersec_buff = getTrackInterSec(info, a_track, isgood, sigu, sigv);
153 
154  if (!isgood) {
155  continue;//track does not go through this sensor-> nothing to measure anyway
156  } else {
157  if (m_verboseHistos) {
158  if (m_h_p[aVxdID]) m_h_p[aVxdID]->Fill(trackstate.getMom().Mag());
159  if (m_h_pt[aVxdID]) m_h_pt[aVxdID]->Fill(trackstate.getMom().Pt());
160  if (m_h_su[aVxdID]) m_h_su[aVxdID]->Fill(sigu);
161  if (m_h_sv[aVxdID]) m_h_sv[aVxdID]->Fill(sigv);
162  }
163  if (m_uFactor * sigu > m_distcut) continue; // Error ufak*SigmaU > cut
164  if (m_vFactor * sigv > m_distcut) continue; // Error vfak*SigmaV > cut
165 
166  double u_fit = intersec_buff.X();
167  double v_fit = intersec_buff.Y();
168 
169  int ucell_fit = info.getUCellID(intersec_buff.X());
170  int vcell_fit = info.getVCellID(intersec_buff.Y());
171 
172  if (m_cutBorders && isCloseToBorder(ucell_fit, vcell_fit, m_maskedDistance)) {
173  continue;
174  }
175 
176  if (m_maskDeadPixels && isDeadPixelClose(ucell_fit, vcell_fit, m_maskedDistance, aVxdID)) {
177  continue;
178  }
179 
180  if (m_requireROIs) {
181  //Check if the intersection is inside a ROI
182  //If not, even if measured the cluster was thrown away->Not PXD's fault
183  bool fitInsideROI = false;
184  for (auto& roit : m_ROIs) {
185  if (aVxdID != roit.getSensorID()) {
186  continue; //ROI on other sensor
187  }
188 
189  if (ucell_fit < roit.getMaxUid()
190  && ucell_fit > roit.getMinUid()
191  && vcell_fit < roit.getMaxVid()
192  && vcell_fit > roit.getMinVid()) {
193  fitInsideROI = true;
194  }
195  }
196  if (!fitInsideROI) {
197  continue;//Hit wouldn't have been recorded
198  }
199  }
200 
201  //This track should be on the sensor
202  m_h_track_hits[aVxdID]->Fill(ucell_fit, vcell_fit);
203 
204  //Now check if the sensor measured a hit here
205 
206  int bestcluster = findClosestCluster(aVxdID, intersec_buff);
207  if (bestcluster >= 0) {
208  double u_clus = m_pxdclusters[bestcluster]->getU();
209  double v_clus = m_pxdclusters[bestcluster]->getV();
210 
211  //is the closest cluster close enough to the track to count as measured?
212  TVector3 dist_clus(u_fit - u_clus, v_fit - v_clus, 0);
213  if (dist_clus.Mag() <= m_distcut) {
214  m_h_matched_cluster[aVxdID]->Fill(ucell_fit, vcell_fit);
215  if (m_verboseHistos) {
216  if (m_h_p2[aVxdID]) m_h_p2[aVxdID]->Fill(trackstate.getMom().Mag());
217  if (m_h_pt2[aVxdID]) m_h_pt2[aVxdID]->Fill(trackstate.getMom().Pt());
218  if (m_h_su2[aVxdID]) m_h_su2[aVxdID]->Fill(sigu);
219  if (m_h_sv2[aVxdID]) m_h_sv2[aVxdID]->Fill(sigv);
220  }
221  }
222  }
223  }
224  }
225  }
226 }
227 
228 
229 
231  bool& isgood,
232  double& du, double& dv)
233 {
234  //will be set true if the intersect was found
235  isgood = false;
236 
237  TVector3 intersec(99999999, 9999999, 0); //point outside the sensor
238 
240 
241  //adopted (aka stolen) from tracking/modules/pxdClusterRescue/PXDClusterRescueROIModule
242  try {
243  // get sensor plane
244  TVector3 zeroVec(0, 0, 0);
245  TVector3 uVec(1, 0, 0);
246  TVector3 vVec(0, 1, 0);
247 
248  genfit::DetPlane* sensorPlane = new genfit::DetPlane();
249  sensorPlane->setO(pxdSensorInfo.pointToGlobal(zeroVec, m_useAlignment));
250  sensorPlane->setUV(pxdSensorInfo.vectorToGlobal(uVec, m_useAlignment), pxdSensorInfo.vectorToGlobal(vVec, m_useAlignment));
251 
252  //boost pointer (will be deleted automatically ?!?!?)
253  genfit::SharedPlanePtr sensorPlaneSptr(sensorPlane);
254 
255  // do extrapolation
256  gfTrackState.extrapolateToPlane(sensorPlaneSptr);
257  } catch (genfit::Exception& gfException) {
258  B2WARNING("Fitting failed: " << gfException.getExcString());
259  isgood = false;
260  return intersec;
261  } catch (...) {
262  B2WARNING("Fitting failed: for some reason");
263  isgood = false;
264  return intersec;
265  }
266 
267  //local position
268  intersec = pxdSensorInfo.pointToLocal(gfTrackState.getPos(), m_useAlignment);
269 
270  //try to get the momentum
271  B2DEBUG(1, "Fitted momentum on the plane p = " << gfTrackState.getMom().Mag());
272 
273  // no tolerance currently! Maybe one should be added!
274  double tolerance = 0.0;
275  bool inside = pxdSensorInfo.inside(intersec.X(), intersec.Y(), tolerance, tolerance);
276 
277  // get intersection point in local coordinates with covariance matrix
278  TMatrixDSym covMatrix = gfTrackState.getCov(); // 5D with elements q/p,u',v',u,v in plane system
279 
280  // get ROI by covariance matrix and local intersection point
281  du = std::sqrt(covMatrix(3, 3));
282  dv = std::sqrt(covMatrix(4, 4));
283 
284  if (inside) isgood = true;
285 
286  return intersec;
287 }
288 
289 
291 {
292  // Create a separate histogram directory and cd into it.
293  TDirectory* oldDir = gDirectory;
294  if (m_histogramDirectoryName != "") {
295  oldDir->mkdir(m_histogramDirectoryName.c_str());
296  oldDir->cd(m_histogramDirectoryName.c_str());
297  }
298 
299  std::vector<VxdID> sensors = m_vxdGeometry.getListOfSensors();
300  for (VxdID& avxdid : sensors) {
302  if (info.getType() != VXD::SensorInfoBase::PXD) continue;
303  //Only interested in PXD sensors
304 
305  TString buff = (std::string)avxdid;
306  buff.ReplaceAll(".", "_");
307 
308  int nu = info.getUCells();
309  int nv = info.getVCells();
310 
311  //nu + 1,nv + 1 Bin numbers when using one bin per pixel
312  m_h_track_hits[avxdid] = new TH2F("track_hits_" + buff, "tracks through sensor " + buff,
313  m_u_bins, -0.5, nu - 0.5, m_v_bins, -0.5, nv - 0.5);
314  m_h_matched_cluster[avxdid] = new TH2F("matched_cluster_" + buff, "clusters matched to track intersections " + buff,
315  m_u_bins, -0.5, nu - 0.5, m_v_bins, -0.5, nv - 0.5);
316 
317  if (m_verboseHistos) {
318  m_h_p[avxdid] = new TH1F("p_" + buff, "p " + buff, 100, 0, 10);
319  m_h_pt[avxdid] = new TH1F("pt_" + buff, "pt " + buff, 100, 0, 10);
320  m_h_su[avxdid] = new TH1F("su_" + buff, "su " + buff, 1000, 0, 1);
321  m_h_sv[avxdid] = new TH1F("sv_" + buff, "sv " + buff, 1000, 0, 1);
322  m_h_p2[avxdid] = new TH1F("p2_" + buff, "p2 " + buff, 100, 0, 10);
323  m_h_pt2[avxdid] = new TH1F("pt2_" + buff, "pt2 " + buff, 100, 0, 10);
324  m_h_su2[avxdid] = new TH1F("su2_" + buff, "su2 " + buff, 1000, 0, 1);
325  m_h_sv2[avxdid] = new TH1F("sv2_" + buff, "sv2 " + buff, 1000, 0, 1);
326  }
327  }
328  // cd back to root directory
329  oldDir->cd();
330 }
331 
332 
333 int
334 PXDDQMEfficiencySelftrackModule::findClosestCluster(const VxdID& avxdid, TVector3 intersection)
335 {
336  int closest = -1;
337  double mindist = 999999999999; //definitely outside of the sensor
338 
340 
341  //loop the clusters
342  for (int iclus = 0; iclus < m_pxdclusters.getEntries(); iclus++) {
343  //Do not consider as different if only segment differs!
344  //As of this writing segment is never filled for clusters, but just to be sure
345  VxdID clusterID = m_pxdclusters[iclus]->getSensorID();
346  if (avxdid.getLayerNumber() != clusterID.getLayerNumber() ||
347  avxdid.getLadderNumber() != clusterID.getLadderNumber() ||
348  avxdid.getSensorNumber() != clusterID.getSensorNumber()) {
349  continue;
350  }
351  //only cluster on the correct sensor and direction should survive
352 
353  double u = m_pxdclusters[iclus]->getU();
354  double v = m_pxdclusters[iclus]->getV();
355  TVector3 current(u, v, 0);
356 
357  //2D dist sqared
358  double dist = (intersection - current).Mag();
359  if (dist < mindist) {
360  closest = iclus;
361  mindist = dist;
362  }
363  }
364 
365  return closest;
366 
367 }
368 
369 bool PXDDQMEfficiencySelftrackModule::isCloseToBorder(int u, int v, int checkDistance)
370 {
371 
372  if (u - checkDistance < 0 || u + checkDistance >= 250 ||
373  v - checkDistance < 0 || v + checkDistance >= 768) {
374  return true;
375  }
376  return false;
377 }
378 
379 bool PXDDQMEfficiencySelftrackModule::isDeadPixelClose(int u, int v, int checkDistance, const VxdID& moduleID)
380 {
381 
382  //Iterate over square around the intersection to see if any close pixel is dead
383  for (int u_iter = u - checkDistance; u_iter <= u + checkDistance ; ++u_iter) {
384  for (int v_iter = v - checkDistance; v_iter <= v + checkDistance ; ++v_iter) {
385  if (PXD::PXDPixelMasker::getInstance().pixelDead(moduleID, u_iter, v_iter)
386  || !PXD::PXDPixelMasker::getInstance().pixelOK(moduleID, u_iter, v_iter)) {
387  return true;
388  }
389  }
390  }
391  return false;
392 }
genfit::Exception
Exception class for error handling in GENFIT (provides storage for diagnostic information)
Definition: Exception.h:48
Belle2::PXDDQMEfficiencySelftrackModule::m_pTCut
double m_pTCut
Cut on fitted track pT.
Definition: PXDDQMEfficiencySelftrackModule.h:139
Belle2::PXDDQMEfficiencySelftrackModule::isCloseToBorder
bool isCloseToBorder(int u, int v, int checkDistance)
is it close to the border
Definition: PXDDQMEfficiencySelftrackModule.cc:369
genfit::SharedPlanePtr
std::shared_ptr< genfit::DetPlane > SharedPlanePtr
Shared Pointer to a DetPlane.
Definition: SharedPlanePtr.h:40
Belle2::PXDDQMEfficiencySelftrackModule::m_ROIsName
std::string m_ROIsName
name of the store array of ROIs
Definition: PXDDQMEfficiencySelftrackModule.h:125
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::PXDDQMEfficiencySelftrackModule::m_h_track_hits
std::map< VxdID, TH2F * > m_h_track_hits
histograms of track hits
Definition: PXDDQMEfficiencySelftrackModule.h:147
Belle2::PXDDQMEfficiencySelftrackModule::getTrackInterSec
TVector3 getTrackInterSec(const VXD::SensorInfoBase &pxdSensorInfo, const RecoTrack &aTrack, bool &isgood, double &du, double &dv)
helper functions to do some of the calculations
Definition: PXDDQMEfficiencySelftrackModule.cc:230
genfit::MeasuredStateOnPlane
#StateOnPlane with additional covariance matrix.
Definition: MeasuredStateOnPlane.h:39
Belle2::PXDDQMEfficiencySelftrackModule::m_h_p2
std::map< VxdID, TH1F * > m_h_p2
histograms of p2
Definition: PXDDQMEfficiencySelftrackModule.h:153
Belle2::PXDDQMEfficiencySelftrackModule::findClosestCluster
int findClosestCluster(const VxdID &vxdid, TVector3 intersection)
find the closest cluster
Definition: PXDDQMEfficiencySelftrackModule.cc:334
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::PXDDQMEfficiencySelftrackModule::m_h_sv2
std::map< VxdID, TH1F * > m_h_sv2
histrograms of sv2
Definition: PXDDQMEfficiencySelftrackModule.h:156
Belle2::PXDDQMEfficiencySelftrackModule::m_maskDeadPixels
bool m_maskDeadPixels
mask dead pixels
Definition: PXDDQMEfficiencySelftrackModule.h:111
Belle2::PXDDQMEfficiencySelftrackModule::m_requireROIs
bool m_requireROIs
Require tracks going through ROIs.
Definition: PXDDQMEfficiencySelftrackModule.h:106
Belle2::RecoTrack::getMeasuredStateOnPlaneFromFirstHit
const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneFromFirstHit(const genfit::AbsTrackRep *representation=nullptr) const
Return genfit's MeasuredStateOnPlane for the first hit in a fit useful for extrapolation of measureme...
Definition: RecoTrack.cc:580
Belle2::PXDDQMEfficiencySelftrackModule::m_verboseHistos
bool m_verboseHistos
add some verbose histograms for cuts
Definition: PXDDQMEfficiencySelftrackModule.h:115
Belle2::PXDDQMEfficiencySelftrackModule::m_d0Cut
double m_d0Cut
cut abs(d0) in cm (and negativ value eg -9999 disables)
Definition: PXDDQMEfficiencySelftrackModule.h:143
Belle2::PXDDQMEfficiencySelftrackModule::m_tracksName
std::string m_tracksName
name of the store array of tracks
Definition: PXDDQMEfficiencySelftrackModule.h:124
Belle2::VxdID::getLadderNumber
baseType getLadderNumber() const
Get the ladder id.
Definition: VxdID.h:108
Belle2::PXDDQMEfficiencySelftrackModule::m_vxdGeometry
VXD::GeoCache & m_vxdGeometry
the geometry
Definition: PXDDQMEfficiencySelftrackModule.h:118
Belle2::VXD::SensorInfoBase::vectorToGlobal
TVector3 vectorToGlobal(const TVector3 &local, bool reco=false) const
Convert a vector from local to global coordinates.
Definition: SensorInfoBase.h:383
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:40
Belle2::PXDDQMEfficiencySelftrackModule::m_h_sv
std::map< VxdID, TH1F * > m_h_sv
histograms of sv
Definition: PXDDQMEfficiencySelftrackModule.h:152
Belle2::PXDDQMEfficiencySelftrackModule::m_useAlignment
bool m_useAlignment
if true alignment will be used!
Definition: PXDDQMEfficiencySelftrackModule.h:109
Belle2::PXDDQMEfficiencySelftrackModule::beginRun
void beginRun() override final
begin run function which resets histograms
Definition: PXDDQMEfficiencySelftrackModule.cc:79
Belle2::PXDDQMEfficiencySelftrackModule::m_pxdclusters
StoreArray< PXDCluster > m_pxdclusters
store array of pxd clusters
Definition: PXDDQMEfficiencySelftrackModule.h:130
Belle2::VXD::GeoCache::getListOfSensors
const std::vector< VxdID > getListOfSensors() const
Get list of all sensors.
Definition: GeoCache.cc:60
Belle2::PXDDQMEfficiencySelftrackModule::m_maskedDistance
int m_maskedDistance
Distance inside which no dead pixel or module border is allowed.
Definition: PXDDQMEfficiencySelftrackModule.h:144
Belle2::PXDDQMEfficiencySelftrackModule::m_minSVDHits
unsigned int m_minSVDHits
Required hits in SVD strips for tracks.
Definition: PXDDQMEfficiencySelftrackModule.h:140
Belle2::PXDDQMEfficiencySelftrackModule::m_momCut
double m_momCut
Cut on fitted track momentum.
Definition: PXDDQMEfficiencySelftrackModule.h:138
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:78
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:535
genfit::FitStatus::getPVal
virtual double getPVal() const
Get the p value of the fit.
Definition: FitStatus.h:128
Belle2::PXDDQMEfficiencySelftrackModule::m_h_su2
std::map< VxdID, TH1F * > m_h_su2
histrograms of su2
Definition: PXDDQMEfficiencySelftrackModule.h:155
Belle2::PXDDQMEfficiencySelftrackModule::m_h_pt2
std::map< VxdID, TH1F * > m_h_pt2
histograms of pt2
Definition: PXDDQMEfficiencySelftrackModule.h:154
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::PXDDQMEfficiencySelftrackModule::event
void event() override final
main function which fills trees and histograms
Definition: PXDDQMEfficiencySelftrackModule.cc:93
Belle2::PXDDQMEfficiencySelftrackModule::m_pcut
double m_pcut
pValue-Cut for tracks
Definition: PXDDQMEfficiencySelftrackModule.h:137
Belle2::PXDDQMEfficiencySelftrackModule::m_v_bins
int m_v_bins
the v bins
Definition: PXDDQMEfficiencySelftrackModule.h:128
Belle2::PXDDQMEfficiencySelftrackModule::m_z0minCut
double m_z0minCut
cut z0 minimum in cm (large negativ value eg -9999 disables)
Definition: PXDDQMEfficiencySelftrackModule.h:141
Belle2::StoreArray::isValid
bool isValid() const
Check wether the array was registered.
Definition: StoreArray.h:298
Belle2::PXDDQMEfficiencySelftrackModule::isDeadPixelClose
bool isDeadPixelClose(int u, int v, int checkDistance, const VxdID &moduleID)
is a dead pixel close
Definition: PXDDQMEfficiencySelftrackModule.cc:379
Belle2::VXD::SensorInfoBase::pointToGlobal
TVector3 pointToGlobal(const TVector3 &local, bool reco=false) const
Convert a point from local to global coordinates.
Definition: SensorInfoBase.h:373
Belle2::PXDDQMEfficiencySelftrackModule::m_vFactor
double m_vFactor
factor for track-error on distcut comparison
Definition: PXDDQMEfficiencySelftrackModule.h:136
Belle2::VxdID::getSensorNumber
baseType getSensorNumber() const
Get the sensor id.
Definition: VxdID.h:110
Belle2::PXDDQMEfficiencySelftrackModule::m_h_pt
std::map< VxdID, TH1F * > m_h_pt
histograms of transverse momenta
Definition: PXDDQMEfficiencySelftrackModule.h:150
Belle2::PXDDQMEfficiencySelftrackModule::m_h_matched_cluster
std::map< VxdID, TH2F * > m_h_matched_cluster
histograms of matched clusters
Definition: PXDDQMEfficiencySelftrackModule.h:148
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::PXDDQMEfficiencySelftrackModule::defineHisto
void defineHisto() override final
actually defines the trees and histograms
Definition: PXDDQMEfficiencySelftrackModule.cc:290
Belle2::VXD::SensorInfoBase::PXD
@ PXD
PXD Sensor.
Definition: SensorInfoBase.h:44
Belle2::PXDDQMEfficiencySelftrackModule
Creates the basic histograms for PXD Efficiency DQM Simplified and adopted version of the testbeam px...
Definition: PXDDQMEfficiencySelftrackModule.h:56
Belle2::PXDDQMEfficiencySelftrackModule::initialize
void initialize() override final
initializes the need store arrays, trees and histograms
Definition: PXDDQMEfficiencySelftrackModule.cc:67
Belle2::PXDDQMEfficiencySelftrackModule::m_pxdClustersName
std::string m_pxdClustersName
name of the store array of pxd clusters
Definition: PXDDQMEfficiencySelftrackModule.h:123
Belle2::PXDDQMEfficiencySelftrackModule::m_cutBorders
bool m_cutBorders
cut borders
Definition: PXDDQMEfficiencySelftrackModule.h:113
genfit::DetPlane
Detector plane.
Definition: DetPlane.h:59
Belle2::PXDDQMEfficiencySelftrackModule::m_histogramDirectoryName
std::string m_histogramDirectoryName
Where to save the histograms too.
Definition: PXDDQMEfficiencySelftrackModule.h:121
Belle2::VXD::GeoCache::getSensorInfo
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a referecne to the SensorInfo of a given SensorID.
Definition: GeoCache.cc:68
Belle2::Track
Class that bundles various TrackFitResults.
Definition: Track.h:35
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:106
Belle2::PXDDQMEfficiencySelftrackModule::m_distcut
double m_distcut
distance cut in cm!
Definition: PXDDQMEfficiencySelftrackModule.h:134
Belle2::PXDDQMEfficiencySelftrackModule::m_h_p
std::map< VxdID, TH1F * > m_h_p
histograms of momenta
Definition: PXDDQMEfficiencySelftrackModule.h:149
genfit::FitStatus
Class where important numbers and properties of a fit can be stored.
Definition: FitStatus.h:80
Belle2::PXDDQMEfficiencySelftrackModule::m_ROIs
StoreArray< ROIid > m_ROIs
store array of ROIs
Definition: PXDDQMEfficiencySelftrackModule.h:132
Belle2::PXDDQMEfficiencySelftrackModule::m_z0maxCut
double m_z0maxCut
cut z0 maximum in cm (large positiv value eg 9999 disables)
Definition: PXDDQMEfficiencySelftrackModule.h:142
Belle2::PXDDQMEfficiencySelftrackModule::m_uFactor
double m_uFactor
factor for track-error on distcut comparison
Definition: PXDDQMEfficiencySelftrackModule.h:135
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:226
Belle2::VXD::SensorInfoBase::inside
bool inside(double u, double v, double uTolerance=DBL_EPSILON, double vTolerance=DBL_EPSILON) const
Check wether a given point is inside the active area.
Definition: SensorInfoBase.h:238
Belle2::PXDDQMEfficiencySelftrackModule::m_u_bins
int m_u_bins
the u bins
Definition: PXDDQMEfficiencySelftrackModule.h:127
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29
Belle2::PXD::PXDPixelMasker::getInstance
static PXDPixelMasker & getInstance()
Main (and only) way to access the PXDPixelMasker.
Definition: PXDPixelMasker.cc:37
Belle2::PXDDQMEfficiencySelftrackModule::m_tracks
StoreArray< RecoTrack > m_tracks
store array of tracks
Definition: PXDDQMEfficiencySelftrackModule.h:131
Belle2::PXDDQMEfficiencySelftrackModule::m_h_su
std::map< VxdID, TH1F * > m_h_su
histograms of su
Definition: PXDDQMEfficiencySelftrackModule.h:151