ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Private Types | Private Attributes | List of all members
DerivationFramework::PixelNtupleMaker Class Reference

#include <PixelNtupleMaker.h>

Inheritance diagram for DerivationFramework::PixelNtupleMaker:
Collaboration diagram for DerivationFramework::PixelNtupleMaker:

Public Member Functions

virtual StatusCode initialize () override final
virtual StatusCode addBranches (const EventContext &ctx) const override final

Static Public Member Functions

static void GetLayerEtaPhiFromId (uint64_t id, int *barrelEC, int *layer, int *eta, int *phi)

Private Types

typedef std::vector< ElementLink< xAOD::TrackStateValidationContainer > > MeasurementsOnTrack
typedef std::vector< ElementLink< xAOD::TrackStateValidationContainer > >::const_iterator MeasurementsOnTrackIter

Private Attributes

Gaudi::Property< int > m_storeMode {this, "StoreMode", 1, "Storing mode: 1:full, 2:small, 3:Z->tautau"}
ToolHandle< InDet::IInDetTrackSelectionTool > m_selector {this, "TrackSelectionTool",""}
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_containerKey { this, "ContainerName", "InDetTrackParticles", "" }
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_measurementContainerKey { this, "MeasurementValidationKey","PixelClusters", ""}
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_monitoringTracks { this, "PixelMonitoringTracksKey", "PixelMonitoringTrack","" }

Detailed Description

Definition at line 29 of file PixelNtupleMaker.h.

Member Typedef Documentation

◆ MeasurementsOnTrack

typedef std::vector<ElementLink< xAOD::TrackStateValidationContainer > > DerivationFramework::PixelNtupleMaker::MeasurementsOnTrack
private

Definition at line 53 of file PixelNtupleMaker.h.

◆ MeasurementsOnTrackIter

typedef std::vector<ElementLink<xAOD::TrackStateValidationContainer>>::const_iterator DerivationFramework::PixelNtupleMaker::MeasurementsOnTrackIter
private

Definition at line 54 of file PixelNtupleMaker.h.

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::PixelNtupleMaker::addBranches ( const EventContext & ctx) const
finaloverridevirtual

Definition at line 28 of file PixelNtupleMaker.cxx.

28 {
29
30 SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_containerKey,ctx);
31 if (!tracks.isValid()) { return StatusCode::SUCCESS; }
32
33 // Check the event contains tracks
34 SG::WriteHandle<xAOD::TrackParticleContainer> PixelMonitoringTrack(m_monitoringTracks,ctx);
35 if (PixelMonitoringTrack.record(std::make_unique<xAOD::TrackParticleContainer>(),
36 std::make_unique<xAOD::TrackParticleAuxContainer>()).isFailure()) {
37 return StatusCode::SUCCESS;
38 }
39
40 SG::ReadHandle<xAOD::TrackMeasurementValidationContainer> pixClusters(m_measurementContainerKey,ctx);
41 if (!pixClusters.isValid()) { return StatusCode::SUCCESS; }
42
43 // monitoring variables.
44 const int nbin_charge = 60;
45 const int nbin_tot = 120;
46 const int nbin_eta = 30;
47 const int nbin_dedx = 300;
48 const int nbin_size = 10;
49 const int nbin_reso = 80;
50 const int nbin_occ = 80;
51
52 std::vector<std::vector<int>> clusCharge(11,std::vector<int>(nbin_charge,0));
53 std::vector<std::vector<int>> clusToT(11,std::vector<int>(nbin_tot,0));
54 std::vector<std::vector<int>> clusEta(11,std::vector<int>(nbin_eta,0));
55 std::vector<std::vector<int>> clusHitEta(11,std::vector<int>(nbin_eta,0));
56 std::vector<std::vector<int>> clusdEdx(11,std::vector<int>(nbin_dedx,0));
57 std::vector<std::vector<int>> clusSizeX(11,std::vector<int>(nbin_size,0));
58 std::vector<std::vector<int>> clusSizeZ(11,std::vector<int>(nbin_size,0));
59 std::vector<std::vector<int>> clusResidualX(11,std::vector<int>(nbin_reso,0));
60 std::vector<std::vector<int>> clusResidualY(11,std::vector<int>(nbin_reso,0));
61 std::vector<std::vector<int>> clusHole(11,std::vector<int>(nbin_eta,0));
62 std::vector<std::vector<int>> clusOcc(11,std::vector<int>(nbin_occ,0));
63
64 std::vector<int> trkEta(nbin_eta,0);
65 std::vector<int> trkHole(nbin_eta,0);
66 std::vector<int> trkdEdx(nbin_dedx,0);
67
68 float maxPt = 0.0;
69 const xAOD::TrackParticle* trk_maxpt = nullptr;
70
71 std::vector<float> tmpCov(15,0.);
72
73 // StoreGateSvc+InDetTrackParticles.msosLink
74 static const SG::ConstAccessor<MeasurementsOnTrack> acc_MeasurementsOnTrack("msosLink");
75
76 for (const xAOD::TrackParticle* trk : *tracks) {
77 uint8_t nPixHits = 0; trk->summaryValue(nPixHits,xAOD::numberOfPixelHits);
78 uint8_t nSCTHits = 0; trk->summaryValue(nSCTHits,xAOD::numberOfSCTHits);
79 if (trk->pt()<1000.0 && nPixHits<4) { continue; }
80 if (trk->pt()<1000.0 && nSCTHits<1) { continue; }
81
82 std::vector<uint64_t> holeIndex;
83 std::vector<int> clusterLayer;
84 std::vector<int> clusterBEC;
85 std::vector<int> clusterModulePhi;
86 std::vector<int> clusterModuleEta;
87 std::vector<float> clusterCharge;
88 std::vector<int> clusterToT;
89 std::vector<int> clusterL1A;
90 std::vector<int> clusterIsSplit;
91 std::vector<int> clusterSize;
92 std::vector<int> clusterSizePhi;
93 std::vector<int> clusterSizeZ;
94 std::vector<bool> isEdge;
95 std::vector<bool> isOverflow;
96 std::vector<float> trackPhi;
97 std::vector<float> trackTheta;
98 std::vector<float> trackX;
99 std::vector<float> trackY;
100 std::vector<float> localX;
101 std::vector<float> localY;
102 std::vector<float> globalX;
103 std::vector<float> globalY;
104 std::vector<float> globalZ;
105 std::vector<float> unbiasedResidualX;
106 std::vector<float> unbiasedResidualY;
107 std::vector<int> clusterIsolation10x2;
108 std::vector<int> clusterIsolation20x4;
109 std::vector<int> numTotalClustersPerModule;
110 std::vector<int> numTotalPixelsPerModule;
111 std::vector<float> moduleLorentzShift;
112
113 std::vector<std::vector<int>> rdoToT;
114 std::vector<std::vector<float>> rdoCharge;
115 std::vector<std::vector<int>> rdoPhi;
116 std::vector<std::vector<int>> rdoEta;
117
118 const MeasurementsOnTrack& measurementsOnTrack = acc_MeasurementsOnTrack(*trk);
119 for (const auto & msos_iter : measurementsOnTrack) {
120 if (!msos_iter.isValid()) { continue; }
121 const xAOD::TrackStateValidation* msos = *msos_iter;
122 if (msos->detType()!=Trk::TrackState::Pixel) { continue; } // its a pixel
123 if (msos->type()==Trk::TrackStateOnSurface::Hole) { // hole
124 holeIndex.push_back(msos->detElementId());
125 continue;
126 }
127 if (!msos->trackMeasurementValidationLink().isValid()) { continue; }
128 if (!(*(msos->trackMeasurementValidationLink()))) { continue; }
129
130 const xAOD::TrackMeasurementValidation* msosClus = *(msos->trackMeasurementValidationLink());
131
132 static const SG::ConstAccessor<float> chargeAcc("charge");
133 static const SG::ConstAccessor<int> layerAcc("layer");
134 static const SG::ConstAccessor<int> becAcc("bec");
135 static const SG::ConstAccessor<int> phi_moduleAcc("phi_module");
136 static const SG::ConstAccessor<int> eta_moduleAcc("eta_module");
137 static const SG::ConstAccessor<int> ToTAcc("ToT");
138 static const SG::ConstAccessor<int> LVL1AAcc("LVL1A");
139 static const SG::ConstAccessor<char> isSplitAcc("isSplit");
140 static const SG::ConstAccessor<int> nRDOAcc("nRDO");
141 static const SG::ConstAccessor<int> sizePhiAcc("sizePhi");
142 static const SG::ConstAccessor<int> sizeZAcc("sizeZ");
143 static const SG::ConstAccessor<float> LorentzShiftAcc("LorentzShift");
144 static const SG::ConstAccessor<std::vector<int> > rdo_totAcc("rdo_tot");
145 static const SG::ConstAccessor<std::vector<float> > rdo_chargeAcc("rdo_charge");
146
147 for (const auto *clus_itr : *pixClusters) {
148 if (clus_itr->identifier()!=(msosClus)->identifier()) { continue; }
149 if (chargeAcc(*clus_itr)!=chargeAcc(*msosClus)) { continue; }
150
151 clusterLayer.push_back(layerAcc(*clus_itr));
152 clusterBEC.push_back(becAcc(*clus_itr));
153 clusterModulePhi.push_back(phi_moduleAcc(*clus_itr));
154 clusterModuleEta.push_back(eta_moduleAcc(*clus_itr));
155 clusterCharge.push_back(chargeAcc(*clus_itr));
156 clusterToT.push_back(ToTAcc(*clus_itr));
157 clusterL1A.push_back(LVL1AAcc(*clus_itr));
158 clusterIsSplit.push_back(isSplitAcc(*clus_itr));
159 clusterSize.push_back(nRDOAcc(*clus_itr));
160 clusterSizePhi.push_back(sizePhiAcc(*clus_itr));
161 clusterSizeZ.push_back(sizeZAcc(*clus_itr));
162
163 trackPhi.push_back(msos->localPhi());
164 trackTheta.push_back(msos->localTheta());
165 trackX.push_back(msos->localX());
166 trackY.push_back(msos->localY());
167 localX.push_back(clus_itr->localX());
168 localY.push_back(clus_itr->localY());
169 globalX.push_back(clus_itr->globalX());
170 globalY.push_back(clus_itr->globalY());
171 globalZ.push_back(clus_itr->globalZ());
172 unbiasedResidualX.push_back(msos->unbiasedResidualX());
173 unbiasedResidualY.push_back(msos->unbiasedResidualY());
174 moduleLorentzShift.push_back(LorentzShiftAcc(*clus_itr));
175
176 // cluster isolation IBL:50x250um, PIXEL:50x400um
177 // - isolation region 10x2 = 500x500um for IBL, 500x800um for PIXEL
178 int numNeighborCluster10x2 = 0;
179 int numNeighborCluster20x4 = 0;
180 int nTotalClustersPerModule = 0;
181 int nTotalPixelsPerModule = 0;
182 for (const auto *clus_neighbor : *pixClusters) {
183 if (layerAcc(*clus_neighbor)==layerAcc(*clus_itr)
184 && becAcc(*clus_neighbor)==becAcc(*clus_itr)
185 && phi_moduleAcc(*clus_neighbor)==phi_moduleAcc(*clus_itr)
186 && eta_moduleAcc(*clus_neighbor)==eta_moduleAcc(*clus_itr)) {
187 float deltaX = std::abs(clus_neighbor->localX()-clus_itr->localX());
188 float deltaY = std::abs(clus_neighbor->localY()-clus_itr->localY());
189 nTotalClustersPerModule++;
190 nTotalPixelsPerModule += nRDOAcc(*clus_neighbor);
191 if (deltaX>0.0 && deltaY>0.0) {
192 if (layerAcc(*clus_itr)==0 && becAcc(*clus_itr)==0) { // IBL
193 if (deltaX<0.500 && deltaY<0.500) { numNeighborCluster10x2++; }
194 if (deltaX<1.000 && deltaY<1.000) { numNeighborCluster20x4++; }
195 }
196 else {
197 if (deltaX<0.500 && deltaY<0.800) { numNeighborCluster10x2++; }
198 if (deltaX<1.000 && deltaY<1.600) { numNeighborCluster20x4++; }
199 }
200 }
201 }
202 }
203 clusterIsolation10x2.push_back(numNeighborCluster10x2);
204 clusterIsolation20x4.push_back(numNeighborCluster20x4);
205 numTotalClustersPerModule.push_back(nTotalClustersPerModule);
206 numTotalPixelsPerModule.push_back(nTotalPixelsPerModule);
207
208 // is edge pixel?
209 // contain overlflow hit?
210 bool checkEdge = false;
211 bool checkOverflow = false;
212
213 // rdo information
214 std::vector<int> tmpToT;
215 std::vector<float> tmpCharge;
216 std::vector<int> tmpPhi;
217 std::vector<int> tmpEta;
218
219 static const SG::ConstAccessor<std::vector<int> > rdo_phi_pixel_indexAcc("rdo_phi_pixel_index");
220 int nrdo = rdo_phi_pixel_indexAcc.isAvailable(*clus_itr) ? rdo_phi_pixel_indexAcc(*clus_itr).size() : -1;
221 for (int i=0; i<nrdo; i++) {
222
223 int phi = rdo_phi_pixel_indexAcc(*clus_itr)[i];
224 if (phi<5) { checkEdge=true; }
225 if (phi>320) { checkEdge=true; }
226
227 int eta = rdo_phi_pixel_indexAcc(*clus_itr)[i];
228 if (layerAcc(*clus_itr)==0 && becAcc(*clus_itr)==0) { // IBL
229 if (eta_moduleAcc(*clus_itr)>-7 && eta_moduleAcc(*clus_itr)<6) { // IBL Planar
230 if (eta<5) { checkEdge=true; }
231 if (eta>154) { checkEdge=true; }
232 }
233 else { // IBL 3D
234 if (eta<5) { checkEdge=true; }
235 if (eta>74) { checkEdge=true; }
236 }
237 }
238 else {
239 if (eta<5) { checkEdge=true; }
240 if (eta>154) { checkEdge=true; }
241 }
242
243 int tot = rdo_totAcc(*clus_itr)[i];
244 if (layerAcc(*clus_itr)==0 && becAcc(*clus_itr)==0) { // IBL
245 if (tot==16) { checkOverflow=true; }
246 }
247 else if (layerAcc(*clus_itr)==1 && becAcc(*clus_itr)==0) { // b-layer
248 if (tot==150) { checkOverflow=true; }
249 }
250 else {
251 if (tot==255) { checkOverflow=true; }
252 }
253
254 float charge = rdo_chargeAcc(*clus_itr)[i];
255 if (trk->pt()>2000.0) {
256 tmpToT.push_back(tot);
257 tmpCharge.push_back(charge);
258 tmpPhi.push_back(phi);
259 tmpEta.push_back(eta);
260 }
261 }
262 isEdge.push_back(checkEdge);
263 isOverflow.push_back(checkOverflow);
264
265 rdoToT.push_back(std::move(tmpToT));
266 rdoCharge.push_back(std::move(tmpCharge));
267 rdoPhi.push_back(std::move(tmpPhi));
268 rdoEta.push_back(std::move(tmpEta));
269 break;
270 }
271 }
272 const std::size_t nHole = holeIndex.size(); //extract this before moving it
273 const std::size_t nClusterLayer = clusterLayer.size();
274 if (m_storeMode==1) {
275 static const SG::Decorator<float> d0err("d0err");
276 static const SG::Decorator<float> z0err("z0err");
277 static const SG::Decorator<std::vector<uint64_t>> HoleIndex("HoleIndex");
278 static const SG::Decorator<std::vector<int>> ClusterLayer("ClusterLayer");
279 static const SG::Decorator<std::vector<int>> ClusterBEC("ClusterBEC");
280 static const SG::Decorator<std::vector<int>> ClusterModulePhi("ClusterModulePhi");
281 static const SG::Decorator<std::vector<int>> ClusterModuleEta("ClusterModuleEta");
282 static const SG::Decorator<std::vector<float>> ClusterCharge("ClusterCharge");
283 static const SG::Decorator<std::vector<int>> ClusterToT("ClusterToT");
284 static const SG::Decorator<std::vector<int>> ClusterL1A("ClusterL1A");
285 static const SG::Decorator<std::vector<int>> ClusterIsSplit("ClusterIsSplit");
286 static const SG::Decorator<std::vector<int>> ClusterSize("ClusterSize");
287 static const SG::Decorator<std::vector<int>> ClusterSizePhi("ClusterSizePhi");
288 static const SG::Decorator<std::vector<int>> ClusterSizeZ("ClusterSizeZ");
289 static const SG::Decorator<std::vector<bool>> ClusterIsEdge("ClusterIsEdge");
290 static const SG::Decorator<std::vector<bool>> ClusterIsOverflow("ClusterIsOverflow");
291 static const SG::Decorator<std::vector<float>> TrackLocalPhi("TrackLocalPhi");
292 static const SG::Decorator<std::vector<float>> TrackLocalTheta("TrackLocalTheta");
293 static const SG::Decorator<std::vector<float>> TrackLocalX("TrackLocalX");
294 static const SG::Decorator<std::vector<float>> TrackLocalY("TrackLocalY");
295 static const SG::Decorator<std::vector<float>> ClusterLocalX("ClusterLocalX");
296 static const SG::Decorator<std::vector<float>> ClusterLocalY("ClusterLocalY");
297 static const SG::Decorator<std::vector<float>> ClusterGlobalX("ClusterGlobalX");
298 static const SG::Decorator<std::vector<float>> ClusterGlobalY("ClusterGlobalY");
299 static const SG::Decorator<std::vector<float>> ClusterGlobalZ("ClusterGlobalZ");
300 static const SG::Decorator<std::vector<float>> UnbiasedResidualX("UnbiasedResidualX");
301 static const SG::Decorator<std::vector<float>> UnbiasedResidualY("UnbiasedResidualY");
302 static const SG::Decorator<std::vector<int>> ClusterIsolation10x2("ClusterIsolation10x2");
303 static const SG::Decorator<std::vector<int>> ClusterIsolation20x4("ClusterIsolation20x4");
304 static const SG::Decorator<std::vector<int>> NumTotalClustersPerModule("NumTotalClustersPerModule");
305 static const SG::Decorator<std::vector<int>> NumTotalPixelsPerModule("NumTotalPixelsPerModule");
306 static const SG::Decorator<std::vector<float>> ModuleLorentzShift("ModuleLorentzShift");
307 static const SG::Decorator<std::vector<std::vector<int>>> RdoToT("RdoToT");
308 static const SG::Decorator<std::vector<std::vector<float>>> RdoCharge("RdoCharge");
309 static const SG::Decorator<std::vector<std::vector<int>>> RdoPhi("RdoPhi");
310 static const SG::Decorator<std::vector<std::vector<int>>> RdoEta("RdoEta");
311
312 d0err(*trk) = trk->definingParametersCovMatrixVec().at(0);
313 z0err(*trk) = trk->definingParametersCovMatrixVec().at(2);
314 //holeIndex moved here
315 HoleIndex(*trk) = std::move(holeIndex);
316 ClusterLayer(*trk) = std::move(clusterLayer);
317 ClusterBEC(*trk) = std::move(clusterBEC);
318 ClusterModulePhi(*trk) = std::move(clusterModulePhi);
319 ClusterModuleEta(*trk) = std::move(clusterModuleEta);
320 ClusterCharge(*trk) = std::move(clusterCharge);
321 ClusterToT(*trk) = std::move(clusterToT);
322 ClusterL1A(*trk) = std::move(clusterL1A);
323 ClusterIsSplit(*trk) = std::move(clusterIsSplit);
324 ClusterSize(*trk) = std::move(clusterSize);
325 ClusterSizePhi(*trk) = std::move(clusterSizePhi);
326 ClusterSizeZ(*trk) = std::move(clusterSizeZ);
327 ClusterIsEdge(*trk) = std::move(isEdge);
328 ClusterIsOverflow(*trk) = std::move(isOverflow);
329 TrackLocalPhi(*trk) = std::move(trackPhi);
330 TrackLocalTheta(*trk) = std::move(trackTheta);
331 TrackLocalX(*trk) = std::move(trackX);
332 TrackLocalY(*trk) = std::move(trackY);
333 ClusterLocalX(*trk) = std::move(localX);
334 ClusterLocalY(*trk) = std::move(localY);
335 ClusterGlobalX(*trk) = std::move(globalX);
336 ClusterGlobalY(*trk) = std::move(globalY);
337 ClusterGlobalZ(*trk) = std::move(globalZ);
338 UnbiasedResidualX(*trk) = std::move(unbiasedResidualX);
339 UnbiasedResidualY(*trk) = std::move(unbiasedResidualY);
340 ClusterIsolation10x2(*trk) = std::move(clusterIsolation10x2);
341 ClusterIsolation20x4(*trk) = std::move(clusterIsolation20x4);
342 NumTotalClustersPerModule(*trk) = std::move(numTotalClustersPerModule);
343 NumTotalPixelsPerModule(*trk) = std::move(numTotalPixelsPerModule);
344 ModuleLorentzShift(*trk) = std::move(moduleLorentzShift);
345 RdoToT(*trk) = std::move(rdoToT);
346 RdoCharge(*trk) = std::move(rdoCharge);
347 RdoPhi(*trk) = std::move(rdoPhi);
348 RdoEta(*trk) = std::move(rdoEta);
349 }
350
351 // further track selection for slimmed track variables
352 uint8_t nPixelDeadSensor = 0; trk->summaryValue(nPixelDeadSensor,xAOD::numberOfPixelDeadSensors);
353 uint8_t numberOfPixelHits= 0; trk->summaryValue(numberOfPixelHits,xAOD::numberOfPixelHits);
354 uint8_t numberOfPixelHoles= 0; trk->summaryValue(numberOfPixelHoles,xAOD::numberOfPixelHoles);
355 uint8_t numberOfPixelOutliers= 0; trk->summaryValue(numberOfPixelOutliers,xAOD::numberOfPixelOutliers);
356 uint8_t nSCTHoles = 0; trk->summaryValue(nSCTHoles,xAOD::numberOfSCTHoles);
357 uint8_t nPixSharedHits = 0; trk->summaryValue(nPixSharedHits,xAOD::numberOfPixelSharedHits);
358 uint8_t nSCTSharedHits = 0; trk->summaryValue(nSCTSharedHits,xAOD::numberOfSCTSharedHits);
359
360 // loose track selection
361 bool passLooseCut = static_cast<bool>(m_selector->accept(trk));
362 if (!passLooseCut) { continue; }
363
364 //==================
365 // Efficiency check
366 //==================
367 int checkIBL(0),check3D(0),checkBLY(0),checkLY1(0),checkLY2(0),checkEA1(0),checkEA2(0),checkEA3(0),checkEC1(0),checkEC2(0),checkEC3(0);
368 for (std::size_t i=0; i<nClusterLayer; i++) {
369 if (clusterBEC.at(i)== 0 && clusterLayer.at(i)==0) {
370 if (clusterModuleEta.at(i)>-7 && clusterModuleEta.at(i)<6) { checkIBL++; }
371 else { check3D++; }
372 }
373 else if (clusterBEC.at(i)== 0 && clusterLayer.at(i)==1) { checkBLY++; }
374 else if (clusterBEC.at(i)== 0 && clusterLayer.at(i)==2) { checkLY1++; }
375 else if (clusterBEC.at(i)== 0 && clusterLayer.at(i)==3) { checkLY2++; }
376 else if (clusterBEC.at(i)== 2 && clusterLayer.at(i)==0) { checkEA1++; }
377 else if (clusterBEC.at(i)== 2 && clusterLayer.at(i)==1) { checkEA2++; }
378 else if (clusterBEC.at(i)== 2 && clusterLayer.at(i)==2) { checkEA3++; }
379 else if (clusterBEC.at(i)==-2 && clusterLayer.at(i)==0) { checkEC1++; }
380 else if (clusterBEC.at(i)==-2 && clusterLayer.at(i)==1) { checkEC2++; }
381 else if (clusterBEC.at(i)==-2 && clusterLayer.at(i)==2) { checkEC3++; }
382 }
383
384 if (trk->pt()>2000.0 && nPixelDeadSensor==0) {
385 int ietabin = trunc((trk->eta()+3.0)/0.2);
386
387 std::for_each((trkEta.begin()+ietabin),(trkEta.begin()+ietabin+1),[](int &n){ n++; });
388 if (numberOfPixelHoles>0) { std::for_each((trkHole.begin()+ietabin),(trkHole.begin()+ietabin+1),[](int &n){ n++; }); }
389
390 if (checkBLY>0 && checkLY1>0 && checkLY2>0) { std::for_each((clusEta[0].begin()+ietabin),(clusEta[0].begin()+ietabin+1),[](int &n){ n++; }); if (checkIBL>0) { std::for_each((clusHitEta[0].begin()+ietabin),(clusHitEta[0].begin()+ietabin+1),[](int &n){ n++; }); }}
391 if (checkBLY>0 && checkEC2>0 && checkEC3>0) { std::for_each((clusEta[1].begin()+ietabin),(clusEta[1].begin()+ietabin+1),[](int &n){ n++; }); if (check3D>0) { std::for_each((clusHitEta[1].begin()+ietabin),(clusHitEta[1].begin()+ietabin+1),[](int &n){ n++; }); }}
392 if (checkIBL>0 && checkLY1>0 && checkLY2>0) { std::for_each((clusEta[2].begin()+ietabin),(clusEta[2].begin()+ietabin+1),[](int &n){ n++; }); if (checkBLY>0) { std::for_each((clusHitEta[2].begin()+ietabin),(clusHitEta[2].begin()+ietabin+1),[](int &n){ n++; }); }}
393 if (checkIBL>0 && checkBLY>0 && checkLY2>0) { std::for_each((clusEta[3].begin()+ietabin),(clusEta[3].begin()+ietabin+1),[](int &n){ n++; }); if (checkLY1>0) { std::for_each((clusHitEta[3].begin()+ietabin),(clusHitEta[3].begin()+ietabin+1),[](int &n){ n++; }); }}
394 if (checkIBL>0 && checkBLY>0 && checkLY1>0) { std::for_each((clusEta[4].begin()+ietabin),(clusEta[4].begin()+ietabin+1),[](int &n){ n++; }); if (checkLY2>0) { std::for_each((clusHitEta[4].begin()+ietabin),(clusHitEta[4].begin()+ietabin+1),[](int &n){ n++; }); }}
395 if (checkIBL>0 && checkEA2>0 && checkEA3>0) { std::for_each((clusEta[5].begin()+ietabin),(clusEta[5].begin()+ietabin+1),[](int &n){ n++; }); if (checkEA1>0) { std::for_each((clusHitEta[5].begin()+ietabin),(clusHitEta[5].begin()+ietabin+1),[](int &n){ n++; }); }}
396 if (checkIBL>0 && checkEA1>0 && checkEA3>0) { std::for_each((clusEta[6].begin()+ietabin),(clusEta[6].begin()+ietabin+1),[](int &n){ n++; }); if (checkEA2>0) { std::for_each((clusHitEta[6].begin()+ietabin),(clusHitEta[6].begin()+ietabin+1),[](int &n){ n++; }); }}
397 if (checkIBL>0 && checkEA1>0 && checkEA2>0) { std::for_each((clusEta[7].begin()+ietabin),(clusEta[7].begin()+ietabin+1),[](int &n){ n++; }); if (checkEA3>0) { std::for_each((clusHitEta[7].begin()+ietabin),(clusHitEta[7].begin()+ietabin+1),[](int &n){ n++; }); }}
398 if (checkIBL>0 && checkEC2>0 && checkEC3>0) { std::for_each((clusEta[8].begin()+ietabin),(clusEta[8].begin()+ietabin+1),[](int &n){ n++; }); if (checkEC1>0) { std::for_each((clusHitEta[8].begin()+ietabin),(clusHitEta[8].begin()+ietabin+1),[](int &n){ n++; }); }}
399 if (checkIBL>0 && checkEC1>0 && checkEC3>0) { std::for_each((clusEta[9].begin()+ietabin),(clusEta[9].begin()+ietabin+1),[](int &n){ n++; }); if (checkEC2>0) { std::for_each((clusHitEta[9].begin()+ietabin),(clusHitEta[9].begin()+ietabin+1),[](int &n){ n++; }); }}
400 if (checkIBL>0 && checkEC1>0 && checkEC2>0) { std::for_each((clusEta[10].begin()+ietabin),(clusEta[10].begin()+ietabin+1),[](int &n){ n++; }); if (checkEC3>0) { std::for_each((clusHitEta[10].begin()+ietabin),(clusHitEta[10].begin()+ietabin+1),[](int &n){ n++; }); }}
401
402 for (std::size_t i=0; i!=nHole; i++) {
403 int becH, layerH, etaH, phiH;
404 GetLayerEtaPhiFromId(holeIndex.at(i),&becH,&layerH,&etaH,&phiH);
405 if (becH== 0 && layerH==0) {
406 if (etaH>-7 && etaH<6) { std::for_each((clusHole[0].begin()+ietabin),(clusHole[0].begin()+ietabin+1),[](int &n){ n++; }); }
407 else { std::for_each((clusHole[1].begin()+ietabin),(clusHole[1].begin()+ietabin+1),[](int &n){ n++; }); }
408 }
409 if (becH== 0 && layerH==1) { std::for_each((clusHole[2].begin()+ietabin),(clusHole[2].begin()+ietabin+1),[](int &n){ n++; }); }
410 if (becH== 0 && layerH==2) { std::for_each((clusHole[3].begin()+ietabin),(clusHole[3].begin()+ietabin+1),[](int &n){ n++; }); }
411 if (becH== 0 && layerH==3) { std::for_each((clusHole[4].begin()+ietabin),(clusHole[4].begin()+ietabin+1),[](int &n){ n++; }); }
412 if (becH== 2 && layerH==0) { std::for_each((clusHole[5].begin()+ietabin),(clusHole[5].begin()+ietabin+1),[](int &n){ n++; }); }
413 if (becH== 2 && layerH==1) { std::for_each((clusHole[6].begin()+ietabin),(clusHole[6].begin()+ietabin+1),[](int &n){ n++; }); }
414 if (becH== 2 && layerH==2) { std::for_each((clusHole[7].begin()+ietabin),(clusHole[7].begin()+ietabin+1),[](int &n){ n++; }); }
415 if (becH==-2 && layerH==0) { std::for_each((clusHole[8].begin()+ietabin),(clusHole[8].begin()+ietabin+1),[](int &n){ n++; }); }
416 if (becH==-2 && layerH==1) { std::for_each((clusHole[9].begin()+ietabin),(clusHole[9].begin()+ietabin+1),[](int &n){ n++; }); }
417 if (becH==-2 && layerH==2) { std::for_each((clusHole[10].begin()+ietabin),(clusHole[10].begin()+ietabin+1),[](int &n){ n++; }); }
418 }
419 }
420
421 // Cluster should not contain edge pixels
422 int clusterEdge = 0;
423 for (std::size_t i=0; i<nClusterLayer; i++) { clusterEdge+=isEdge.at(i); }
424
425 // Cluster should not contain overflow pixels
426 int clusterOverflow = 0;
427 for (std::size_t i=0; i<nClusterLayer; i++) { clusterOverflow+=isOverflow.at(i); }
428
429 // Cluster should not contain split state
430 int isSplit = 0;
431 for (std::size_t i=0; i<nClusterLayer; i++) { isSplit+=clusterIsSplit.at(i); }
432
433 // Strong isolation
434 int iso20x4 = 0;
435 for (std::size_t i=0; i<nClusterLayer; i++) { iso20x4+=clusterIsolation20x4.at(i); }
436
437 // Good tracks must be required for the dE/dx and Lorentz angle measurements
438 bool passCut = false;
439 if (numberOfPixelHits>3 && numberOfPixelHoles==0 && nPixelDeadSensor==0 && numberOfPixelOutliers==0 && clusterEdge==0 && clusterOverflow==0 && isSplit==0 && iso20x4==0) {
440 if (checkIBL>0 && checkBLY>0 && checkLY1>0 && checkLY2>0) { // Barrel
441 passCut = true;
442 }
443 else if (checkIBL>0 && checkEA1>0 && checkEA2>0 && checkEA3>0) { // Endcap
444 passCut = true;
445 }
446 else if (checkIBL>0 && checkEC1>0 && checkEC2>0 && checkEC3>0) { // Endcap
447 passCut = true;
448 }
449 else if (check3D>0 && checkEC2>0 && checkEC3>0) { // 3D
450 passCut = true;
451 }
452 }
453 if (!passCut) { continue; }
454
455 // Cut on angle alpha
456 bool isAlphaCut = false;
457 for (std::size_t i=0; i<nClusterLayer; i++) {
458 float alpha = std::atan(std::hypot(std::tan(trackTheta[i]),std::tan(trackPhi[i])));
459 if (std::cos(alpha)<0.16) { isAlphaCut=true; break; }
460 }
461 if (isAlphaCut) { continue; }
462
463 if (trk->pt()>maxPt) {
464 maxPt = trk->pt();
465 trk_maxpt = trk;
466 }
467
468 // Cluster study
469 float energyPair = 3.62e-6; // Electron-hole pair creation energy e-h/[MeV]
470 float siDensity = 2.329; // Silicon density [g/cm^3]
471 float thicknessIBL = 0.0200; // thickness for IBL planar [cm]
472 float thickness3D = 0.0230; // thickness for IBL 3D [cm]
473 float thicknessPIX = 0.0250; // thickness for PIXEL [cm]
474 float sumE = 0.0;
475 float sumX = 0.0;
476 for (std::size_t i=0; i<nClusterLayer; i++) {
477
478 float alpha = std::atan(std::hypot(std::tan(trackTheta[i]),std::tan(trackPhi[i])));
479 float thickness = thicknessPIX;
480 if (clusterBEC.at(i)==0 && clusterLayer.at(i)==0) {
481 thickness = (clusterModuleEta[i]<6 && clusterModuleEta[i]>-7) ? thicknessIBL : thickness3D;
482 }
483 float recodEdx = clusterCharge[i]*energyPair/thickness/siDensity*std::cos(alpha);
484 sumE += clusterCharge[i]*energyPair;
485 sumX += thickness*siDensity/std::cos(alpha);
486
487 int ibc = (clusterCharge[i]>0.0 && clusterCharge[i]<120000.0) ? trunc(clusterCharge[i]/2000.0) : nbin_charge-1;
488 int ibt = (clusterToT[i]>0 && clusterToT[i]<120) ? trunc(clusterToT[i]) : nbin_tot-1;
489 int ibe = (recodEdx>0.0 && recodEdx<3.0) ? trunc(recodEdx*100) : nbin_dedx-1;
490 int ibx = (clusterSizePhi[i]>-0.5 && clusterSizePhi[i]<9.5) ? trunc(clusterSizePhi[i]) : nbin_size-1;
491 int ibz = (clusterSizeZ[i]>-0.5 && clusterSizeZ[i]<9.5) ? trunc(clusterSizeZ[i]) : nbin_size-1;
492 int irx = (unbiasedResidualX[i]>-0.4 && unbiasedResidualX[i]<0.4) ? trunc((unbiasedResidualX[i]+0.4)/0.01) : nbin_reso-1;
493 int iry = (unbiasedResidualY[i]>-0.4 && unbiasedResidualY[i]<0.4) ? trunc((unbiasedResidualY[i]+0.4)/0.01) : nbin_reso-1;
494 int ibo = (numTotalPixelsPerModule[i]>-0.1 && numTotalPixelsPerModule[i]<160) ? trunc(numTotalPixelsPerModule[i]/2.0) : nbin_occ-1;
495
496 int idx = 0;
497 if (clusterBEC.at(i)==0 && clusterLayer.at(i)==0) {
498 if (clusterModuleEta[i]<6 && clusterModuleEta[i]>-7) { idx=0; } // IBL-planar
499 else { idx=1; } // 3D sensor
500 }
501 else if (clusterBEC.at(i)==0 && clusterLayer.at(i)==1) { idx=2; } // B-layer
502 else if (clusterBEC.at(i)==0 && clusterLayer.at(i)==2) { idx=3; } // Layer-1
503 else if (clusterBEC.at(i)==0 && clusterLayer.at(i)==3) { idx=4; } // Layer-2
504 else if (clusterBEC.at(i)==2 && clusterLayer.at(i)==0) { idx=5; } // Endcap-A1
505 else if (clusterBEC.at(i)==2 && clusterLayer.at(i)==1) { idx=6; } // Endcap-A2
506 else if (clusterBEC.at(i)==2 && clusterLayer.at(i)==2) { idx=7; } // Endcap-A3
507 else if (clusterBEC.at(i)==-2 && clusterLayer.at(i)==0) { idx=8; } // Endcap-C1
508 else if (clusterBEC.at(i)==-2 && clusterLayer.at(i)==1) { idx=9; } // Endcap-C2
509 else if (clusterBEC.at(i)==-2 && clusterLayer.at(i)==2) { idx=10; } // Endcap-C3
510
511 std::for_each((clusCharge[idx].begin()+ibc),(clusCharge[idx].begin()+ibc+1),[](int &n){ n++; });
512 std::for_each((clusToT[idx].begin()+ibt),(clusToT[idx].begin()+ibt+1),[](int &n){ n++; });
513 std::for_each((clusdEdx[idx].begin()+ibe),(clusdEdx[idx].begin()+ibe+1),[](int &n){ n++; });
514 std::for_each((clusSizeX[idx].begin()+ibx),(clusSizeX[idx].begin()+ibx+1),[](int &n){ n++; });
515 std::for_each((clusSizeZ[idx].begin()+ibz),(clusSizeZ[idx].begin()+ibz+1),[](int &n){ n++; });
516 std::for_each((clusResidualX[idx].begin()+irx),(clusResidualX[idx].begin()+irx+1),[](int &n){ n++; });
517 std::for_each((clusResidualY[idx].begin()+iry),(clusResidualY[idx].begin()+iry+1),[](int &n){ n++; });
518 std::for_each((clusOcc[idx].begin()+ibo),(clusOcc[idx].begin()+ibo+1),[](int &n){ n++; });
519 }
520
521 if (sumX>0.0) {
522 int iby = (sumE/sumX>0.0 && sumE/sumX<3.0) ? trunc(sumE/sumX*100) : 299;
523 std::for_each((trkdEdx.begin()+iby),(trkdEdx.begin()+iby+1),[](int &n){ n++; });
524 }
525 }
526
527 if (m_storeMode==2) {
528 if (maxPt>0.0) {
529 xAOD::TrackParticle* tp = new xAOD::TrackParticle();
530 tp->makePrivateStore(*trk_maxpt);
531 tp->setDefiningParametersCovMatrixVec(tmpCov);
532
533 static const SG::Decorator<std::vector<int>> TrackEtaIBL("TrackEtaIBL");
534 static const SG::Decorator<std::vector<int>> TrackEta3D("TrackEta3D");
535 static const SG::Decorator<std::vector<int>> TrackEtaBL("TrackEtaBL");
536 static const SG::Decorator<std::vector<int>> TrackEtaL1("TrackEtaL1");
537 static const SG::Decorator<std::vector<int>> TrackEtaL2("TrackEtaL2");
538 static const SG::Decorator<std::vector<int>> TrackEtaEA1("TrackEtaEA1");
539 static const SG::Decorator<std::vector<int>> TrackEtaEA2("TrackEtaEA2");
540 static const SG::Decorator<std::vector<int>> TrackEtaEA3("TrackEtaEA3");
541 static const SG::Decorator<std::vector<int>> TrackEtaEC1("TrackEtaEC1");
542 static const SG::Decorator<std::vector<int>> TrackEtaEC2("TrackEtaEC2");
543 static const SG::Decorator<std::vector<int>> TrackEtaEC3("TrackEtaEC3");
544 static const SG::Decorator<std::vector<int>> TrackHitEtaIBL("TrackHitEtaIBL");
545 static const SG::Decorator<std::vector<int>> TrackHitEta3D("TrackHitEta3D");
546 static const SG::Decorator<std::vector<int>> TrackHitEtaBL("TrackHitEtaBL");
547 static const SG::Decorator<std::vector<int>> TrackHitEtaL1("TrackHitEtaL1");
548 static const SG::Decorator<std::vector<int>> TrackHitEtaL2("TrackHitEtaL2");
549 static const SG::Decorator<std::vector<int>> TrackHitEtaEA1("TrackHitEtaEA1");
550 static const SG::Decorator<std::vector<int>> TrackHitEtaEA2("TrackHitEtaEA2");
551 static const SG::Decorator<std::vector<int>> TrackHitEtaEA3("TrackHitEtaEA3");
552 static const SG::Decorator<std::vector<int>> TrackHitEtaEC1("TrackHitEtaEC1");
553 static const SG::Decorator<std::vector<int>> TrackHitEtaEC2("TrackHitEtaEC2");
554 static const SG::Decorator<std::vector<int>> TrackHitEtaEC3("TrackHitEtaEC3");
555 static const SG::Decorator<std::vector<int>> ClusterChargeIBL("ClusterChargeIBL");
556 static const SG::Decorator<std::vector<int>> ClusterCharge3D("ClusterCharge3D");
557 static const SG::Decorator<std::vector<int>> ClusterChargeBL("ClusterChargeBL");
558 static const SG::Decorator<std::vector<int>> ClusterChargeL1("ClusterChargeL1");
559 static const SG::Decorator<std::vector<int>> ClusterChargeL2("ClusterChargeL2");
560 static const SG::Decorator<std::vector<int>> ClusterChargeEA1("ClusterChargeEA1");
561 static const SG::Decorator<std::vector<int>> ClusterChargeEA2("ClusterChargeEA2");
562 static const SG::Decorator<std::vector<int>> ClusterChargeEA3("ClusterChargeEA3");
563 static const SG::Decorator<std::vector<int>> ClusterChargeEC1("ClusterChargeEC1");
564 static const SG::Decorator<std::vector<int>> ClusterChargeEC2("ClusterChargeEC2");
565 static const SG::Decorator<std::vector<int>> ClusterChargeEC3("ClusterChargeEC3");
566 static const SG::Decorator<std::vector<int>> ClusterToTIBL("ClusterToTIBL");
567 static const SG::Decorator<std::vector<int>> ClusterToT3D("ClusterToT3D");
568 static const SG::Decorator<std::vector<int>> ClusterToTBL("ClusterToTBL");
569 static const SG::Decorator<std::vector<int>> ClusterToTL1("ClusterToTL1");
570 static const SG::Decorator<std::vector<int>> ClusterToTL2("ClusterToTL2");
571 static const SG::Decorator<std::vector<int>> ClusterToTEA1("ClusterToTEA1");
572 static const SG::Decorator<std::vector<int>> ClusterToTEA2("ClusterToTEA2");
573 static const SG::Decorator<std::vector<int>> ClusterToTEA3("ClusterToTEA3");
574 static const SG::Decorator<std::vector<int>> ClusterToTEC1("ClusterToTEC1");
575 static const SG::Decorator<std::vector<int>> ClusterToTEC2("ClusterToTEC2");
576 static const SG::Decorator<std::vector<int>> ClusterToTEC3("ClusterToTEC3");
577 static const SG::Decorator<std::vector<int>> ClusterdEdxIBL("ClusterdEdxIBL");
578 static const SG::Decorator<std::vector<int>> ClusterdEdx3D("ClusterdEdx3D");
579 static const SG::Decorator<std::vector<int>> ClusterdEdxBL("ClusterdEdxBL");
580 static const SG::Decorator<std::vector<int>> ClusterdEdxL1("ClusterdEdxL1");
581 static const SG::Decorator<std::vector<int>> ClusterdEdxL2("ClusterdEdxL2");
582 static const SG::Decorator<std::vector<int>> ClusterdEdxEA1("ClusterdEdxEA1");
583 static const SG::Decorator<std::vector<int>> ClusterdEdxEA2("ClusterdEdxEA2");
584 static const SG::Decorator<std::vector<int>> ClusterdEdxEA3("ClusterdEdxEA3");
585 static const SG::Decorator<std::vector<int>> ClusterdEdxEC1("ClusterdEdxEC1");
586 static const SG::Decorator<std::vector<int>> ClusterdEdxEC2("ClusterdEdxEC2");
587 static const SG::Decorator<std::vector<int>> ClusterdEdxEC3("ClusterdEdxEC3");
588 static const SG::Decorator<std::vector<int>> ClusterSizeXIBL("ClusterSizeXIBL");
589 static const SG::Decorator<std::vector<int>> ClusterSizeX3D("ClusterSizeX3D");
590 static const SG::Decorator<std::vector<int>> ClusterSizeXBL("ClusterSizeXBL");
591 static const SG::Decorator<std::vector<int>> ClusterSizeXL1("ClusterSizeXL1");
592 static const SG::Decorator<std::vector<int>> ClusterSizeXL2("ClusterSizeXL2");
593 static const SG::Decorator<std::vector<int>> ClusterSizeXEA1("ClusterSizeXEA1");
594 static const SG::Decorator<std::vector<int>> ClusterSizeXEA2("ClusterSizeXEA2");
595 static const SG::Decorator<std::vector<int>> ClusterSizeXEA3("ClusterSizeXEA3");
596 static const SG::Decorator<std::vector<int>> ClusterSizeXEC1("ClusterSizeXEC1");
597 static const SG::Decorator<std::vector<int>> ClusterSizeXEC2("ClusterSizeXEC2");
598 static const SG::Decorator<std::vector<int>> ClusterSizeXEC3("ClusterSizeXEC3");
599 static const SG::Decorator<std::vector<int>> ClusterSizeZIBL("ClusterSizeZIBL");
600 static const SG::Decorator<std::vector<int>> ClusterSizeZ3D("ClusterSizeZ3D");
601 static const SG::Decorator<std::vector<int>> ClusterSizeZBL("ClusterSizeZBL");
602 static const SG::Decorator<std::vector<int>> ClusterSizeZL1("ClusterSizeZL1");
603 static const SG::Decorator<std::vector<int>> ClusterSizeZL2("ClusterSizeZL2");
604 static const SG::Decorator<std::vector<int>> ClusterSizeZEA1("ClusterSizeZEA1");
605 static const SG::Decorator<std::vector<int>> ClusterSizeZEA2("ClusterSizeZEA2");
606 static const SG::Decorator<std::vector<int>> ClusterSizeZEA3("ClusterSizeZEA3");
607 static const SG::Decorator<std::vector<int>> ClusterSizeZEC1("ClusterSizeZEC1");
608 static const SG::Decorator<std::vector<int>> ClusterSizeZEC2("ClusterSizeZEC2");
609 static const SG::Decorator<std::vector<int>> ClusterSizeZEC3("ClusterSizeZEC3");
610 static const SG::Decorator<std::vector<int>> ClusterResidualXIBL("ClusterResidualXIBL");
611 static const SG::Decorator<std::vector<int>> ClusterResidualX3D("ClusterResidualX3D");
612 static const SG::Decorator<std::vector<int>> ClusterResidualXBL("ClusterResidualXBL");
613 static const SG::Decorator<std::vector<int>> ClusterResidualXL1("ClusterResidualXL1");
614 static const SG::Decorator<std::vector<int>> ClusterResidualXL2("ClusterResidualXL2");
615 static const SG::Decorator<std::vector<int>> ClusterResidualXEA1("ClusterResidualXEA1");
616 static const SG::Decorator<std::vector<int>> ClusterResidualXEA2("ClusterResidualXEA2");
617 static const SG::Decorator<std::vector<int>> ClusterResidualXEA3("ClusterResidualXEA3");
618 static const SG::Decorator<std::vector<int>> ClusterResidualXEC1("ClusterResidualXEC1");
619 static const SG::Decorator<std::vector<int>> ClusterResidualXEC2("ClusterResidualXEC2");
620 static const SG::Decorator<std::vector<int>> ClusterResidualXEC3("ClusterResidualXEC3");
621 static const SG::Decorator<std::vector<int>> ClusterResidualYIBL("ClusterResidualYIBL");
622 static const SG::Decorator<std::vector<int>> ClusterResidualY3D("ClusterResidualY3D");
623 static const SG::Decorator<std::vector<int>> ClusterResidualYBL("ClusterResidualYBL");
624 static const SG::Decorator<std::vector<int>> ClusterResidualYL1("ClusterResidualYL1");
625 static const SG::Decorator<std::vector<int>> ClusterResidualYL2("ClusterResidualYL2");
626 static const SG::Decorator<std::vector<int>> ClusterResidualYEA1("ClusterResidualYEA1");
627 static const SG::Decorator<std::vector<int>> ClusterResidualYEA2("ClusterResidualYEA2");
628 static const SG::Decorator<std::vector<int>> ClusterResidualYEA3("ClusterResidualYEA3");
629 static const SG::Decorator<std::vector<int>> ClusterResidualYEC1("ClusterResidualYEC1");
630 static const SG::Decorator<std::vector<int>> ClusterResidualYEC2("ClusterResidualYEC2");
631 static const SG::Decorator<std::vector<int>> ClusterResidualYEC3("ClusterResidualYEC3");
632 static const SG::Decorator<std::vector<int>> ClusterHoleIBL("ClusterHoleIBL");
633 static const SG::Decorator<std::vector<int>> ClusterHole3D("ClusterHole3D");
634 static const SG::Decorator<std::vector<int>> ClusterHoleBL("ClusterHoleBL");
635 static const SG::Decorator<std::vector<int>> ClusterHoleL1("ClusterHoleL1");
636 static const SG::Decorator<std::vector<int>> ClusterHoleL2("ClusterHoleL2");
637 static const SG::Decorator<std::vector<int>> ClusterHoleEA1("ClusterHoleEA1");
638 static const SG::Decorator<std::vector<int>> ClusterHoleEA2("ClusterHoleEA2");
639 static const SG::Decorator<std::vector<int>> ClusterHoleEA3("ClusterHoleEA3");
640 static const SG::Decorator<std::vector<int>> ClusterHoleEC1("ClusterHoleEC1");
641 static const SG::Decorator<std::vector<int>> ClusterHoleEC2("ClusterHoleEC2");
642 static const SG::Decorator<std::vector<int>> ClusterHoleEC3("ClusterHoleEC3");
643 static const SG::Decorator<std::vector<int>> ClusterOccIBL("ClusterOccIBL");
644 static const SG::Decorator<std::vector<int>> ClusterOcc3D("ClusterOcc3D");
645 static const SG::Decorator<std::vector<int>> ClusterOccBL("ClusterOccBL");
646 static const SG::Decorator<std::vector<int>> ClusterOccL1("ClusterOccL1");
647 static const SG::Decorator<std::vector<int>> ClusterOccL2("ClusterOccL2");
648 static const SG::Decorator<std::vector<int>> ClusterOccEA1("ClusterOccEA1");
649 static const SG::Decorator<std::vector<int>> ClusterOccEA2("ClusterOccEA2");
650 static const SG::Decorator<std::vector<int>> ClusterOccEA3("ClusterOccEA3");
651 static const SG::Decorator<std::vector<int>> ClusterOccEC1("ClusterOccEC1");
652 static const SG::Decorator<std::vector<int>> ClusterOccEC2("ClusterOccEC2");
653 static const SG::Decorator<std::vector<int>> ClusterOccEC3("ClusterOccEC3");
654 static const SG::Decorator<std::vector<int>> TrackALL("TrackALL");
655 static const SG::Decorator<std::vector<int>> TrackHOLE("TrackHOLE");
656 static const SG::Decorator<std::vector<int>> TrackdEdx("TrackdEdx");
657
658 TrackEtaIBL(*tp) = std::move(clusEta[0]);
659 TrackEta3D(*tp) = std::move(clusEta[1]);
660 TrackEtaBL(*tp) = std::move(clusEta[2]);
661 TrackEtaL1(*tp) = std::move(clusEta[3]);
662 TrackEtaL2(*tp) = std::move(clusEta[4]);
663 TrackEtaEA1(*tp) = std::move(clusEta[5]);
664 TrackEtaEA2(*tp) = std::move(clusEta[6]);
665 TrackEtaEA3(*tp) = std::move(clusEta[7]);
666 TrackEtaEC1(*tp) = std::move(clusEta[8]);
667 TrackEtaEC2(*tp) = std::move(clusEta[9]);
668 TrackEtaEC3(*tp) = std::move(clusEta[10]);
669 TrackHitEtaIBL(*tp) = std::move(clusHitEta[0]);
670 TrackHitEta3D(*tp) = std::move(clusHitEta[1]);
671 TrackHitEtaBL(*tp) = std::move(clusHitEta[2]);
672 TrackHitEtaL1(*tp) = std::move(clusHitEta[3]);
673 TrackHitEtaL2(*tp) = std::move(clusHitEta[4]);
674 TrackHitEtaEA1(*tp) = std::move(clusHitEta[5]);
675 TrackHitEtaEA2(*tp) = std::move(clusHitEta[6]);
676 TrackHitEtaEA3(*tp) = std::move(clusHitEta[7]);
677 TrackHitEtaEC1(*tp) = std::move(clusHitEta[8]);
678 TrackHitEtaEC2(*tp) = std::move(clusHitEta[9]);
679 TrackHitEtaEC3(*tp) = std::move(clusHitEta[10]);
680 ClusterChargeIBL(*tp) = std::move(clusCharge[0]);
681 ClusterCharge3D(*tp) = std::move(clusCharge[1]);
682 ClusterChargeBL(*tp) = std::move(clusCharge[2]);
683 ClusterChargeL1(*tp) = std::move(clusCharge[3]);
684 ClusterChargeL2(*tp) = std::move(clusCharge[4]);
685 ClusterChargeEA1(*tp) = std::move(clusCharge[5]);
686 ClusterChargeEA2(*tp) = std::move(clusCharge[6]);
687 ClusterChargeEA3(*tp) = std::move(clusCharge[7]);
688 ClusterChargeEC1(*tp) = std::move(clusCharge[8]);
689 ClusterChargeEC2(*tp) = std::move(clusCharge[9]);
690 ClusterChargeEC3(*tp) = std::move(clusCharge[10]);
691 ClusterToTIBL(*tp) = std::move(clusToT[0]);
692 ClusterToT3D(*tp) = std::move(clusToT[1]);
693 ClusterToTBL(*tp) = std::move(clusToT[2]);
694 ClusterToTL1(*tp) = std::move(clusToT[3]);
695 ClusterToTL2(*tp) = std::move(clusToT[4]);
696 ClusterToTEA1(*tp) = std::move(clusToT[5]);
697 ClusterToTEA2(*tp) = std::move(clusToT[6]);
698 ClusterToTEA3(*tp) = std::move(clusToT[7]);
699 ClusterToTEC1(*tp) = std::move(clusToT[8]);
700 ClusterToTEC2(*tp) = std::move(clusToT[9]);
701 ClusterToTEC3(*tp) = std::move(clusToT[10]);
702 ClusterdEdxIBL(*tp) = std::move(clusdEdx[0]);
703 ClusterdEdx3D(*tp) = std::move(clusdEdx[1]);
704 ClusterdEdxBL(*tp) = std::move(clusdEdx[2]);
705 ClusterdEdxL1(*tp) = std::move(clusdEdx[3]);
706 ClusterdEdxL2(*tp) = std::move(clusdEdx[4]);
707 ClusterdEdxEA1(*tp) = std::move(clusdEdx[5]);
708 ClusterdEdxEA2(*tp) = std::move(clusdEdx[6]);
709 ClusterdEdxEA3(*tp) = std::move(clusdEdx[7]);
710 ClusterdEdxEC1(*tp) = std::move(clusdEdx[8]);
711 ClusterdEdxEC2(*tp) = std::move(clusdEdx[9]);
712 ClusterdEdxEC3(*tp) = std::move(clusdEdx[10]);
713 ClusterSizeXIBL(*tp) = std::move(clusSizeX[0]);
714 ClusterSizeX3D(*tp) = std::move(clusSizeX[1]);
715 ClusterSizeXBL(*tp) = std::move(clusSizeX[2]);
716 ClusterSizeXL1(*tp) = std::move(clusSizeX[3]);
717 ClusterSizeXL2(*tp) = std::move(clusSizeX[4]);
718 ClusterSizeXEA1(*tp) = std::move(clusSizeX[5]);
719 ClusterSizeXEA2(*tp) = std::move(clusSizeX[6]);
720 ClusterSizeXEA3(*tp) = std::move(clusSizeX[7]);
721 ClusterSizeXEC1(*tp) = std::move(clusSizeX[8]);
722 ClusterSizeXEC2(*tp) = std::move(clusSizeX[9]);
723 ClusterSizeXEC3(*tp) = std::move(clusSizeX[10]);
724 ClusterSizeZIBL(*tp) = std::move(clusSizeZ[0]);
725 ClusterSizeZ3D(*tp) = std::move(clusSizeZ[1]);
726 ClusterSizeZBL(*tp) = std::move(clusSizeZ[2]);
727 ClusterSizeZL1(*tp) = std::move(clusSizeZ[3]);
728 ClusterSizeZL2(*tp) = std::move(clusSizeZ[4]);
729 ClusterSizeZEA1(*tp) = std::move(clusSizeZ[5]);
730 ClusterSizeZEA2(*tp) = std::move(clusSizeZ[6]);
731 ClusterSizeZEA3(*tp) = std::move(clusSizeZ[7]);
732 ClusterSizeZEC1(*tp) = std::move(clusSizeZ[8]);
733 ClusterSizeZEC2(*tp) = std::move(clusSizeZ[9]);
734 ClusterSizeZEC3(*tp) = std::move(clusSizeZ[10]);
735 ClusterResidualXIBL(*tp) = std::move(clusResidualX[0]);
736 ClusterResidualX3D(*tp) = std::move(clusResidualX[1]);
737 ClusterResidualXBL(*tp) = std::move(clusResidualX[2]);
738 ClusterResidualXL1(*tp) = std::move(clusResidualX[3]);
739 ClusterResidualXL2(*tp) = std::move(clusResidualX[4]);
740 ClusterResidualXEA1(*tp) = std::move(clusResidualX[5]);
741 ClusterResidualXEA2(*tp) = std::move(clusResidualX[6]);
742 ClusterResidualXEA3(*tp) = std::move(clusResidualX[7]);
743 ClusterResidualXEC1(*tp) = std::move(clusResidualX[8]);
744 ClusterResidualXEC2(*tp) = std::move(clusResidualX[9]);
745 ClusterResidualXEC3(*tp) = std::move(clusResidualX[10]);
746 ClusterResidualYIBL(*tp) = std::move(clusResidualY[0]);
747 ClusterResidualY3D(*tp) = std::move(clusResidualY[1]);
748 ClusterResidualYBL(*tp) = std::move(clusResidualY[2]);
749 ClusterResidualYL1(*tp) = std::move(clusResidualY[3]);
750 ClusterResidualYL2(*tp) = std::move(clusResidualY[4]);
751 ClusterResidualYEA1(*tp) = std::move(clusResidualY[5]);
752 ClusterResidualYEA2(*tp) = std::move(clusResidualY[6]);
753 ClusterResidualYEA3(*tp) = std::move(clusResidualY[7]);
754 ClusterResidualYEC1(*tp) = std::move(clusResidualY[8]);
755 ClusterResidualYEC2(*tp) = std::move(clusResidualY[9]);
756 ClusterResidualYEC3(*tp) = std::move(clusResidualY[10]);
757 ClusterHoleIBL(*tp) = std::move(clusHole[0]);
758 ClusterHole3D(*tp) = std::move(clusHole[1]);
759 ClusterHoleBL(*tp) = std::move(clusHole[2]);
760 ClusterHoleL1(*tp) = std::move(clusHole[3]);
761 ClusterHoleL2(*tp) = std::move(clusHole[4]);
762 ClusterHoleEA1(*tp) = std::move(clusHole[5]);
763 ClusterHoleEA2(*tp) = std::move(clusHole[6]);
764 ClusterHoleEA3(*tp) = std::move(clusHole[7]);
765 ClusterHoleEC1(*tp) = std::move(clusHole[8]);
766 ClusterHoleEC2(*tp) = std::move(clusHole[9]);
767 ClusterHoleEC3(*tp) = std::move(clusHole[10]);
768 ClusterOccIBL(*tp) = std::move(clusOcc[0]);
769 ClusterOcc3D(*tp) = std::move(clusOcc[1]);
770 ClusterOccBL(*tp) = std::move(clusOcc[2]);
771 ClusterOccL1(*tp) = std::move(clusOcc[3]);
772 ClusterOccL2(*tp) = std::move(clusOcc[4]);
773 ClusterOccEA1(*tp) = std::move(clusOcc[5]);
774 ClusterOccEA2(*tp) = std::move(clusOcc[6]);
775 ClusterOccEA3(*tp) = std::move(clusOcc[7]);
776 ClusterOccEC1(*tp) = std::move(clusOcc[8]);
777 ClusterOccEC2(*tp) = std::move(clusOcc[9]);
778 ClusterOccEC3(*tp) = std::move(clusOcc[10]);
779 TrackALL(*tp) = std::move(trkEta);
780 TrackHOLE(*tp) = std::move(trkHole);
781 TrackdEdx(*tp) = std::move(trkdEdx);
782
783 PixelMonitoringTrack->push_back(tp);
784 }
785 }
786 return StatusCode::SUCCESS;
787}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
charge
double charge(const T &p)
Definition AtlasPID.h:1003
DerivationFramework::PixelNtupleMaker::m_selector
ToolHandle< InDet::IInDetTrackSelectionTool > m_selector
Definition PixelNtupleMaker.h:43
DerivationFramework::PixelNtupleMaker::m_containerKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_containerKey
Definition PixelNtupleMaker.h:46
DerivationFramework::PixelNtupleMaker::m_monitoringTracks
SG::WriteHandleKey< xAOD::TrackParticleContainer > m_monitoringTracks
Definition PixelNtupleMaker.h:51
DerivationFramework::PixelNtupleMaker::m_measurementContainerKey
SG::ReadHandleKey< xAOD::TrackMeasurementValidationContainer > m_measurementContainerKey
Definition PixelNtupleMaker.h:48
DerivationFramework::PixelNtupleMaker::MeasurementsOnTrack
std::vector< ElementLink< xAOD::TrackStateValidationContainer > > MeasurementsOnTrack
Definition PixelNtupleMaker.h:53
DerivationFramework::PixelNtupleMaker::GetLayerEtaPhiFromId
static void GetLayerEtaPhiFromId(uint64_t id, int *barrelEC, int *layer, int *eta, int *phi)
Definition PixelNtupleMaker.cxx:789
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition TrackStateOnSurface.h:128
xAOD::TrackParticle_v1::setDefiningParametersCovMatrixVec
void setDefiningParametersCovMatrixVec(const std::vector< float > &cov)
Definition TrackParticle_v1.cxx:412
xAOD::TrackStateValidation_v1::localX
float localX() const
xAOD::TrackStateValidation_v1::detElementId
uint64_t detElementId() const
Returns the detector element identifier.
xAOD::TrackStateValidation_v1::unbiasedResidualX
float unbiasedResidualX() const
Returns the unbiased x residual.
xAOD::TrackStateValidation_v1::localY
float localY() const
Returns the y position.
xAOD::TrackStateValidation_v1::type
int type() const
xAOD::TrackStateValidation_v1::localTheta
float localTheta() const
Returns the theta position.
xAOD::TrackStateValidation_v1::unbiasedResidualY
float unbiasedResidualY() const
Returns the unbiased x residual.
xAOD::TrackStateValidation_v1::detType
char detType() const
Returns the detector type.
xAOD::TrackStateValidation_v1::localPhi
float localPhi() const
Returns the phi position.
xAOD::TrackStateValidation_v1::trackMeasurementValidationLink
ElementLink< xAOD::TrackMeasurementValidationContainer > trackMeasurementValidationLink() const
IDTPM::nSCTSharedHits
float nSCTSharedHits(const U &p)
Definition TrackParametersHelper.h:412
IDTPM::nSCTHoles
float nSCTHoles(const U &p)
Definition TrackParametersHelper.h:402
IDTPM::nSCTHits
float nSCTHits(const U &p)
Definition TrackParametersHelper.h:392
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition LArNewCalib_DelayDump_OFC_Cali.py:69
SG::ConstAccessor
SG::ConstAccessor< T, ALLOC > ConstAccessor
Definition AuxElement.h:570
SG::Decorator
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576
TRT::Hit::globalZ
@ globalZ
Definition HitInfo.h:39
TauTrackVars::trackPhi
bool trackPhi(const xAOD::TauJet &, const xAOD::TauTrack &track, float &out)
Definition ConstituentLoaderTauTrack.cxx:122
xAOD::TrackMeasurementValidation
TrackMeasurementValidation_v1 TrackMeasurementValidation
Reference the current persistent version:
Definition TrackMeasurementValidation.h:13
xAOD::TrackStateValidation
TrackStateValidation_v1 TrackStateValidation
Reference the current persistent version:
Definition TrackStateValidation.h:13
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition TrackingPrimitives.h:257
xAOD::numberOfPixelOutliers
@ numberOfPixelOutliers
these are the pixel outliers, including the b-layer [unit8_t].
Definition TrackingPrimitives.h:256
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition TrackingPrimitives.h:264
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition TrackingPrimitives.h:255
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition TrackingPrimitives.h:258
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition TrackingPrimitives.h:268
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition TrackingPrimitives.h:262
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition TrackingPrimitives.h:266

◆ GetLayerEtaPhiFromId()

void DerivationFramework::PixelNtupleMaker::GetLayerEtaPhiFromId ( uint64_t id,
int * barrelEC,
int * layer,
int * eta,
int * phi )
static

Definition at line 789 of file PixelNtupleMaker.cxx.

789 {
790 *eta =(id>>43) % 0x20 - 10;
791 *phi =(id>>43) % 0x800 / 0x20;
792 int layer_index = ((id>>43) / 0x800) & 0xF;
793
794 //A possibility is to use a bit by bit AND: layer_index & 0xF
795 switch (layer_index) {
796 case 4:
797 *barrelEC=-2;
798 *layer = 0;
799 break;
800 case 5:
801 *barrelEC=-2;
802 *layer = 1;
803 break;
804 case 6:
805 *barrelEC=-2;
806 *layer = 2;
807 break;
808 case 8:
809 *barrelEC=0;
810 *layer=0;
811 break;
812 case 9:
813 *layer=1;
814 *barrelEC=0;
815 break;
816 case 10:
817 *layer=2;
818 *barrelEC=0;
819 break;
820 case 11:
821 *barrelEC=0;
822 *layer =3;
823 break;
824 case 12:
825 *barrelEC=2;
826 *layer=0;
827 break;
828 case 13:
829 *layer =1;
830 *barrelEC=2;
831 break;
832 case 14:
833 *layer=2;
834 *barrelEC=2;
835 break;
836 }
837}
TRT::Hit::layer
@ layer
Definition HitInfo.h:79

◆ initialize()

StatusCode DerivationFramework::PixelNtupleMaker::initialize ( )
finaloverridevirtual

Definition at line 19 of file PixelNtupleMaker.cxx.

19 {
20 ATH_CHECK(m_selector.retrieve());
21 ATH_CHECK(m_containerKey.initialize());
22 ATH_CHECK(m_measurementContainerKey.initialize());
23 ATH_CHECK(m_monitoringTracks.initialize());
24 return StatusCode::SUCCESS;
25}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40

Member Data Documentation

◆ m_containerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PixelNtupleMaker::m_containerKey { this, "ContainerName", "InDetTrackParticles", "" }
private

Definition at line 45 of file PixelNtupleMaker.h.

46{ this, "ContainerName", "InDetTrackParticles", "" };

◆ m_measurementContainerKey

SG::ReadHandleKey<xAOD::TrackMeasurementValidationContainer> DerivationFramework::PixelNtupleMaker::m_measurementContainerKey { this, "MeasurementValidationKey","PixelClusters", ""}
private

Definition at line 47 of file PixelNtupleMaker.h.

48{ this, "MeasurementValidationKey","PixelClusters", ""};

◆ m_monitoringTracks

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PixelNtupleMaker::m_monitoringTracks { this, "PixelMonitoringTracksKey", "PixelMonitoringTrack","" }
private

Definition at line 50 of file PixelNtupleMaker.h.

51{ this, "PixelMonitoringTracksKey", "PixelMonitoringTrack","" };

◆ m_selector

ToolHandle<InDet::IInDetTrackSelectionTool> DerivationFramework::PixelNtupleMaker::m_selector {this, "TrackSelectionTool",""}
private

Definition at line 42 of file PixelNtupleMaker.h.

43{this, "TrackSelectionTool",""};

◆ m_storeMode

Gaudi::Property<int> DerivationFramework::PixelNtupleMaker::m_storeMode {this, "StoreMode", 1, "Storing mode: 1:full, 2:small, 3:Z->tautau"}
private

Definition at line 39 of file PixelNtupleMaker.h.

40{this, "StoreMode", 1, "Storing mode: 1:full, 2:small, 3:Z->tautau"};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0