Belle II Software  release-08-00-10
SVDPerformanceTTreeModule.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/svdPerformance/SVDPerformanceTTreeModule.h>
10 #include <framework/datastore/StoreArray.h>
11 #include <framework/gearbox/Unit.h>
12 #include <framework/core/Environment.h>
13 #include <svd/dataobjects/SVDCluster.h>
14 #include <svd/dataobjects/SVDRecoDigit.h>
15 #include <svd/dataobjects/SVDShaperDigit.h>
16 #include <svd/dataobjects/SVDTrueHit.h>
17 #include <svd/dataobjects/SVDEventInfo.h>
18 #include <vxd/dataobjects/VxdID.h>
19 #include <vxd/geometry/GeoCache.h>
20 #include <vxd/geometry/SensorInfoBase.h>
21 #include <tracking/dataobjects/RecoTrack.h>
22 #include <tracking/dataobjects/RecoHitInformation.h>
23 #include <genfit/TrackPoint.h>
24 #include <TVector3.h>
25 #include <Math/Boost.h>
26 #include <math.h>
27 #include <iostream>
28 #include <algorithm>
29 #include <mdst/dataobjects/Track.h>
30 #include <mdst/dataobjects/TrackFitResult.h>
31 
32 
33 using namespace Belle2;
34 using namespace std;
35 
36 
37 //-----------------------------------------------------------------
38 // Register the Module
39 //-----------------------------------------------------------------
40 REG_MODULE(SVDPerformanceTTree);
41 
42 //-----------------------------------------------------------------
43 // Implementation
44 //-----------------------------------------------------------------
45 
46 SVDPerformanceTTreeModule::SVDPerformanceTTreeModule() : Module()
47 {
48  //Set module properties
49  setDescription("The module is used to create a TTree to study SVD clusters, genfit unbiased residuals and many other properties related to the track they belong to.");
50  //Parameter to take only specific RecoTracks as input
51  addParam("outputFileName", m_rootFileName, "Name of output root file.", std::string("SVDPerformanceTTree.root"));
52  addParam("recoTracksStoreArrayName", m_recoTracksStoreArrayName, "StoreArray name of the input and output RecoTracks.",
53  m_recoTracksStoreArrayName);
54 }
55 
56 void SVDPerformanceTTreeModule::initialize()
57 {
58  StoreArray<RecoTrack> recoTracks(m_recoTracksStoreArrayName);
59  recoTracks.isOptional();
60  m_EventT0.isOptional();
61 
62  m_rootFilePtr = new TFile(m_rootFileName.c_str(), "RECREATE");
63 
64  //Tree for SVD u overlapping clusters
65  m_t_U = new TTree("t_U", "Tree for SVD u-clusters");
66  m_t_U->Branch("cdcEventT0", &m_cdcEventT0, "cdcEventT0/F");
67  m_t_U->Branch("cdcEventT0_6SRF", &m_cdcEventT0_6SRF, "cdcEventT0_6SRF/F");
68  m_t_U->Branch("cdcEventT0_3SRF", &m_cdcEventT0_3SRF, "cdcEventT0_3SRF/F");
69  m_t_U->Branch("cdcEventT0Err", &m_cdcEventT0Err, "cdcEventT0Err/F");
70  m_t_U->Branch("svdTB", &m_svdTB, "svdTB/i");
71  m_t_U->Branch("svdClSNR", &m_svdClSNR, "svdClSNR/F");
72  m_t_U->Branch("svdClCharge", &m_svdClCharge, "svdClCharge/F");
73  m_t_U->Branch("svdStripCharge", &m_svdStripCharge);
74  m_t_U->Branch("svdStrip6Samples", &m_svdStrip6Samples);
75  m_t_U->Branch("svdClTime", &m_svdClTime, "svdClTime/F");
76  m_t_U->Branch("svdClTimeErr", &m_svdClTimeErr, "svdClTimeErr/F");
77  m_t_U->Branch("svdClTime_6SRF", &m_svdClTime_6SRF, "svdClTime_6SRF/F");
78  m_t_U->Branch("svdClTime_3SRF", &m_svdClTime_3SRF, "svdClTime_3SRF/F");
79  m_t_U->Branch("svdFF", &m_svdFF, "svdFF/i");
80  m_t_U->Branch("svdStripTime", &m_svdStripTime);
81  m_t_U->Branch("svdStripPosition", &m_svdStripPosition);
82  m_t_U->Branch("svdRes", &m_svdRes, "svdRes/F");
83  m_t_U->Branch("svdPitch", &m_svdPitch, "svdPitch/F");
84  m_t_U->Branch("svdWidth", &m_svdWidth, "svdWidth/F");
85  m_t_U->Branch("svdLength", &m_svdLength, "svdLength/F");
86  m_t_U->Branch("svdClIntStrPos", &m_svdClIntStrPos, "svdClIntStrPos/F");
87  m_t_U->Branch("svdClPos", &m_svdClPos, "svdClPos/F");
88  m_t_U->Branch("svdClPosErr", &m_svdClPosErr, "svdClPosErr/F");
89  m_t_U->Branch("svdTruePos", &m_svdTruePos, "svdTruePos/F");
90  m_t_U->Branch("svdClPhi", &m_svdClPhi, "svdClPhi/F");
91  m_t_U->Branch("svdClZ", &m_svdClZ, "svdClZ/F");
92  m_t_U->Branch("svdTrkd0", &m_svdTrkd0, "svdTrkd0/F");
93  m_t_U->Branch("svdTrkz0", &m_svdTrkz0, "svdTrkz0/F");
94  m_t_U->Branch("svdTrkpT", &m_svdTrkpT, "svdTrkpT/F");
95  m_t_U->Branch("svdTrkpCM", &m_svdTrkpCM, "svdTrkpCM/F");
96  m_t_U->Branch("svdTrkTraversedLength", &m_svdTrkTraversedLength, "svdTrkTraversedLength/F");
97  m_t_U->Branch("svdTrkPXDHits", &m_svdTrkPXDHits, "svdTrkPXDHits/i");
98  m_t_U->Branch("svdTrkSVDHits", &m_svdTrkSVDHits, "svdTrkSVDHits/i");
99  m_t_U->Branch("svdTrkCDCHits", &m_svdTrkCDCHits, "svdTrkCDCHits/i");
100  m_t_U->Branch("svdTrkPos", &m_svdTrkPos, "svdTrkPos/F");
101  m_t_U->Branch("svdTrkPosOS", &m_svdTrkPosOS, "svdTrkPosOS/F");
102  m_t_U->Branch("svdTrkPosErr", &m_svdTrkPosErr, "svdTrkPosErr/F");
103  m_t_U->Branch("svdTrkPosErrOS", &m_svdTrkPosErrOS, "svdTrkPosErrOS/F");
104  m_t_U->Branch("svdTrkQoP", &m_svdTrkQoP, "svdTrkQoP/F");
105  m_t_U->Branch("svdTrkPrime", &m_svdTrkPrime, "svdTrkPrime/F");
106  m_t_U->Branch("svdTrkPrimeOS", &m_svdTrkPrimeOS, "svdTrkPrimeOS/F");
107  m_t_U->Branch("svdTrkPosUnbiased", &m_svdTrkPosUnbiased, "svdTrkPosUnbiased/F");
108  m_t_U->Branch("svdTrkPosErrUnbiased", &m_svdTrkPosErrUnbiased, "svdTrkPosErrUnbiased/F");
109  m_t_U->Branch("svdTrkQoPUnbiased", &m_svdTrkQoPUnbiased, "svdTrkQoPUnbiased/F");
110  m_t_U->Branch("svdTrkPrimeUnbiased", &m_svdTrkPrimeUnbiased, "svdTrkPrimeUnbiased/F");
111  m_t_U->Branch("svdLayer", &m_svdLayer, "svdLayer/i");
112  m_t_U->Branch("svdLadder", &m_svdLadder, "svdLadder/i");
113  m_t_U->Branch("svdSensor", &m_svdSensor, "svdSensor/i");
114  m_t_U->Branch("svdSize", &m_svdSize, "svdSize/i");
115  //Tree for SVD v overlapping clusters
116  m_t_V = new TTree("t_V", "Tree for SVD v-clusters");
117  m_t_V->Branch("cdcEventT0", &m_cdcEventT0, "cdcEventT0/F");
118  m_t_V->Branch("cdcEventT0_6SRF", &m_cdcEventT0_6SRF, "cdcEventT0_6SRF/F");
119  m_t_V->Branch("cdcEventT0_3SRF", &m_cdcEventT0_3SRF, "cdcEventT0_3SRF/F");
120  m_t_V->Branch("cdcEventT0Err", &m_cdcEventT0Err, "cdcEventT0Err/F");
121  m_t_V->Branch("svdTB", &m_svdTB, "svdTB/i");
122  m_t_V->Branch("svdClSNR", &m_svdClSNR, "svdClSNR/F");
123  m_t_V->Branch("svdClCharge", &m_svdClCharge, "svdClCharge/F");
124  m_t_V->Branch("svdStripCharge", &m_svdStripCharge);
125  m_t_V->Branch("svdStrip6Samples", &m_svdStrip6Samples);
126  m_t_V->Branch("svdClTime", &m_svdClTime, "svdClTime/F");
127  m_t_V->Branch("svdClTimeErr", &m_svdClTimeErr, "svdClTimeErr/F");
128  m_t_V->Branch("svdClTime_6SRF", &m_svdClTime_6SRF, "svdClTime_6SRF/F");
129  m_t_V->Branch("svdClTime_3SRF", &m_svdClTime_3SRF, "svdClTime_3SRF/F");
130  m_t_V->Branch("svdFF", &m_svdFF, "svdFF/i");
131  m_t_V->Branch("svdStripTime", &m_svdStripTime);
132  m_t_V->Branch("svdStripPosition", &m_svdStripPosition);
133  m_t_V->Branch("svdRes", &m_svdRes, "svdRes/F");
134  m_t_V->Branch("svdPitch", &m_svdPitch, "svdPitch/F");
135  m_t_V->Branch("svdWidth", &m_svdWidth, "svdWidth/F");
136  m_t_V->Branch("svdLength", &m_svdLength, "svdLength/F");
137  m_t_V->Branch("svdClIntStrPos", &m_svdClIntStrPos, "svdClIntStrPos/F");
138  m_t_V->Branch("svdClPos", &m_svdClPos, "svdClPos/F");
139  m_t_V->Branch("svdClPosErr", &m_svdClPosErr, "svdClPosErr/F");
140  m_t_V->Branch("svdTruePos", &m_svdTruePos, "svdTruePos/F");
141  m_t_V->Branch("svdClPhi", &m_svdClPhi, "svdClPhi/F");
142  m_t_V->Branch("svdClZ", &m_svdClZ, "svdClZ/F");
143  m_t_V->Branch("svdTrkd0", &m_svdTrkd0, "svdTrkd0/F");
144  m_t_V->Branch("svdTrkz0", &m_svdTrkz0, "svdTrkz0/F");
145  m_t_V->Branch("svdTrkpT", &m_svdTrkpT, "svdTrkpT/F");
146  m_t_V->Branch("svdTrkpCM", &m_svdTrkpCM, "svdTrkpCM/F");
147  m_t_V->Branch("svdTrkTraversedLength", &m_svdTrkTraversedLength, "svdTrkTraversedLength/F");
148  m_t_V->Branch("svdTrkPXDHits", &m_svdTrkPXDHits, "svdTrkPXDHits/i");
149  m_t_V->Branch("svdTrkSVDHits", &m_svdTrkSVDHits, "svdTrkSVDHits/i");
150  m_t_V->Branch("svdTrkCDCHits", &m_svdTrkCDCHits, "svdTrkCDCHits/i");
151  m_t_V->Branch("svdTrkPos", &m_svdTrkPos, "svdTrkPos/F");
152  m_t_V->Branch("svdTrkPosOS", &m_svdTrkPosOS, "svdTrkPosOS/F");
153  m_t_V->Branch("svdTrkPosErr", &m_svdTrkPosErr, "svdTrkPosErr/F");
154  m_t_V->Branch("svdTrkPosErrOS", &m_svdTrkPosErrOS, "svdTrkPosErrOS/F");
155  m_t_V->Branch("svdTrkQoP", &m_svdTrkQoP, "svdTrkQoP/F");
156  m_t_V->Branch("svdTrkPrime", &m_svdTrkPrime, "svdTrkPrime/F");
157  m_t_V->Branch("svdTrkPrimeOS", &m_svdTrkPrimeOS, "svdTrkPrimeOS/F");
158  m_t_V->Branch("svdTrkPosUnbiased", &m_svdTrkPosUnbiased, "svdTrkPosUnbiased/F");
159  m_t_V->Branch("svdTrkPosErrUnbiased", &m_svdTrkPosErrUnbiased, "svdTrkPosErrUnbiased/F");
160  m_t_V->Branch("svdTrkQoPUnbiased", &m_svdTrkQoPUnbiased, "svdTrkQoPUnbiased/F");
161  m_t_V->Branch("svdTrkPrimeUnbiased", &m_svdTrkPrimeUnbiased, "svdTrkPrimeUnbiased/F");
162  m_t_V->Branch("svdLayer", &m_svdLayer, "svdLayer/i");
163  m_t_V->Branch("svdLadder", &m_svdLadder, "svdLadder/i");
164  m_t_V->Branch("svdSensor", &m_svdSensor, "svdSensor/i");
165  m_t_V->Branch("svdSize", &m_svdSize, "svdSize/i");
166 
167 }
168 
169 void SVDPerformanceTTreeModule::beginRun()
170 {
172  m_apvClockPeriod = 1. / m_hwClock->getClockFrequency(Const::EDetector::SVD, "sampling");
173 }
174 void SVDPerformanceTTreeModule::event()
175 {
176 
177  m_cdcEventT0 = std::numeric_limits<float>::quiet_NaN();
178  m_cdcEventT0_6SRF = std::numeric_limits<float>::quiet_NaN();
179  m_cdcEventT0_3SRF = std::numeric_limits<float>::quiet_NaN();
180  m_cdcEventT0Err = std::numeric_limits<float>::quiet_NaN();
181 
182  if (m_EventT0.isValid())
183  if (m_EventT0->hasEventT0()) {
184  if (m_EventT0->hasTemporaryEventT0(Const::EDetector::CDC)) {
185  auto evtT0List_CDC = m_EventT0->getTemporaryEventT0s(Const::EDetector::CDC) ;
186  // The most accurate CDC event t0 value is the last one in the list.
187  m_cdcEventT0 = evtT0List_CDC.back().eventT0 ;
188  m_cdcEventT0Err = evtT0List_CDC.back().eventT0Uncertainty;
189  }
190  }
191 
192  //first check SVDEventInfo name
193  StoreObjPtr<SVDEventInfo> temp_eventinfo("SVDEventInfo");
194  std::string m_svdEventInfoName = "SVDEventInfo";
195  if (!temp_eventinfo.isValid())
196  m_svdEventInfoName = "SVDEventInfoSim";
197  StoreObjPtr<SVDEventInfo> eventinfo(m_svdEventInfoName);
198  if (!eventinfo) B2ERROR("No SVDEventInfo!");
199  m_svdTB = eventinfo->getModeByte().getTriggerBin();
200 
201  bool isMC = Environment::Instance().isMC();
202 
203  static VXD::GeoCache& geo = VXD::GeoCache::getInstance();
204  StoreArray<RecoTrack> recoTracks(m_recoTracksStoreArrayName);
205  for (const auto& trk : recoTracks) {
206  if (! trk.wasFitSuccessful()) {
207  continue;
208  }
209 
210 
211  RelationVector<Track> theTK = DataStore::getRelationsWithObj<Track>(&trk);
212 
213  if (theTK.size() == 0) {
214  continue;
215  }
216 
217 
218  const TrackFitResult* tfr = theTK[0]->getTrackFitResultWithClosestMass(Const::pion);
219 
220  if (tfr) {
221  m_svdTrkd0 = tfr->getD0();
222  m_svdTrkz0 = tfr->getZ0();
223  m_svdTrkpT = tfr->getMomentum().Rho();
224  ROOT::Math::PxPyPzEVector pStar = tfr->get4Momentum();
225  ROOT::Math::BoostZ boost(3. / 11);
226  pStar = boost(pStar);
227  m_svdTrkpCM = pStar.P();
228  }
229 
230 
231  const vector<SVDCluster* > svdClusters = trk.getSVDHitList();
232  B2DEBUG(40, "FITTED TRACK: NUMBER OF SVD HITS = " << svdClusters.size());
233 
234  m_svdTrkPXDHits = (trk.getPXDHitList()).size();
235  m_svdTrkSVDHits = (trk.getSVDHitList()).size();
236  m_svdTrkCDCHits = (trk.getCDCHitList()).size();
237 
238  for (unsigned int i = 0; i < svdClusters.size(); i++) {
239 
240  const SVDCluster* svd_1 = svdClusters[i];
241 
242  //get true hits, used only if isMC
243  RelationVector<SVDTrueHit> trueHit_1 = DataStore::getRelationsWithObj<SVDTrueHit>(svd_1);
244 
245  const RecoHitInformation* infoSVD_1 = trk.getRecoHitInformation(svd_1);
246  if (!infoSVD_1) {
247  continue;
248  }
249  const auto* hitTrackPoint_1 = trk.getCreatedTrackPoint(infoSVD_1);
250  const auto* fittedResult_1 = hitTrackPoint_1->getFitterInfo();
251  if (!fittedResult_1) {
252  continue;
253  }
254  const VxdID svd_id_1 = svd_1->getSensorID();
255  const unsigned short svd_Layer_1 = svd_id_1.getLayerNumber();
256  const unsigned short svd_Ladder_1 = svd_id_1.getLadderNumber();
257  const unsigned short svd_Sensor_1 = svd_id_1.getSensorNumber();
258 
259  try {
260  const TVectorD resUnBias_1 = fittedResult_1->getResidual(0, false).getState();
261  genfit::MeasuredStateOnPlane state_unbiased = fittedResult_1->getFittedState(false);
262  const TVectorD& svd_predIntersect_unbiased = state_unbiased.getState();
263  const TMatrixDSym& covMatrix_unbiased = state_unbiased.getCov();
264  genfit::MeasuredStateOnPlane state_1 = trk.getMeasuredStateOnPlaneFromRecoHit(infoSVD_1);
265  const TVectorD& svd_predIntersect_1 = state_1.getState();
266  const TMatrixDSym& covMatrix_1 = state_1.getCov();
267 
268  if (svd_1->isUCluster()) {
269 
270  const int strips_1 = svd_1->getSize();
271 
272  const double res_U_1 = resUnBias_1.GetMatrixArray()[0] * Unit::convertValueToUnit(1.0, "um");
273  const ROOT::Math::XYZVector svdLocal_1(svd_1->getPosition(), svd_predIntersect_1[4], 0.);
274  const VXD::SensorInfoBase& svdSensor_1 = geo.get(svd_id_1);
275  const ROOT::Math::XYZVector& svdGlobal_1 = svdSensor_1.pointToGlobal(svdLocal_1);
276  double svdPhi_1 = atan2(svdGlobal_1.Y(), svdGlobal_1.X()); // maybe use svdGlobal_1.Phi()
277  double svdZ_1 = svdGlobal_1.Z();
278 
279  m_svdFF = svd_1->getFirstFrame();
280  //Fill SVD tree for u-overlaps if required by the user
281  m_svdRes = res_U_1;
282  m_svdClTime = svd_1->getClsTime();
283  m_svdClTimeErr = svd_1->getClsTimeSigma();
284  m_svdClSNR = svd_1->getSNR();
285  m_svdClCharge = svd_1->getCharge();
286  m_svdClPosErr = svd_1->getPositionSigma();
287  if (isMC && trueHit_1.size() > 0)
288  m_svdTruePos = trueHit_1[0]->getU();
289  else
290  m_svdTruePos = -99;
291  m_svdClPhi = svdPhi_1;
292  m_svdClZ = svdZ_1;
293  m_svdTrkPos = svd_predIntersect_1[3];
294  m_svdTrkPosOS = svd_predIntersect_1[4];
295  m_svdTrkPosErr = sqrt(covMatrix_1[3][3]);
296  m_svdTrkPosErrOS = sqrt(covMatrix_1[4][4]);
297  m_svdTrkQoP = svd_predIntersect_1[0];
298  m_svdTrkPrime = svd_predIntersect_1[1];
299  m_svdTrkPrimeOS = svd_predIntersect_1[2];
300  m_svdTrkTraversedLength = svdSensor_1.getThickness() * sqrt(1 + m_svdTrkPrimeOS * m_svdTrkPrimeOS + m_svdTrkPrime * m_svdTrkPrime);
301  m_svdTrkPosUnbiased = svd_predIntersect_unbiased[3];
302  m_svdClPos = m_svdRes / 1e4 + m_svdTrkPosUnbiased;
303  m_svdTrkPosErrUnbiased = sqrt(covMatrix_unbiased[3][3]);
304  m_svdTrkQoPUnbiased = svd_predIntersect_unbiased[0];
305  m_svdTrkPrimeUnbiased = svd_predIntersect_unbiased[1];
306  m_svdLayer = svd_Layer_1;
307  m_svdLadder = svd_Ladder_1;
308  m_svdSensor = svd_Sensor_1;
309  m_svdSize = strips_1;
310 
311  m_svdPitch = svdSensor_1.getUPitch(m_svdTrkPosOS);
312  m_svdWidth = svdSensor_1.getUSize(m_svdTrkPosOS);
313  m_svdLength = svdSensor_1.getVSize();
314 
315  m_svdClIntStrPos = fmod(m_svdClPos + 0.5 * m_svdWidth, m_svdPitch) / m_svdPitch;
316 
317  m_svdStripCharge.clear();
318  m_svdStripTime.clear();
319  m_svdStripPosition.clear();
320  m_svdStrip6Samples.clear();
321  //retrieve relations and set strip charges and times
322  RelationVector<SVDRecoDigit> theRecoDigits = DataStore::getRelationsWithObj<SVDRecoDigit>(svd_1);
323  if ((theRecoDigits.size() != m_svdSize) && (m_svdSize != 128)) //virtual cluster
324  B2ERROR(" Inconsistency with cluster size! # recoDigits = " << theRecoDigits.size() << " != " << m_svdSize << " cluster size");
325 
326  //skip clusters created beacuse of missing APV
327  if (m_svdSize < 128)
328  for (unsigned int d = 0; d < m_svdSize; d++) {
329 
330  SVDShaperDigit* ShaperDigit = theRecoDigits[d]->getRelated<SVDShaperDigit>();
331  array<float, 6> Samples = ShaperDigit->getSamples();
332 
333  m_svdStripCharge.push_back(theRecoDigits[d]->getCharge());
334  std::copy(std::begin(Samples), std::end(Samples), std::back_inserter(m_svdStrip6Samples));
335  m_svdStripTime.push_back(theRecoDigits[d]->getTime());
336  double misalignedStripPos = svdSensor_1.getUCellPosition(theRecoDigits[d]->getCellID());
337  //aligned strip pos = misaligned strip - ( misaligned cluster - aligned cluster)
338  m_svdStripPosition.push_back(misalignedStripPos - svd_1->getPosition() + m_svdClPos);
339  }
340 
341  m_cdcEventT0_3SRF = eventinfo->getTimeInSVDReference(m_cdcEventT0, m_svdFF);
342  m_cdcEventT0_6SRF = m_cdcEventT0_3SRF + m_apvClockPeriod * m_svdFF;
343  m_svdClTime_3SRF = eventinfo->getTimeInSVDReference(m_svdClTime, m_svdFF);
344  m_svdClTime_6SRF = m_svdClTime_3SRF + m_apvClockPeriod * m_svdFF;
345 
346  m_t_U->Fill();
347 
348  } else {
349  const int strips_1 = svd_1->getSize();
350  const double res_V_1 = resUnBias_1.GetMatrixArray()[0] * Unit::convertValueToUnit(1.0, "um");
351  const ROOT::Math::XYZVector svdLocal_1(svd_predIntersect_1[3], svd_1->getPosition(), 0.);
352  const VXD::SensorInfoBase& svdSensor_1 = geo.get(svd_id_1);
353  const ROOT::Math::XYZVector& svdGlobal_1 = svdSensor_1.pointToGlobal(svdLocal_1);
354  double svdPhi_1 = atan2(svdGlobal_1.Y(), svdGlobal_1.X()); // maybe use svdGlobal_1.Phi()
355  double svdZ_1 = svdGlobal_1.Z();
356 
357  m_svdFF = svd_1->getFirstFrame();
358 
359  m_svdRes = res_V_1;
360  m_svdClTime = svd_1->getClsTime();
361  m_svdClTimeErr = svd_1->getClsTimeSigma();
362  m_svdClSNR = svd_1->getSNR();
363  m_svdClCharge = svd_1->getCharge();
364  m_svdClPosErr = svd_1->getPositionSigma();
365  if (isMC && trueHit_1.size() > 0)
366  m_svdTruePos = trueHit_1[0]->getV();
367  else
368  m_svdTruePos = -99;
369  m_svdClPhi = svdPhi_1;
370  m_svdClZ = svdZ_1;
371  m_svdTrkPos = svd_predIntersect_1[4];
372  m_svdTrkPosOS = svd_predIntersect_1[3];
373  m_svdTrkPosErr = sqrt(covMatrix_1[4][4]);
374  m_svdTrkPosErrOS = sqrt(covMatrix_1[3][3]);
375  m_svdTrkQoP = svd_predIntersect_1[0];
376  m_svdTrkPrime = svd_predIntersect_1[2];
377  m_svdTrkPrimeOS = svd_predIntersect_1[1];
378  m_svdTrkTraversedLength = svdSensor_1.getThickness() * sqrt(1 + m_svdTrkPrimeOS * m_svdTrkPrimeOS + m_svdTrkPrime * m_svdTrkPrime);
379  m_svdTrkPosUnbiased = svd_predIntersect_unbiased[4];
380  m_svdClPos = m_svdRes / 1e4 + m_svdTrkPosUnbiased;
381  m_svdTrkPosErrUnbiased = sqrt(covMatrix_unbiased[4][4]);
382  m_svdTrkQoPUnbiased = svd_predIntersect_unbiased[0];
383  m_svdTrkPrimeUnbiased = svd_predIntersect_unbiased[2];
384  m_svdLayer = svd_Layer_1;
385  m_svdLadder = svd_Ladder_1;
386  m_svdSensor = svd_Sensor_1;
387  m_svdSize = strips_1;
388 
389  m_svdPitch = svdSensor_1.getVPitch();
390  m_svdWidth = svdSensor_1.getUSize(m_svdTrkPos);
391  m_svdLength = svdSensor_1.getVSize();
392 
393  m_svdClIntStrPos = fmod(m_svdClPos + 0.5 * m_svdLength, m_svdPitch) / m_svdPitch;
394 
395  m_svdStripCharge.clear();
396  m_svdStripTime.clear();
397  m_svdStripPosition.clear();
398  m_svdStrip6Samples.clear();
399  //retrieve relations and set strip charges and times
400  RelationVector<SVDRecoDigit> theRecoDigits = DataStore::getRelationsWithObj<SVDRecoDigit>(svd_1);
401  if ((theRecoDigits.size() != m_svdSize) && (m_svdSize != 128)) //virtual cluster
402  B2ERROR(" Inconsistency with cluster size! # recoDigits = " << theRecoDigits.size() << " != " << m_svdSize << " cluster size");
403 
404  //skip clusters created beacuse of missing APV
405  if (m_svdSize < 128)
406  for (unsigned int d = 0; d < m_svdSize; d++) {
407  SVDShaperDigit* ShaperDigit = theRecoDigits[d]->getRelated<SVDShaperDigit>();
408  array<float, 6> Samples = ShaperDigit->getSamples();
409  m_svdStripCharge.push_back(theRecoDigits[d]->getCharge());
410  std::copy(std::begin(Samples), std::end(Samples), std::back_inserter(m_svdStrip6Samples));
411  m_svdStripTime.push_back(theRecoDigits[d]->getTime());
412  double misalignedStripPos = svdSensor_1.getVCellPosition(theRecoDigits[d]->getCellID());
413  //Aligned strip pos = misaligned strip - ( misaligned cluster - aligned cluster)
414  m_svdStripPosition.push_back(misalignedStripPos - svd_1->getPosition() + m_svdClPos);
415  }
416 
417  m_cdcEventT0_3SRF = eventinfo->getTimeInSVDReference(m_cdcEventT0, m_svdFF);
418  m_cdcEventT0_6SRF = m_cdcEventT0_3SRF + m_apvClockPeriod * m_svdFF;
419  m_svdClTime_3SRF = eventinfo->getTimeInSVDReference(m_svdClTime, m_svdFF);
420  m_svdClTime_6SRF = m_svdClTime_3SRF + m_apvClockPeriod * m_svdFF;
421 
422 
423  m_t_V->Fill();
424  }
425  } catch (...) {
426  B2INFO("oops...something went wrong in getting the unbiased state, skipping this cluster.");
427  continue;
428  }
429 
430  }
431  }
432 }
433 
434 
435 void SVDPerformanceTTreeModule::terminate()
436 {
437 
438  if (m_rootFilePtr != nullptr) {
439  m_rootFilePtr->cd();
440  m_t_U->Write();
441  m_t_V->Write();
442  m_rootFilePtr->Close();
443  }
444 }
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:652
Belle2::Environment::isMC
bool isMC() const
Do we have generated, not real data?
Definition: Environment.cc:54
Belle2::Environment::Instance
static Environment & Instance()
Static method to get a reference to the Environment instance.
Definition: Environment.cc:28
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::RecoHitInformation
This class stores additional information to every CDC/SVD/PXD hit stored in a RecoTrack.
Definition: RecoHitInformation.h:38
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::SVDCluster::getClsTime
float getClsTime() const
Get average of waveform maximum times of cluster strip signals.
Definition: SVDCluster.h:134
Belle2::SVDCluster::getSNR
float getSNR() const
Get cluster SNR.
Definition: SVDCluster.h:159
Belle2::SVDCluster::getSize
unsigned short getSize() const
Get cluster size.
Definition: SVDCluster.h:154
Belle2::SVDCluster::getCharge
float getCharge() const
Get collected charge.
Definition: SVDCluster.h:144
Belle2::SVDCluster::getSensorID
VxdID getSensorID() const
Get the sensor ID.
Definition: SVDCluster.h:102
Belle2::SVDCluster::isUCluster
bool isUCluster() const
Get the direction of strips.
Definition: SVDCluster.h:110
Belle2::SVDCluster::getPosition
float getPosition(double v=0) const
Get the coordinate of reconstructed hit.
Definition: SVDCluster.h:117
Belle2::SVDCluster::getClsTimeSigma
float getClsTimeSigma() const
Get the error of the reconstructed hit time.
Definition: SVDCluster.h:139
Belle2::SVDCluster::getPositionSigma
float getPositionSigma() const
Get the error of the reconstructed hit coordinate.
Definition: SVDCluster.h:129
Belle2::SVDCluster::getFirstFrame
int getFirstFrame() const
Get firstFrame of the MaxSum algorithm.
Definition: SVDCluster.h:169
Belle2::SVDPerformanceTTreeModule::m_svdTrkPrimeOS
float m_svdTrkPrimeOS
tan of incident angle projected on v/u,w (other side)
Definition: SVDPerformanceTTreeModule.h:100
Belle2::SVDPerformanceTTreeModule::m_svdClIntStrPos
float m_svdClIntStrPos
cluster interstrip position
Definition: SVDPerformanceTTreeModule.h:76
Belle2::SVDPerformanceTTreeModule::m_svdTrkPosErrOS
float m_svdTrkPosErrOS
track position error on the other side
Definition: SVDPerformanceTTreeModule.h:97
Belle2::SVDPerformanceTTreeModule::m_t_V
TTree * m_t_V
tree containing info related to the V side clusters
Definition: SVDPerformanceTTreeModule.h:58
Belle2::SVDPerformanceTTreeModule::initialize
void initialize() override
Register input and output data.
Definition: SVDPerformanceTTreeModule.cc:56
Belle2::SVDPerformanceTTreeModule::m_svdStripPosition
std::vector< float > m_svdStripPosition
absolute position of the strips of the cluster
Definition: SVDPerformanceTTreeModule.h:85
Belle2::SVDPerformanceTTreeModule::m_svdClPosErr
float m_svdClPosErr
cluster position error
Definition: SVDPerformanceTTreeModule.h:78
Belle2::SVDPerformanceTTreeModule::m_svdTrkCDCHits
int m_svdTrkCDCHits
number of CDC hits on the track
Definition: SVDPerformanceTTreeModule.h:88
Belle2::SVDPerformanceTTreeModule::m_svdTrkPrime
float m_svdTrkPrime
tan of incident angle projected on u/v,w
Definition: SVDPerformanceTTreeModule.h:99
Belle2::SVDPerformanceTTreeModule::event
void event() override
Compute the variables and fill the tree.
Definition: SVDPerformanceTTreeModule.cc:174
Belle2::SVDPerformanceTTreeModule::m_svdTrkPXDHits
int m_svdTrkPXDHits
number of PXD hits on the track
Definition: SVDPerformanceTTreeModule.h:86
Belle2::SVDPerformanceTTreeModule::terminate
void terminate() override
Write the TTrees to the file.
Definition: SVDPerformanceTTreeModule.cc:435
Belle2::SVDPerformanceTTreeModule::m_cdcEventT0_3SRF
float m_cdcEventT0_3SRF
CDC event T0 in the 3-sample SVD ref frame.
Definition: SVDPerformanceTTreeModule.h:62
Belle2::SVDPerformanceTTreeModule::m_svdStripCharge
std::vector< float > m_svdStripCharge
charge of the strips of the cluster
Definition: SVDPerformanceTTreeModule.h:82
Belle2::SVDPerformanceTTreeModule::beginRun
void beginRun() override
Compute the APV clock period.
Definition: SVDPerformanceTTreeModule.cc:169
Belle2::SVDPerformanceTTreeModule::m_svdTrkTraversedLength
float m_svdTrkTraversedLength
traversed length of the track in the sensor
Definition: SVDPerformanceTTreeModule.h:93
Belle2::SVDPerformanceTTreeModule::m_svdTrkPosUnbiased
float m_svdTrkPosUnbiased
unbiased track position
Definition: SVDPerformanceTTreeModule.h:101
Belle2::SVDPerformanceTTreeModule::m_hwClock
DBObjPtr< HardwareClockSettings > m_hwClock
Hardware Clocks.
Definition: SVDPerformanceTTreeModule.h:48
Belle2::SVDPerformanceTTreeModule::m_svdStrip6Samples
std::vector< float > m_svdStrip6Samples
6 samples of the strips of the cluster
Definition: SVDPerformanceTTreeModule.h:83
Belle2::SVDPerformanceTTreeModule::m_svdRes
float m_svdRes
residual computed by genfit
Definition: SVDPerformanceTTreeModule.h:72
Belle2::SVDPerformanceTTreeModule::m_EventT0
StoreObjPtr< EventT0 > m_EventT0
event T0
Definition: SVDPerformanceTTreeModule.h:45
Belle2::SVDPerformanceTTreeModule::m_svdTrkPosErrUnbiased
float m_svdTrkPosErrUnbiased
unbiased track position error
Definition: SVDPerformanceTTreeModule.h:102
Belle2::SVDPerformanceTTreeModule::m_t_U
TTree * m_t_U
tree containing info related to the U side clusters
Definition: SVDPerformanceTTreeModule.h:57
Belle2::SVDPerformanceTTreeModule::m_svdTrkPosOS
float m_svdTrkPosOS
track position on the other side
Definition: SVDPerformanceTTreeModule.h:95
Belle2::SVDPerformanceTTreeModule::m_svdClTime_6SRF
float m_svdClTime_6SRF
cluster time in the 6-sample SVD ref frame
Definition: SVDPerformanceTTreeModule.h:70
Belle2::SVDPerformanceTTreeModule::m_svdStripTime
std::vector< float > m_svdStripTime
time of the strips of the cluster
Definition: SVDPerformanceTTreeModule.h:84
Belle2::SVDPerformanceTTreeModule::m_svdTrkPrimeUnbiased
float m_svdTrkPrimeUnbiased
unbiased tan of incident angle projected on u,w
Definition: SVDPerformanceTTreeModule.h:104
Belle2::SVDPerformanceTTreeModule::m_cdcEventT0_6SRF
float m_cdcEventT0_6SRF
CDC event T0 in the 6-sample SVD ref frame.
Definition: SVDPerformanceTTreeModule.h:61
Belle2::SVDPerformanceTTreeModule::m_recoTracksStoreArrayName
std::string m_recoTracksStoreArrayName
storeArray name of the input and output RecoTracks
Definition: SVDPerformanceTTreeModule.h:55
Belle2::SVDPerformanceTTreeModule::m_rootFilePtr
TFile * m_rootFilePtr
pointer at root file used for storing histograms
Definition: SVDPerformanceTTreeModule.h:53
Belle2::SVDPerformanceTTreeModule::m_svdClTime_3SRF
float m_svdClTime_3SRF
cluster time in the 3-sample SVD ref frame
Definition: SVDPerformanceTTreeModule.h:71
Belle2::SVDPerformanceTTreeModule::m_svdTrkSVDHits
int m_svdTrkSVDHits
number of SVD hits on the track
Definition: SVDPerformanceTTreeModule.h:87
Belle2::SVDShaperDigit
The SVD ShaperDigit class.
Definition: SVDShaperDigit.h:32
Belle2::SVDShaperDigit::getSamples
APVFloatSamples getSamples() const
Get array of samples.
Definition: SVDShaperDigit.h:119
Belle2::StoreAccessorBase::isOptional
bool isOptional(const std::string &name="")
Tell the DataStore about an optional input.
Definition: StoreAccessorBase.h:93
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::StoreObjPtr::isValid
bool isValid() const
Check whether the object was created.
Definition: StoreObjPtr.h:111
Belle2::TrackFitResult
Values of the result of a track fit with a given particle hypothesis.
Definition: TrackFitResult.h:49
Belle2::TrackFitResult::get4Momentum
ROOT::Math::PxPyPzEVector get4Momentum() const
Getter for the 4Momentum at the closest approach of the track in the r/phi projection.
Definition: TrackFitResult.h:125
Belle2::TrackFitResult::getD0
double getD0() const
Getter for d0.
Definition: TrackFitResult.h:179
Belle2::TrackFitResult::getZ0
double getZ0() const
Getter for z0.
Definition: TrackFitResult.h:201
Belle2::TrackFitResult::getMomentum
ROOT::Math::XYZVector getMomentum() const
Getter for vector of momentum at closest approach of track in r/phi projection.
Definition: TrackFitResult.h:116
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::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:214
Belle2::VXD::GeoCache::get
static const SensorInfoBase & get(Belle2::VxdID id)
Return a reference to the SensorInfo of a given SensorID.
Definition: GeoCache.h:139
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:29
Belle2::VXD::SensorInfoBase::getVCellPosition
double getVCellPosition(int vID) const
Return the position of a specific strip/pixel in v direction.
Definition: SensorInfoBase.h:180
Belle2::VXD::SensorInfoBase::getUPitch
double getUPitch(double v=0) const
Return the pitch of the sensor.
Definition: SensorInfoBase.h:132
Belle2::VXD::SensorInfoBase::getVSize
double getVSize() const
Return the length of the sensor.
Definition: SensorInfoBase.h:121
Belle2::VXD::SensorInfoBase::getUCellPosition
double getUCellPosition(int uID, int vID=-1) const
Return the position of a specific strip/pixel in u direction.
Definition: SensorInfoBase.h:168
Belle2::VXD::SensorInfoBase::pointToGlobal
ROOT::Math::XYZVector pointToGlobal(const ROOT::Math::XYZVector &local, bool reco=false) const
Convert a point from local to global coordinates.
Definition: SensorInfoBase.h:364
Belle2::VXD::SensorInfoBase::getVPitch
double getVPitch(double v=0) const
Return the pitch of the sensor.
Definition: SensorInfoBase.h:139
Belle2::VXD::SensorInfoBase::getThickness
double getThickness() const
Return the thickness of the sensor.
Definition: SensorInfoBase.h:110
Belle2::VXD::SensorInfoBase::getUSize
double getUSize(double v=0) const
Return the width of the sensor.
Definition: SensorInfoBase.h:116
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::getLadderNumber
baseType getLadderNumber() const
Get the ladder id.
Definition: VxdID.h:98
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:96
genfit::MeasuredStateOnPlane
#StateOnPlane with additional covariance matrix.
Definition: MeasuredStateOnPlane.h:39
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::Unit::convertValueToUnit
static double convertValueToUnit(double value, const std::string &unitString)
Converts a floating point value from the standard framework unit to the given unit.
Definition: UnitConst.cc:139
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17