Belle II Software  release-08-01-10
SVDPositionErrorScaleFactorImporterModule.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 
9 #include <svd/modules/svdCalibration/SVDPositionErrorScaleFactorImporterModule.h>
10 #include <svd/calibration/SVDCoGOnlyErrorScaleFactors.h>
11 #include <svd/calibration/SVDOldDefaultErrorScaleFactors.h>
12 #include <vxd/geometry/GeoCache.h>
13 #include <framework/datastore/StoreObjPtr.h>
14 #include <framework/datastore/StoreArray.h>
15 #include <framework/datastore/RelationVector.h>
16 #include <framework/datastore/RelationArray.h>
17 #include <framework/dataobjects/EventMetaData.h>
18 
19 using namespace Belle2;
20 
21 //-----------------------------------------------------------------
22 // Register the Module
23 //-----------------------------------------------------------------
24 REG_MODULE(SVDPositionErrorScaleFactorImporter);
25 
26 //-----------------------------------------------------------------
27 // Implementation
28 //-----------------------------------------------------------------
29 
30 SVDPositionErrorScaleFactorImporterModule::SVDPositionErrorScaleFactorImporterModule() : Module()
31 {
32  // Set module properties
33  setDescription("Module to produce a list of histograms showing the uploaded calibration constants");
34 
35  // Parameter definitions
36  addParam("outputFileName", m_rootFileName, "Name of output root file.", std::string("SVDPositionErrorScaleFactors.root"));
37  addParam("posAlgorithm", m_posAlgorithm, "Position Algorithm.", std::string(m_posAlgorithm));
38  addParam("uniqueID", m_uniqueID, "Payload uniqueID.", std::string(m_uniqueID));
39  addParam("minPulls", m_min, "min of the pulls histograms.", float(m_min));
40  addParam("maxPulls", m_max, "max of the pulls histograms.", float(m_max));
41  addParam("nBinsPulls", m_nBins, "number of bins of the pulls histograms.", float(m_nBins));
42  addParam("noOutliers", m_noOutliers, "If True, removes outliers from cluster position error scale factor computation.",
43  bool(false));
44 }
45 
46 void SVDPositionErrorScaleFactorImporterModule::initialize()
47 {
48  m_clusters.isRequired();
49  m_truehits.isRequired();
50 }
51 
52 void SVDPositionErrorScaleFactorImporterModule::beginRun()
53 {
54  //to avoid publicAllocationError:
55  delete m_rootFilePtr;
56 
57  m_rootFilePtr = new TFile(m_rootFileName.c_str(), "RECREATE");
58  //tree initialization
59  m_tree = new TTree("scf", "RECREATE");
60  m_tree->Branch("exp", &m_exp, "exp/i");
61  m_tree->Branch("run", &m_run, "run/i");
62  m_tree->Branch("layer", &m_layer, "layer/i");
63  m_tree->Branch("ladder", &m_ladder, "ladder/i");
64  m_tree->Branch("sensor", &m_sensor, "sensor/i");
65  m_tree->Branch("side", &m_side, "side/i");
66  m_tree->Branch("size", &m_size, "size/i");
67  m_tree->Branch("clsCharge", &m_clsCharge, "clsCharge/F");
68  m_tree->Branch("clsTime", &m_clsTime, "clsTime/F");
69  m_tree->Branch("clsPos", &m_clsPos, "clsPos/F");
70  m_tree->Branch("clsErr", &m_clsErr, "clsErr/F");
71  m_tree->Branch("clsResid", &m_clsResid, "clsResid/F");
72  m_tree->Branch("clsPull", &m_clsPull, "clsPull/F");
73 
74  //CLUSTER POSITION PULLS
75  TH1F hClsPullSize1("clusterPulls1_L@layerL@ladderS@sensor@view",
76  Form("Cluster %s Pulls for Size 1 in @layer.@ladder.@sensor @view/@side", m_posAlgorithm.c_str()),
77  m_nBins, m_min, m_max);
78  hClsPullSize1.GetXaxis()->SetTitle("cluster pull");
79  m_hClsPullSize1 = new SVDHistograms<TH1F>(hClsPullSize1);
80 
81  TH1F hClsPullSize2("clusterPulls2_L@layerL@ladderS@sensor@view",
82  Form("Cluster %s Pulls for Size 2 in @layer.@ladder.@sensor @view/@side", m_posAlgorithm.c_str()),
83  m_nBins, m_min, m_max);
84  hClsPullSize2.GetXaxis()->SetTitle("cluster pull");
85  m_hClsPullSize2 = new SVDHistograms<TH1F>(hClsPullSize2);
86 
87  TH1F hClsPullSize3("clusterPulls3_L@layerL@ladderS@sensor@view",
88  Form("Cluster %s Pulls for Size 3 in @layer.@ladder.@sensor @view/@side", m_posAlgorithm.c_str()),
89  m_nBins, m_min, m_max);
90  hClsPullSize3.GetXaxis()->SetTitle("cluster pull");
91  m_hClsPullSize3 = new SVDHistograms<TH1F>(hClsPullSize3);
92 
93  TH1F hClsPullSize4("clusterPulls4_L@layerL@ladderS@sensor@view",
94  Form("Cluster %s Pulls for Size 4 in @layer.@ladder.@sensor @view/@side", m_posAlgorithm.c_str()),
95  m_nBins, m_min, m_max);
96  hClsPullSize4.GetXaxis()->SetTitle("cluster pull");
97  m_hClsPullSize4 = new SVDHistograms<TH1F>(hClsPullSize4);
98 
99  TH1F hClsPullSize5("clusterPulls5_L@layerL@ladderS@sensor@view",
100  Form("Cluster %s Pulls for Size > 4 in @layer.@ladder.@sensor @view/@side", m_posAlgorithm.c_str()),
101  m_nBins, m_min, m_max);
102  hClsPullSize5.GetXaxis()->SetTitle("cluster pull");
103  m_hClsPullSize5 = new SVDHistograms<TH1F>(hClsPullSize5);
104 
105  for (int i = 0; i < 2; i++)
106  for (int s = 0; s < maxSize; s++) {
107  TString sside = "u";
108  if (i == 0) sside = "v";
109  m_hL3Pulls[s][i] = new TH1F(Form("l3_%s_size%d", sside.Data(), s + 1), Form("Size %d Cluster %s Pulls for L3 %s sensors",
110  s + 1, m_posAlgorithm.c_str(), sside.Data()), m_nBins, m_min, m_max);
111  m_hL3Pulls[s][i]->GetXaxis()->SetTitle("cluster pull");
112  m_hBWPulls[s][i] = new TH1F(Form("bw_%s_size%d", sside.Data(), s + 1), Form("Size %d Cluster %s Pulls for BW %s sensors",
113  s + 1, m_posAlgorithm.c_str(), sside.Data()), m_nBins, m_min, m_max);
114  m_hBWPulls[s][i]->GetXaxis()->SetTitle("cluster pull");
115  m_hFWPulls[s][i] = new TH1F(Form("fw_%s_size%d", sside.Data(), s + 1), Form("Size %d Cluster %s Pulls for FW %s sensors",
116  s + 1, m_posAlgorithm.c_str(), sside.Data()), m_nBins, m_min, m_max);
117  m_hFWPulls[s][i]->GetXaxis()->SetTitle("cluster pull");
118  m_hORPulls[s][i] = new TH1F(Form("or_%s_size%d", sside.Data(), s + 1), Form("Size %d Cluster %s Pulls for ORIGAMI %s sensors",
119  s + 1, m_posAlgorithm.c_str(), sside.Data()), m_nBins, m_min, m_max);
120  m_hORPulls[s][i]->GetXaxis()->SetTitle("cluster pull");
121  }
122 
123 
124 }
125 
126 void SVDPositionErrorScaleFactorImporterModule::event()
127 {
128  StoreObjPtr<EventMetaData> meta;
129  m_run = meta->getRun();
130  m_exp = meta->getExperiment();
131 
132  for (const SVDCluster& cluster : m_clusters) {
133 
134  RelationVector<SVDTrueHit> trueHit = cluster.getRelationsTo<SVDTrueHit>();
135 
136  if (trueHit.size() == 0) continue;
137 
138  m_size = cluster.getSize();
139  m_side = cluster.isUCluster();
140  m_clsCharge = cluster.getCharge();
141  m_clsTime = cluster.getClsTime();
142  m_clsPos = m_side ? cluster.getPosition(trueHit[0]->getV()) : cluster.getPosition();
143  m_clsErr = cluster.getPositionSigma();
144  m_clsResid = m_side ? m_clsPos - trueHit[0]->getU() : m_clsPos - trueHit[0]->getV();
145  m_clsPull = m_clsResid / m_clsErr;
146 
147  m_layer = cluster.getSensorID().getLayerNumber();
148  m_ladder = cluster.getSensorID().getLadderNumber();
149  m_sensor = cluster.getSensorID().getSensorNumber();
150 
151  m_tree->Fill();
152 
153  if (m_size == 1) m_hClsPullSize1->fill(cluster.getSensorID(), m_side, m_clsPull);
154  else if (m_size == 2) m_hClsPullSize2->fill(cluster.getSensorID(), m_side, m_clsPull);
155  else if (m_size == 3) m_hClsPullSize3->fill(cluster.getSensorID(), m_side, m_clsPull);
156  else if (m_size == 4) m_hClsPullSize4->fill(cluster.getSensorID(), m_side, m_clsPull);
157  else m_hClsPullSize5->fill(cluster.getSensorID(), m_side, m_clsPull);
158 
159  }
160 }
161 
162 void SVDPositionErrorScaleFactorImporterModule::endRun()
163 {
164 
165  // 1. compute scale factors for each sensor (not used in the payload!)
166  // and add them to histogram title
167 
168  //call for a geometry instance
169  VXD::GeoCache& aGeometry = VXD::GeoCache::getInstance();
170  std::set<Belle2::VxdID> svdLayers = aGeometry.getLayers(VXD::SensorInfoBase::SVD);
171  std::set<Belle2::VxdID>::iterator itSvdLayers = svdLayers.begin();
172 
173  while ((itSvdLayers != svdLayers.end()) && (itSvdLayers->getLayerNumber() != 7)) { //loop on Layers
174 
175  std::set<Belle2::VxdID> svdLadders = aGeometry.getLadders(*itSvdLayers);
176  std::set<Belle2::VxdID>::iterator itSvdLadders = svdLadders.begin();
177 
178  while (itSvdLadders != svdLadders.end()) { //loop on Ladders
179 
180  std::set<Belle2::VxdID> svdSensors = aGeometry.getSensors(*itSvdLadders);
181  std::set<Belle2::VxdID>::iterator itSvdSensors = svdSensors.begin();
182  B2DEBUG(1, " svd sensor info " << * (svdSensors.begin()));
183 
184  while (itSvdSensors != svdSensors.end()) { //loop on sensors
185  B2DEBUG(1, " svd sensor info " << *itSvdSensors);
186 
187  m_layer = (int)itSvdSensors->getLayerNumber();
188  m_ladder = (int)itSvdSensors->getLadderNumber();
189  m_sensor = (int)itSvdSensors->getSensorNumber();
190  Belle2::VxdID theVxdID(m_layer, m_ladder, m_sensor);
191 
192  for (m_side = 0; m_side < 2; m_side++) {
193 
194  TH1F* h = m_hClsPullSize1->getHistogram(theVxdID, m_side);
195  h->SetTitle(Form("%s, scf = %1.2f", h->GetTitle(), oneSigma(h)));
196  h = m_hClsPullSize2->getHistogram(theVxdID, m_side);
197  h->SetTitle(Form("%s, scf = %1.2f", h->GetTitle(), oneSigma(h)));
198  h = m_hClsPullSize3->getHistogram(theVxdID, m_side);
199  h->SetTitle(Form("%s, scf = %1.2f", h->GetTitle(), oneSigma(h)));
200  h = m_hClsPullSize4->getHistogram(theVxdID, m_side);
201  h->SetTitle(Form("%s, scf = %1.2f", h->GetTitle(), oneSigma(h)));
202  h = m_hClsPullSize5->getHistogram(theVxdID, m_side);
203  h->SetTitle(Form("%s, scf = %1.2f", h->GetTitle(), oneSigma(h)));
204 
205  //layer 3
206  if (theVxdID.getLayerNumber() == 3) {
207  m_hL3Pulls[0][m_side]->Add(m_hClsPullSize1->getHistogram(theVxdID, m_side));
208  m_hL3Pulls[1][m_side]->Add(m_hClsPullSize2->getHistogram(theVxdID, m_side));
209  m_hL3Pulls[2][m_side]->Add(m_hClsPullSize3->getHistogram(theVxdID, m_side));
210  m_hL3Pulls[3][m_side]->Add(m_hClsPullSize4->getHistogram(theVxdID, m_side));
211  m_hL3Pulls[4][m_side]->Add(m_hClsPullSize5->getHistogram(theVxdID, m_side));
212  }
213 
214  //forward
215  else if (theVxdID.getSensorNumber() == 1) {
216  m_hFWPulls[0][m_side]->Add(m_hClsPullSize1->getHistogram(theVxdID, m_side));
217  m_hFWPulls[1][m_side]->Add(m_hClsPullSize2->getHistogram(theVxdID, m_side));
218  m_hFWPulls[2][m_side]->Add(m_hClsPullSize3->getHistogram(theVxdID, m_side));
219  m_hFWPulls[3][m_side]->Add(m_hClsPullSize4->getHistogram(theVxdID, m_side));
220  m_hFWPulls[4][m_side]->Add(m_hClsPullSize5->getHistogram(theVxdID, m_side));
221  }
222  //backward
223  else if (theVxdID.getSensorNumber() == theVxdID.getLayerNumber() - 1) {
224  m_hBWPulls[0][m_side]->Add(m_hClsPullSize1->getHistogram(theVxdID, m_side));
225  m_hBWPulls[1][m_side]->Add(m_hClsPullSize2->getHistogram(theVxdID, m_side));
226  m_hBWPulls[2][m_side]->Add(m_hClsPullSize3->getHistogram(theVxdID, m_side));
227  m_hBWPulls[3][m_side]->Add(m_hClsPullSize4->getHistogram(theVxdID, m_side));
228  m_hBWPulls[4][m_side]->Add(m_hClsPullSize5->getHistogram(theVxdID, m_side));
229  }
230  // origami
231  else {
232  m_hORPulls[0][m_side]->Add(m_hClsPullSize1->getHistogram(theVxdID, m_side));
233  m_hORPulls[1][m_side]->Add(m_hClsPullSize2->getHistogram(theVxdID, m_side));
234  m_hORPulls[2][m_side]->Add(m_hClsPullSize3->getHistogram(theVxdID, m_side));
235  m_hORPulls[3][m_side]->Add(m_hClsPullSize4->getHistogram(theVxdID, m_side));
236  m_hORPulls[4][m_side]->Add(m_hClsPullSize5->getHistogram(theVxdID, m_side));
237  }
238  }
239  ++itSvdSensors;
240  }
241  ++itSvdLadders;
242  }
243  ++itSvdLayers;
244  }
245 
246 
247  IntervalOfValidity iov(0, 0, -1, -1);
248 
249  auto scfs = new Belle2::SVDPosErrScaleFactors;
250 
251  //CoGOnly payload
252  auto payload_cogOnly = new Belle2::SVDCoGOnlyErrorScaleFactors::t_payload(*scfs, m_uniqueID);
253 
254  //OldDefault payload
255  auto payload_oldDefault = new Belle2::SVDOldDefaultErrorScaleFactors::t_payload(*scfs, m_uniqueID);
256 
257  // 2. compute scale factors using cumulative histograms
258  VXD::GeoCache& geoCache = VXD::GeoCache::getInstance();
259 
260  for (auto layer : geoCache.getLayers(VXD::SensorInfoBase::SVD))
261  for (auto ladder : geoCache.getLadders(layer))
262  for (Belle2::VxdID theVxdID : geoCache.getSensors(ladder))
263 
264  for (m_side = 0; m_side < 2; m_side++) {
265 
266  //layer 3
267  if (theVxdID.getLayerNumber() == 3) {
268  scfs->scaleError_clSize1 = oneSigma(m_hL3Pulls[0][m_side]);
269  scfs->scaleError_clSize2 = oneSigma(m_hL3Pulls[1][m_side]);
270  scfs->scaleError_clSize3 = oneSigma(m_hL3Pulls[2][m_side]);
271  scfs->scaleError_clSize4 = oneSigma(m_hL3Pulls[3][m_side]);
272  scfs->scaleError_clSize5 = oneSigma(m_hL3Pulls[4][m_side]);
273  }
274  //forward
275  else if (theVxdID.getSensorNumber() == 1) {
276  scfs->scaleError_clSize1 = oneSigma(m_hFWPulls[0][m_side]);
277  scfs->scaleError_clSize2 = oneSigma(m_hFWPulls[1][m_side]);
278  scfs->scaleError_clSize3 = oneSigma(m_hFWPulls[2][m_side]);
279  scfs->scaleError_clSize4 = oneSigma(m_hFWPulls[3][m_side]);
280  scfs->scaleError_clSize5 = oneSigma(m_hFWPulls[4][m_side]);
281  }
282  //backward
283  else if (theVxdID.getSensorNumber() == theVxdID.getLayerNumber() - 1) {
284  scfs->scaleError_clSize1 = oneSigma(m_hBWPulls[0][m_side]);
285  scfs->scaleError_clSize2 = oneSigma(m_hBWPulls[1][m_side]);
286  scfs->scaleError_clSize3 = oneSigma(m_hBWPulls[2][m_side]);
287  scfs->scaleError_clSize4 = oneSigma(m_hBWPulls[3][m_side]);
288  scfs->scaleError_clSize5 = oneSigma(m_hBWPulls[4][m_side]);
289  }
290  // origami
291  else {
292  scfs->scaleError_clSize1 = oneSigma(m_hORPulls[0][m_side]);
293  scfs->scaleError_clSize2 = oneSigma(m_hORPulls[1][m_side]);
294  scfs->scaleError_clSize3 = oneSigma(m_hORPulls[2][m_side]);
295  scfs->scaleError_clSize4 = oneSigma(m_hORPulls[3][m_side]);
296  scfs->scaleError_clSize5 = oneSigma(m_hORPulls[4][m_side]);
297  }
298 
299  if (TString(m_posAlgorithm).Contains("CoGOnly"))
300  payload_cogOnly->set(theVxdID.getLayerNumber(), theVxdID.getLadderNumber(), theVxdID.getSensorNumber(), m_side, 1, *scfs);
301  if (TString(m_posAlgorithm).Contains("OldDefault"))
302  payload_oldDefault->set(theVxdID.getLayerNumber(), theVxdID.getLadderNumber(), theVxdID.getSensorNumber(), m_side, 1, *scfs);
303  }
304 
305  if (TString(m_posAlgorithm).Contains("CoGOnly")) {
306  Database::Instance().storeData(SVDCoGOnlyErrorScaleFactors::name, payload_cogOnly, iov);
307 
308  B2RESULT("SVDCoGOnlyErrorScaleFactors imported to database.");
309  }
310  if (TString(m_posAlgorithm).Contains("OldDefault")) {
311  Database::Instance().storeData(SVDOldDefaultErrorScaleFactors::name, payload_oldDefault, iov);
312 
313  B2RESULT("SVDOldDefaultErrorScaleFactors imported to database.");
314  }
315 
316 
317  //now write the rootfile
318  if (m_rootFilePtr != nullptr) {
319 
320  m_rootFilePtr->cd();
321 
322  //write the tree
323  m_tree->Write();
324 
325  m_rootFilePtr->mkdir("sensor_pulls");
326  m_rootFilePtr->mkdir("pulls");
327 
328  for (auto layer : geoCache.getLayers(VXD::SensorInfoBase::SVD))
329  for (auto ladder : geoCache.getLadders(layer))
330  for (Belle2::VxdID sensor : geoCache.getSensors(ladder))
331  for (int view = SVDHistograms<TH1F>::VIndex ; view < SVDHistograms<TH1F>::UIndex + 1; view++) {
332 
333  //writing the histograms to root:
334 
335  m_rootFilePtr->cd("sensor_pulls");
336  (m_hClsPullSize1->getHistogram(sensor, view))->Write();
337  (m_hClsPullSize2->getHistogram(sensor, view))->Write();
338  (m_hClsPullSize3->getHistogram(sensor, view))->Write();
339  (m_hClsPullSize4->getHistogram(sensor, view))->Write();
340  (m_hClsPullSize5->getHistogram(sensor, view))->Write();
341 
342  }
343 
344  for (int s = 0; s < maxSize; s++) {
345  m_rootFilePtr->cd("pulls");
346  m_hL3Pulls[s][1]->Write();
347  m_hFWPulls[s][1]->Write();
348  m_hBWPulls[s][1]->Write();
349  m_hORPulls[s][1]->Write();
350  m_hL3Pulls[s][0]->Write();
351  m_hFWPulls[s][0]->Write();
352  m_hBWPulls[s][0]->Write();
353  m_hORPulls[s][0]->Write();
354  }
355  m_rootFilePtr->Close();
356  B2RESULT("The rootfile containing the list of histograms has been filled and closed.");
357 
358  }
359 }
360 
361 double SVDPositionErrorScaleFactorImporterModule::oneSigma(TH1F* h1)
362 {
363  TH1F* h1_res = (TH1F*)h1->Clone("h1_res");
364 
365  double probs[2] = {0.16, 1 - 0.16};
366  double quant[2] = {0, 0};
367 
368  int nbinsHisto = h1_res->GetNbinsX();
369 
370  if (m_noOutliers) {
371  h1_res->SetBinContent(1, h1_res->GetBinContent(0) + h1_res->GetBinContent(1));
372  h1_res->SetBinContent(nbinsHisto, h1_res->GetBinContent(nbinsHisto) + h1_res->GetBinContent(nbinsHisto + 1));
373  h1_res->SetBinContent(0, 0);
374  h1_res->SetBinContent(nbinsHisto + 1, 0);
375  }
376 
377  h1_res->GetQuantiles(2, quant, probs);
378 
379  return (-quant[0] + quant[1]) / 2;
380 
381 }
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:25
Belle2::Module
Base class for Modules.
Definition: Module.h:72
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Belle2::RelationVector
Class for type safe access to objects that are referred to in relations.
Definition: RelationVector.h:67
Belle2::RelationVector::size
size_t size() const
Get number of relations.
Definition: RelationVector.h:88
Belle2::SVDCluster
The SVD Cluster class This class stores all information about reconstructed SVD clusters.
Definition: SVDCluster.h:29
Belle2::SVDCoGOnlyErrorScaleFactors::name
static std::string name
name of SVDPosErrScaleFactors payload
Definition: SVDCoGOnlyErrorScaleFactors.h:31
Belle2::SVDCoGOnlyErrorScaleFactors::t_payload
SVDCalibrationsBase< SVDCalibrationsScalar< SVDPosErrScaleFactors > > t_payload
typedef for the of SVDPosErrScaleFactors payload of all SVD sensors
Definition: SVDCoGOnlyErrorScaleFactors.h:33
Belle2::SVDHistograms::fill
void fill(const VxdID &vxdID, int view, Types ... args)
fill the histogram for
Definition: SVDHistograms.h:77
Belle2::SVDHistograms::getHistogram
H * getHistogram(const VxdID &vxdID, int view)
get a reference to the histogram for
Definition: SVDHistograms.h:56
Belle2::SVDOldDefaultErrorScaleFactors::name
static std::string name
name of SVDPosErrScaleFactors payload
Definition: SVDOldDefaultErrorScaleFactors.h:31
Belle2::SVDOldDefaultErrorScaleFactors::t_payload
SVDCalibrationsBase< SVDCalibrationsScalar< SVDPosErrScaleFactors > > t_payload
typedef for the of SVDPosErrScaleFactors payload of all SVD sensors
Definition: SVDOldDefaultErrorScaleFactors.h:33
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hClsPullSize1
SVDHistograms< TH1F > * m_hClsPullSize1
cluster size 1, position error scale factor histo
Definition: SVDPositionErrorScaleFactorImporterModule.h:106
Belle2::SVDPositionErrorScaleFactorImporterModule::m_tree
TTree * m_tree
pointer at tree containing the mean and RMS of calibration constants
Definition: SVDPositionErrorScaleFactorImporterModule.h:83
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hFWPulls
TH1F * m_hFWPulls[5][2]
cumulative FW pulls histograms [size][side]
Definition: SVDPositionErrorScaleFactorImporterModule.h:114
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hORPulls
TH1F * m_hORPulls[5][2]
cumulative ORIGAMI pulls histograms [size][side]
Definition: SVDPositionErrorScaleFactorImporterModule.h:116
Belle2::SVDPositionErrorScaleFactorImporterModule::initialize
virtual void initialize() override
check presence of data objects
Definition: SVDPositionErrorScaleFactorImporterModule.cc:46
Belle2::SVDPositionErrorScaleFactorImporterModule::m_noOutliers
bool m_noOutliers
if True removes outliers from scale factor computation
Definition: SVDPositionErrorScaleFactorImporterModule.h:71
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hClsPullSize5
SVDHistograms< TH1F > * m_hClsPullSize5
cluster size 5, position error scale factor histo
Definition: SVDPositionErrorScaleFactorImporterModule.h:110
Belle2::SVDPositionErrorScaleFactorImporterModule::endRun
virtual void endRun() override
create cumulative histograms, compute scale factors, create payloads and import it to a localdb,...
Definition: SVDPositionErrorScaleFactorImporterModule.cc:162
Belle2::SVDPositionErrorScaleFactorImporterModule::SVDPositionErrorScaleFactorImporterModule
SVDPositionErrorScaleFactorImporterModule()
Constructor: Sets the description, the properties and the parameters of the module.
Definition: SVDPositionErrorScaleFactorImporterModule.cc:30
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hClsPullSize3
SVDHistograms< TH1F > * m_hClsPullSize3
cluster size 3, position error scale factor histo
Definition: SVDPositionErrorScaleFactorImporterModule.h:108
Belle2::SVDPositionErrorScaleFactorImporterModule::beginRun
virtual void beginRun() override
initialize the TTrees and create histograms
Definition: SVDPositionErrorScaleFactorImporterModule.cc:52
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hL3Pulls
TH1F * m_hL3Pulls[5][2]
cumulative L3 pulls histograms [size][side]
Definition: SVDPositionErrorScaleFactorImporterModule.h:113
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hClsPullSize2
SVDHistograms< TH1F > * m_hClsPullSize2
cluster size 2, position error scale factor histo
Definition: SVDPositionErrorScaleFactorImporterModule.h:107
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hClsPullSize4
SVDHistograms< TH1F > * m_hClsPullSize4
cluster size 4, position error scale factor histo
Definition: SVDPositionErrorScaleFactorImporterModule.h:109
Belle2::SVDPositionErrorScaleFactorImporterModule::m_hBWPulls
TH1F * m_hBWPulls[5][2]
cumulative BW pulls histograms [size][side]
Definition: SVDPositionErrorScaleFactorImporterModule.h:115
Belle2::SVDPositionErrorScaleFactorImporterModule::oneSigma
double oneSigma(TH1F *)
computes the scale factor by requiring that 68% of the pull distribution is between ±1
Definition: SVDPositionErrorScaleFactorImporterModule.cc:361
Belle2::SVDPositionErrorScaleFactorImporterModule::m_rootFilePtr
TFile * m_rootFilePtr
pointer at root file used for storing histograms
Definition: SVDPositionErrorScaleFactorImporterModule.h:82
Belle2::SVDTrueHit
Class SVDTrueHit - Records of tracks that either enter or leave the sensitive volume.
Definition: SVDTrueHit.h:33
Belle2::StoreAccessorBase::isRequired
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Definition: StoreAccessorBase.h:78
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::VXD::GeoCache
Class to faciliate easy access to sensor information of the VXD like coordinate transformations or pi...
Definition: GeoCache.h:39
Belle2::VXD::GeoCache::getLayers
const std::set< Belle2::VxdID > getLayers(SensorInfoBase::SensorType sensortype=SensorInfoBase::VXD)
Return a set of all known Layers.
Definition: GeoCache.cc:176
Belle2::VXD::GeoCache::getSensors
const std::set< Belle2::VxdID > & getSensors(Belle2::VxdID ladder) const
Return a set of all sensor IDs belonging to a given ladder.
Definition: GeoCache.cc:204
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:214
Belle2::VXD::GeoCache::getLadders
const std::set< Belle2::VxdID > & getLadders(Belle2::VxdID layer) const
Return a set of all ladder IDs belonging to a given layer.
Definition: GeoCache.cc:193
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::VxdID::getSensorNumber
baseType getSensorNumber() const
Get the sensor id.
Definition: VxdID.h:100
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:96
Belle2::REG_MODULE
REG_MODULE(arichBtest)
Register the Module.
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:560
Belle2::Database::Instance
static Database & Instance()
Instance of a singleton Database.
Definition: Database.cc:42
Belle2::Database::storeData
bool storeData(const std::string &name, TObject *object, const IntervalOfValidity &iov)
Store an object in the database.
Definition: Database.cc:141
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
Belle2::SVDPosErrScaleFactors
contains the scaling factors for the cluster position error
Definition: SVDPosErrScaleFactors.h:18