Belle II Software  release-05-02-19
HitXPModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2017 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Valerio Bertacchi *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <tracking/modules/trackingPerformanceEvaluation/HitXPModule.h>
12 #include <framework/datastore/StoreArray.h>
13 #include <framework/datastore/RelationArray.h>
14 #include <mdst/dataobjects/MCParticle.h>
15 #include <svd/dataobjects/SVDCluster.h>
16 #include <svd/dataobjects/SVDTrueHit.h>
17 #include <TFile.h>
18 #include <tracking/dataobjects/RecoTrack.h>
19 #include <tracking/dataobjects/hitXPDerivate.h>
20 
21 #include <string>
22 
23 using namespace Belle2;
24 
25 REG_MODULE(HitXP)
26 
27 HitXPModule::HitXPModule() : Module()
28 {
29  setDescription("This module builds a ttree with true hit informations (momentum, position, PDGID, and track parameters hit per hit) running over simulated and reconstructed events.");
30 
32  addParam("additionalTree", c_addTree,
33  "produce two additional tree with reduced date: selTree (track with at least one hit per layer), tiSelTree (track with one hit per layer)",
34  false);
35 
36 }
37 
38 
39 HitXPModule::~HitXPModule()
40 {
41 }
42 
43 
44 
45 void HitXPModule::initialize()
46 {
47 
49  StoreArray<SVDCluster> storeClusters("");
50  StoreArray<SVDTrueHit> storeTrueHits("");
51  StoreArray<MCParticle> storeMCParticles("");
52  StoreArray<RecoTrack> recoTracks("");
53 
54 
55  storeClusters.isRequired();
56  storeTrueHits.isRequired();
57  storeMCParticles.isRequired();
58  recoTracks.isRequired();
59 
60 
61  RelationArray relClusterTrueHits(storeClusters, storeTrueHits);
62  RelationArray relClusterMCParticles(storeClusters, storeMCParticles);
63  RelationArray recoTracksToMCParticles(recoTracks , storeMCParticles);
64 
65 
66 
75  m_outputFile = new TFile("TFile_hitXP.root", "RECREATE");
76  m_tree = new TTree("TTree_hitXP", "TTree_hitXP");
77 
78  m_tree->Branch("hitXP", &m_hitXP);
79  m_tree->Branch("trackNumber", &m_trackNumber);
80  m_tree->Branch("eventNumber", &m_eventNumber);
81  m_tree->Branch("numberHitPerTrack", &m_numberHitPerTrack);
82 
83  m_trackIterator = 0;
84  m_eventIterator = 0;
85 
86  //-------------------------------------------------------------------------------------------------//
87  //------------------------------------selected Tree creation--------------------------------------//
88  //-------------------------------------------------------------------------------------------------//
89  if (c_addTree) m_outputFileSel = new TFile("TFile_hitXPSel.root", "RECREATE");
90  m_treeSel = new TTree("TTree_hitXPSel", "TTree_hitXPSel");
91 
92  m_treeSel->Branch("hitXP", &m_hitXPSel);
93  m_treeSel->Branch("trackNumber", &m_trackNumberSel);
94  m_treeSel->Branch("eventNumber", &m_eventNumberSel);
95  m_treeSel->Branch("numberHitPerTrack", &m_numberHitPerTrackSel);
96 
97 
98  //-------------------------------------------------------------------------------------------------//
99  //------------------------------------tight selected Tree creation--------------------------------------//
100  //-------------------------------------------------------------------------------------------------//
101  if (c_addTree) m_outputFileTiSel = new TFile("TFile_hitXPTiSel.root", "RECREATE");
102  m_treeTiSel = new TTree("TTree_hitXPTiSel", "TTree_hitXPTiSel");
103 
104  m_treeTiSel->Branch("hitXP", &m_hitXPTiSel);
105  m_treeTiSel->Branch("trackNumber", &m_trackNumberTiSel);
106  m_treeTiSel->Branch("eventNumber", &m_eventNumberTiSel);
107  m_treeTiSel->Branch("numberHitPerTrack", &m_numberHitPerTrackTiSel);
108 
109 
110 //-------------------------------------------------------------------------------------------------//
111 //------------------------------------External Tree creation--------------------------------------//
112 //-------------------------------------------------------------------------------------------------//
113 
115  m_outputFileExt = new TFile("TFile_hitXP_ext.root", "RECREATE");
116  m_treeExt = new TTree("TTree_hitXP_ext", "TTree_hitXP_ext");
117 
118  m_treeExt->Branch("positionEntryX", &m_EpositionEntryX);
119  m_treeExt->Branch("positionEntryY", &m_EpositionEntryY);
120  m_treeExt->Branch("positionEntryZ", &m_EpositionEntryZ);
121  m_treeExt->Branch("momentumEntryX", &m_EmomentumEntryX);
122  m_treeExt->Branch("momentumEntryY", &m_EmomentumEntryY);
123  m_treeExt->Branch("momentumEntryZ", &m_EmomentumEntryZ);
124  m_treeExt->Branch("positionLocalEntryX", &m_EpositionLocalEntryX);
125  m_treeExt->Branch("positionLocalEntryY", &m_EpositionLocalEntryY);
126  m_treeExt->Branch("positionLocalEntryZ", &m_EpositionLocalEntryZ);
127  m_treeExt->Branch("PDGID", &m_EPDGID);
128  m_treeExt->Branch("position0X", &m_Eposition0X);
129  m_treeExt->Branch("position0Y", &m_Eposition0Y);
130  m_treeExt->Branch("position0Z", &m_Eposition0Z);
131  m_treeExt->Branch("momentum0X", &m_Emomentum0X);
132  m_treeExt->Branch("momentum0Y", &m_Emomentum0Y);
133  m_treeExt->Branch("momentum0Z", &m_Emomentum0Z);
134  m_treeExt->Branch("time", &m_Etime);
135  m_treeExt->Branch("sensorSensor", &m_EsensorSensor);
136  m_treeExt->Branch("sensorLayer", &m_EsensorLayer);
137  m_treeExt->Branch("sensorLadder", &m_EsensorLadder);
138  m_treeExt->Branch("reconstructed", &m_Ereconstructed);
139  m_treeExt->Branch("clusterU", &m_EclusterU);
140  m_treeExt->Branch("clusterV", &m_EclusterV);
141  m_treeExt->Branch("charge", &m_Echarge);
142  m_treeExt->Branch("trackNumber", &m_EtrackNumber);
143  m_treeExt->Branch("eventNumber", &m_EeventNumber);
144  m_treeExt->Branch("numberHitPerTrack", &m_EnumberHitPerTrack);
145  m_treeExt->Branch("omegaEntry", &m_EomegaEntry);
146  m_treeExt->Branch("omega0", &m_Eomega0);
147  m_treeExt->Branch("d0Entry", &m_Ed0Entry);
148  m_treeExt->Branch("d00", &m_Ed00);
149  m_treeExt->Branch("phi0Entry", &m_Ephi0Entry);
150  m_treeExt->Branch("phi00", &m_Ephi00);
151  m_treeExt->Branch("z0Entry", &m_Ez0Entry);
152  m_treeExt->Branch("z00", &m_Ez00);
153  m_treeExt->Branch("tanlambdaEntry", &m_EtanlambdaEntry);
154  m_treeExt->Branch("tanlambda0", &m_Etanlambda0);
155  m_treeExt->Branch("primary", &m_Eprimary);
156 
157 }
158 
159 void HitXPModule::beginRun() {}
160 
161 void HitXPModule::event()
162 {
163  StoreArray<SVDCluster> SVDClusters;
164  StoreArray<SVDTrueHit> SVDTrueHits;
165  StoreArray<MCParticle> MCParticles;
166 
167  StoreArray<RecoTrack> recoTracks;
168 
169  m_eventNumber = m_eventIterator;
170  m_EeventNumber = m_eventIterator; //------------External Tree---------//
171  m_eventIterator = m_eventIterator + 1;
172 
173 
174  for (const MCParticle& particle : MCParticles) {
175  m_Eprimary = particle.getStatus();
176  for (const SVDTrueHit& hit : particle.getRelationsTo<SVDTrueHit>()) {
177  if (hit.getRelationsFrom<SVDCluster>().size() > 0) {
178  VxdID trueHitSensorID = hit.getSensorID();
179  const VXD::SensorInfoBase& sensorInfo = VXD::GeoCache::getInstance().getSensorInfo(trueHitSensorID);
180  const SVDCluster* cluster = hit.getRelationsFrom<SVDCluster>()[0];
181  hitXPDerivate entry(hit, *cluster, particle, sensorInfo);
182  int NClusterU = 0;
183  int NClusterV = 0;
184  for (SVDCluster Ncluster : hit.getRelationsFrom<SVDCluster>()) {
185  if (Ncluster.isUCluster()) NClusterU++;
186  else NClusterV++;
187  }
188  entry.setClusterU(NClusterU);
189  entry.setClusterV(NClusterV);
190 
191  bool isReconstructed(false);
192  for (const RecoTrack& aRecoTrack : particle.getRelationsFrom<RecoTrack>())
193  isReconstructed |= aRecoTrack.hasSVDHits();
194  entry.setReconstructed(isReconstructed);
195  m_hitXPSet.insert(entry);
196  }
197  }
198  m_trackNumber = m_trackIterator;
199  m_EtrackNumber = m_trackIterator; //----------------External Tree ----------------//
200  m_trackIterator = m_trackIterator + 1;
201 
202  for (auto element : m_hitXPSet) {
203  m_hitXP.push_back(element);
204 
205  //-----------------External Tree ---------------------------- //
206  m_EpositionEntryX.push_back(element.m_positionEntry.x());
207  m_EpositionEntryY.push_back(element.m_positionEntry.y());
208  m_EpositionEntryZ.push_back(element.m_positionEntry.z());
209  m_EmomentumEntryX.push_back(element.m_momentumEntry.x());
210  m_EmomentumEntryY.push_back(element.m_momentumEntry.y());
211  m_EmomentumEntryZ.push_back(element.m_momentumEntry.z());
212  m_EpositionLocalEntryX.push_back(element.m_positionLocalEntry.x());
213  m_EpositionLocalEntryY.push_back(element.m_positionLocalEntry.y());
214  m_EpositionLocalEntryZ.push_back(element.m_positionLocalEntry.z());
215  m_EPDGID.push_back(element.m_PDGID);
216  m_Eposition0X.push_back(element.m_position0.x());
217  m_Eposition0Y.push_back(element.m_position0.y());
218  m_Eposition0Z.push_back(element.m_position0.z());
219  m_Emomentum0X.push_back(element.m_momentum0.x());
220  m_Emomentum0Y.push_back(element.m_momentum0.y());
221  m_Emomentum0Z.push_back(element.m_momentum0.z());
222  m_Etime.push_back(element.m_time);
223  m_EsensorSensor.push_back(element.m_sensorSensor);
224  m_EsensorLayer.push_back(element.m_sensorLayer);
225  m_EsensorLadder.push_back(element.m_sensorLadder);
226  m_Ereconstructed.push_back(element.m_reconstructed);
227  m_EclusterU.push_back(element.m_clusterU);
228  m_EclusterV.push_back(element.m_clusterV);
229  m_Echarge.push_back(element.m_charge);
230  m_EomegaEntry.push_back(element.getOmegaEntry());
231  m_Eomega0.push_back(element.getOmega0());
232  m_Ed0Entry.push_back(element.getD0Entry());
233  m_Ed00.push_back(element.getD00());
234  m_Ephi0Entry.push_back(element.getPhi0Entry());
235  m_Ephi00.push_back(element.getPhi00());
236  m_Ez0Entry.push_back(element.getZ0Entry());
237  m_Ez00.push_back(element.getZ00());
238  m_EtanlambdaEntry.push_back(element.getTanLambdaEntry());
239  m_Etanlambda0.push_back(element.getTanLambda0());
240  }
241  m_numberHitPerTrack = m_hitXP.size();
242  m_EnumberHitPerTrack = m_hitXP.size(); //-------external tree--------------//
243 
244 
245  m_tree->Fill();
246 
247  //-------external tree--------------//
248  m_treeExt->Fill();
249  m_EpositionEntryX.clear();
250  m_EpositionEntryY.clear();
251  m_EpositionEntryZ.clear();
252  m_EmomentumEntryX.clear();
253  m_EmomentumEntryY.clear();
254  m_EmomentumEntryZ.clear();
255  m_EpositionLocalEntryX.clear();
256  m_EpositionLocalEntryY.clear();
257  m_EpositionLocalEntryZ.clear();
258  m_EPDGID.clear();
259  m_Eposition0X.clear();
260  m_Eposition0Y.clear();
261  m_Eposition0Z.clear();
262  m_Emomentum0X.clear();
263  m_Emomentum0Y.clear();
264  m_Emomentum0Z.clear();
265  m_Etime.clear();
266  m_EsensorSensor.clear();
267  m_EsensorLayer.clear();
268  m_EsensorLadder.clear();
269  m_Ereconstructed.clear();
270  m_EclusterU.clear();
271  m_EclusterV.clear();
272  m_Echarge.clear();
273  m_EomegaEntry.clear();
274  m_Eomega0.clear();
275  m_Ed0Entry.clear();
276  m_Ed00.clear();
277  m_Ephi0Entry.clear();
278  m_Ephi00.clear();
279  m_Ez0Entry.clear();
280  m_Ez00.clear();
281  m_EtanlambdaEntry.clear();
282  m_Etanlambda0.clear();
283 
284 
285 
286  //-------------------------------------------------------------------------------------------------//
287  //------------------------------------Selected Tree creation--------------------------------------//
288  //-------------------------------------------------------------------------------------------------//
290  int f3 = 0, f4 = 0, f5 = 0, f6 = 0;
291  int layer_flag = 0;
292  unsigned int j = 0;
293  int brk = 0;
294  std::vector<hitXP> temp_hitXP;
295  while (j < m_hitXP.size() && brk == 0) {
296  if (m_hitXP[j].m_sensorLayer == 3) {
297  f3 = 1;
298  temp_hitXP.push_back(m_hitXP[j]);
299  j++;
300  while (j < m_hitXP.size() && brk == 0) {
301  if (m_hitXP[j].m_sensorLayer == 4) {
302  f4 = 1;
303  temp_hitXP.push_back(m_hitXP[j]);
304  j++;
305  while (j < m_hitXP.size() && brk == 0) {
306  if (m_hitXP[j].m_sensorLayer == 5) {
307  f5 = 1;
308  temp_hitXP.push_back(m_hitXP[j]);
309  j++;
310  while (j < m_hitXP.size() && brk == 0) {
311  if (m_hitXP[j].m_sensorLayer == 6) {
312  f6 = 1;
313  temp_hitXP.push_back(m_hitXP[j]);
314  brk = 1;
315  j++;
316  }
317  j++;
318  }
319  }
320  j++;
321  }
322  }
323  j++;
324  }
325  }
326  j++;
327  }
328  layer_flag = f3 * f4 * f5 * f6;
329  if (layer_flag != 0) {
330  int k;
331  for (k = 0; k < 4; k = k + 1) {
332  m_hitXPSel.push_back(temp_hitXP[k]);
333  }
334  m_trackNumberSel = m_trackNumber;
335  m_eventNumberSel = m_eventNumber;
336  m_numberHitPerTrackSel = m_hitXPSel.size();
337  m_treeSel->Fill();
338  m_hitXPSel.erase(m_hitXPSel.begin(), m_hitXPSel.end());
339  }
340 
341 
342 
343  //-------------------------------------------------------------------------------------------------//
344  //------------------------------------Tight Selected Tree creation--------------------------------------//
345  //-------------------------------------------------------------------------------------------------//
347  if (m_numberHitPerTrack == 4 && m_hitXP[0].m_sensorLayer == 3 && m_hitXP[1].m_sensorLayer == 4
348  && m_hitXP[2].m_sensorLayer == 5 && m_hitXP[3].m_sensorLayer == 6) {
349  int h = 0;
350  for (h = 0; h < 4; h = h + 1) {
351  m_hitXPTiSel.push_back(m_hitXP[h]);
352  }
353  m_trackNumberTiSel = m_trackNumber;
354  m_eventNumberTiSel = m_eventNumber;
355  m_numberHitPerTrackTiSel = m_hitXPTiSel.size();
356  m_treeTiSel->Fill();
357  m_hitXPTiSel.erase(m_hitXPTiSel.begin(), m_hitXPTiSel.end());
358  }
359  m_hitXP.erase(m_hitXP.begin(), m_hitXP.end());
360  m_hitXPSet.clear();
361  }
362 }
363 
364 
365 
366 void HitXPModule::endRun()
367 {
368  m_outputFile->cd();
369  m_tree->Write();
370  m_outputFile->Close();
371 
372  if (c_addTree) {
373  //-------------------------------------------------------------------------------------------------//
374  //------------------------------------selected Tree storage--------------------------------------//
375  //-------------------------------------------------------------------------------------------------//
376  m_outputFileSel->cd();
377  m_treeSel->Write();
378  m_outputFileSel->Close();
379 
380 
381  //-------------------------------------------------------------------------------------------------//
382  //------------------------------------tight selected Tree storage--------------------------------------//
383  //-------------------------------------------------------------------------------------------------//
384  m_outputFileTiSel->cd();
385  m_treeTiSel->Write();
386  m_outputFileTiSel->Close();
387  }
388 
389 
390  //-------------------------------------------------------------------------------------------------//
391  //------------------------------------external Tree storage--------------------------------------//
392  //-------------------------------------------------------------------------------------------------//
393  m_outputFileExt->cd();
394  m_treeExt->Write();
395  m_outputFileExt->Close();
396 }
397 
398 void HitXPModule::terminate() {}
Belle2::HitXPModule::m_Ephi0Entry
std::vector< double > m_Ephi0Entry
external phi0 parameter at entry point
Definition: HitXPModule.h:132
Belle2::HitXPModule::initialize
void initialize() override
Initialize the Module.
Definition: HitXPModule.cc:45
Belle2::HitXPModule::m_trackNumberTiSel
int m_trackNumberTiSel
tight selected iterative number of the track in the run
Definition: HitXPModule.h:95
Belle2::RelationArray
Low-level class to create/modify relations between StoreArrays.
Definition: RelationArray.h:72
Belle2::HitXPModule::endRun
void endRun() override
This method is called if the current run ends.
Definition: HitXPModule.cc:366
Belle2::HitXPModule::m_EpositionLocalEntryX
std::vector< double > m_EpositionLocalEntryX
exteral local position at entry point, coordinate x
Definition: HitXPModule.h:107
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
Belle2::HitXPModule::m_hitXP
std::vector< hitXP > m_hitXP
vector of the hitXP, used to fill the output tree
Definition: HitXPModule.h:75
Belle2::HitXPModule::m_Ez0Entry
std::vector< double > m_Ez0Entry
external z0 parameter at entry point
Definition: HitXPModule.h:134
Belle2::HitXPModule::m_outputFile
TFile * m_outputFile
output file
Definition: HitXPModule.h:74
Belle2::HitXPModule::m_EpositionLocalEntryY
std::vector< double > m_EpositionLocalEntryY
exteral local position at entry point, coordinate y
Definition: HitXPModule.h:108
Belle2::HitXPModule::m_EpositionEntryX
std::vector< double > m_EpositionEntryX
exteral position at entry point, coordinate x
Definition: HitXPModule.h:101
Belle2::HitXPModule::m_outputFileExt
TFile * m_outputFileExt
external output file
Definition: HitXPModule.h:99
Belle2::HitXPModule::m_EtanlambdaEntry
std::vector< double > m_EtanlambdaEntry
external tanlambda parameter at entry point
Definition: HitXPModule.h:136
Belle2::HitXPModule::m_Eprimary
int m_Eprimary
external flag for primary particles
Definition: HitXPModule.h:138
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::HitXPModule::m_trackNumberSel
int m_trackNumberSel
selected iterative number of the track in the run
Definition: HitXPModule.h:88
Belle2::HitXPModule::m_Etime
std::vector< double > m_Etime
external time of the hit
Definition: HitXPModule.h:117
Belle2::HitXPModule::m_hitXPSel
std::vector< hitXP > m_hitXPSel
selected vector of hitXP
Definition: HitXPModule.h:87
Belle2::SVDTrueHit
Class SVDTrueHit - Records of tracks that either enter or leave the sensitive volume.
Definition: SVDTrueHit.h:35
Belle2::HitXPModule::m_treeTiSel
TTree * m_treeTiSel
tight selected output tree
Definition: HitXPModule.h:92
Belle2::HitXPModule::m_EpositionEntryY
std::vector< double > m_EpositionEntryY
exteral position at entry point, coordinate y
Definition: HitXPModule.h:102
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:40
Belle2::HitXPModule::m_trackNumber
int m_trackNumber
iterative number of the track in the run
Definition: HitXPModule.h:79
Belle2::HitXPModule
This module from a data root file builds a tree of hitXP (see the class to know all the informations ...
Definition: HitXPModule.h:48
Belle2::HitXPModule::m_Ereconstructed
std::vector< int > m_Ereconstructed
external flag of track-reconstruction or not
Definition: HitXPModule.h:121
Belle2::HitXPModule::m_EmomentumEntryY
std::vector< double > m_EmomentumEntryY
exteral momentum at entry point, coordinate x
Definition: HitXPModule.h:105
Belle2::HitXPModule::m_eventNumberTiSel
int m_eventNumberTiSel
tight selected interative number of the event in the run
Definition: HitXPModule.h:96
Belle2::HitXPModule::m_numberHitPerTrack
int m_numberHitPerTrack
counter of the number of the hit for each track
Definition: HitXPModule.h:81
Belle2::HitXPModule::m_EmomentumEntryZ
std::vector< double > m_EmomentumEntryZ
exteral momentum at entry point, coordinate x
Definition: HitXPModule.h:106
Belle2::HitXPModule::m_tree
TTree * m_tree
full output tree
Definition: HitXPModule.h:73
Belle2::HitXPModule::m_eventNumber
int m_eventNumber
interative number of the event in the run
Definition: HitXPModule.h:80
Belle2::HitXPModule::m_eventNumberSel
int m_eventNumberSel
selected interative number of the event in the run
Definition: HitXPModule.h:89
Belle2::HitXPModule::m_Ephi00
std::vector< double > m_Ephi00
external phi0 parameter at IP
Definition: HitXPModule.h:133
Belle2::HitXPModule::m_hitXPTiSel
std::vector< hitXP > m_hitXPTiSel
tight selected vector of hitXP
Definition: HitXPModule.h:94
Belle2::Module
Base class for Modules.
Definition: Module.h:74
Belle2::HitXPModule::terminate
void terminate() override
This method is called at the end of the event processing.
Definition: HitXPModule.cc:398
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:78
Belle2::HitXPModule::m_EomegaEntry
std::vector< double > m_EomegaEntry
external omega parameter at entry point
Definition: HitXPModule.h:128
Belle2::HitXPModule::m_EnumberHitPerTrack
int m_EnumberHitPerTrack
external numer of the hit for each track
Definition: HitXPModule.h:127
Belle2::HitXPModule::m_trackIterator
int m_trackIterator
iterator used to count track (m_trackNumber)
Definition: HitXPModule.h:82
Belle2::HitXPModule::m_Eposition0Y
std::vector< double > m_Eposition0Y
extral position at IP, coordinate y
Definition: HitXPModule.h:112
Belle2::HitXPModule::m_hitXPSet
std::set< hitXP, hitXP::timeCompare > m_hitXPSet
set of the hitXP, used to order tn time he hit
Definition: HitXPModule.h:76
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:215
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::HitXPModule::beginRun
void beginRun() override
Called when entering a new run.
Definition: HitXPModule.cc:159
Belle2::HitXPModule::m_Etanlambda0
std::vector< double > m_Etanlambda0
external tanlambda parameter at IP
Definition: HitXPModule.h:137
Belle2::HitXPModule::m_treeSel
TTree * m_treeSel
selected output tree
Definition: HitXPModule.h:85
Belle2::HitXPModule::m_Eomega0
std::vector< double > m_Eomega0
external omega parameter at IP
Definition: HitXPModule.h:129
Belle2::HitXPModule::m_EclusterU
std::vector< int > m_EclusterU
external flag of u-cluster
Definition: HitXPModule.h:122
Belle2::HitXPModule::m_EsensorSensor
std::vector< int > m_EsensorSensor
external sensor of the hit
Definition: HitXPModule.h:118
Belle2::HitXPModule::m_EeventNumber
int m_EeventNumber
external iterator of event in the run
Definition: HitXPModule.h:126
Belle2::HitXPModule::m_outputFileTiSel
TFile * m_outputFileTiSel
tight selected output file
Definition: HitXPModule.h:93
Belle2::HitXPModule::m_Echarge
std::vector< double > m_Echarge
external charge
Definition: HitXPModule.h:124
Belle2::HitXPModule::m_eventIterator
int m_eventIterator
iterator used to count event number (m_eventNumber)
Definition: HitXPModule.h:83
Belle2::HitXPModule::c_addTree
bool c_addTree
parameter to produce additional tree
Definition: HitXPModule.h:77
Belle2::HitXPModule::m_Emomentum0Y
std::vector< double > m_Emomentum0Y
extral momentum at IP, coordinate y
Definition: HitXPModule.h:115
Belle2::HitXPModule::m_EpositionLocalEntryZ
std::vector< double > m_EpositionLocalEntryZ
exteral local position at entry point, coordinate z
Definition: HitXPModule.h:109
Belle2::HitXPModule::m_outputFileSel
TFile * m_outputFileSel
selected output file
Definition: HitXPModule.h:86
Belle2::HitXPModule::m_Emomentum0Z
std::vector< double > m_Emomentum0Z
extral momentum at IP, coordinate z
Definition: HitXPModule.h:116
Belle2::HitXPModule::m_Eposition0Z
std::vector< double > m_Eposition0Z
extral position at IP, coordinate z
Definition: HitXPModule.h:113
Belle2::HitXPModule::m_treeExt
TTree * m_treeExt
external output tree
Definition: HitXPModule.h:100
Belle2::HitXPModule::m_EsensorLadder
std::vector< int > m_EsensorLadder
external ladder of the hit
Definition: HitXPModule.h:120
Belle2::SVDCluster
The SVD Cluster class This class stores all information about reconstructed SVD clusters.
Definition: SVDCluster.h:38
Belle2::HitXPModule::m_Ed0Entry
std::vector< double > m_Ed0Entry
external d0 parameter at entry point
Definition: HitXPModule.h:130
Belle2::HitXPModule::m_EtrackNumber
int m_EtrackNumber
external iterator of track in the run
Definition: HitXPModule.h:125
Belle2::HitXPModule::m_Ez00
std::vector< double > m_Ez00
external z0 parameter at IP
Definition: HitXPModule.h:135
Belle2::HitXPModule::m_EclusterV
std::vector< int > m_EclusterV
external flag of v-cluster
Definition: HitXPModule.h:123
Belle2::HitXPModule::m_EpositionEntryZ
std::vector< double > m_EpositionEntryZ
exteral position at entry point, coordinate z
Definition: HitXPModule.h:103
Belle2::HitXPModule::m_numberHitPerTrackTiSel
int m_numberHitPerTrackTiSel
tight selected counter of the number of the hit for each track
Definition: HitXPModule.h:97
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::MCParticle
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:43
Belle2::hitXPDerivate
This class is the derivate of HitXP, and complete it with a constructor that use all other complex ty...
Definition: hitXPDerivate.h:37
Belle2::StoreArray< SVDCluster >
Belle2::HitXPModule::m_Ed00
std::vector< double > m_Ed00
external d0 parameter at IP
Definition: HitXPModule.h:131
Belle2::HitXPModule::m_EPDGID
std::vector< int > m_EPDGID
external PDGID
Definition: HitXPModule.h:110
Belle2::HitXPModule::m_Emomentum0X
std::vector< double > m_Emomentum0X
extral momentum at IP, coordinate x
Definition: HitXPModule.h:114
Belle2::HitXPModule::m_numberHitPerTrackSel
int m_numberHitPerTrackSel
selected counter of the number of the hit for each track
Definition: HitXPModule.h:90
Belle2::HitXPModule::m_EmomentumEntryX
std::vector< double > m_EmomentumEntryX
exteral momentum at entry point, coordinate x
Definition: HitXPModule.h:104
Belle2::HitXPModule::m_Eposition0X
std::vector< double > m_Eposition0X
extral position at IP, coordinate x
Definition: HitXPModule.h:111
Belle2::HitXPModule::m_EsensorLayer
std::vector< int > m_EsensorLayer
external layer of the hit
Definition: HitXPModule.h:119
Belle2::HitXPModule::event
void event() override
This method is the core of the module.
Definition: HitXPModule.cc:161