ATLAS Offline Software
PhysicsVariablePlots.cxx
Go to the documentation of this file.
1 //Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
2 
3 
4 #include "FlavourTaggingTests/PhysicsVariablePlots.h"
5 
6 #include "xAODBTagging/BTaggingContainer.h"
7 #include "xAODBTagging/BTaggingAuxContainer.h"
8 #include "xAODBTagging/BTaggingUtilities.h"
9 
10 #include "xAODMuon/MuonContainer.h"
11 #include "xAODMuon/MuonAuxContainer.h"
12 
13 #include "CxxUtils/phihelper.h"
14 
15 #include "FlavorTagDiscriminants/BTagTrackIpAccessor.h"
16 
17 namespace FTAGValidation {
18 
19  PhysicsVariablePlots::PhysicsVariablePlots( const std::string& name,
20  ISvcLocator* pSvcLocator ) :
21  FTAGValidationAlgorithm( name, pSvcLocator ) {}
22 
23  PhysicsVariablePlots::~PhysicsVariablePlots() {}
24 
25  /* ===================================================================== */
26 
27  StatusCode PhysicsVariablePlots::initialize() {
28  ATH_MSG_INFO( "Inizializing " << name() << " ..." );
29  ATH_CHECK( FTAGValidationAlgorithm::initialize() );
30 
31  ATH_MSG_INFO( "Properties declaration:" );
32  ATH_MSG_INFO( " -- " << m_jetKey );
33  ATH_MSG_INFO( " -- " << m_vertexKey );
34  ATH_MSG_INFO( " -- " << m_trackKey );
35 
36  ATH_MSG_INFO( " -- " << m_minJetEta );
37  ATH_MSG_INFO( " -- " << m_maxJetEta );
38  ATH_MSG_INFO( " -- " << m_minJetPt );
39 
40  ATH_CHECK( m_jetKey.initialize() );
41  ATH_CHECK( m_vertexKey.initialize() );
42  ATH_CHECK( m_trackKey.initialize() );
43 
44  ATH_CHECK( m_histSvc.retrieve() );
45  ATH_CHECK( initializeHistograms() );
46 
47  return StatusCode::SUCCESS;
48  }
49 
50  StatusCode PhysicsVariablePlots::execute() {
51  ATH_MSG_DEBUG( "Executing " << name() << " ..." );
52 
53  const EventContext context = getContext();
54 
55  /* =========================================================================================================================================== */
56  /* ==== Retrieve Collections */
57  /* =========================================================================================================================================== */
58 
59  // Event Info
60  SG::ReadHandle< xAOD::EventInfo > eventInfoHandle = SG::makeHandle( m_eventInfoKey,context );
61  ATH_CHECK( eventInfoHandle.isValid() );
62  const xAOD::EventInfo *eventInfo = eventInfoHandle.get();
63 
64  // Retrieve Jet Collection
65  const xAOD::JetContainer *jetCollection = nullptr;
66  ATH_CHECK( retrieveCollectionfromStoreGate( context,jetCollection,m_jetKey ) );
67 
68  // Retrieve Vertex Collection
69  const xAOD::VertexContainer *vertexCollection = nullptr;
70  ATH_CHECK( retrieveCollectionfromStoreGate( context,vertexCollection,m_vertexKey ) );
71  ATH_CHECK( fillHistogram( "nPrimVtx",vertexCollection->size() ) );
72 
73  const xAOD::Vertex *primaryVertex = getPrimaryVertex( vertexCollection );
74  if ( primaryVertex == nullptr ) {
75  ATH_MSG_ERROR( "Could not retrieve Primary Vertex" );
76  return StatusCode::FAILURE;
77  }
78 
79  ATH_CHECK( fillHistogram( "nTracksPrimVtx",primaryVertex->nTrackParticles() ) );
80  ATH_CHECK( fillHistogram( "PV_x" ,primaryVertex->x() ) );
81  ATH_CHECK( fillHistogram( "PV_y" ,primaryVertex->y() ) );
82  ATH_CHECK( fillHistogram( "PV_z" ,primaryVertex->z() ) );
83 
84  // Retrieve TrackParticleCollection
85  const xAOD::TrackParticleContainer *trackParticleCollection = nullptr;
86  ATH_CHECK( retrieveCollectionfromStoreGate( context,trackParticleCollection,m_trackKey) );
87  ATH_CHECK( fillHistogram( "nTracks",trackParticleCollection->size() ) );
88 
89  /* =========================================================================================================================================== */
90  /* ==== ShortList jets */
91  /* =========================================================================================================================================== */
92 
93  std::vector< const xAOD::Jet* > qualityJetCollection;
94 
95  for ( const xAOD::Jet *jet : *jetCollection ) {
96  if ( not passJetQualitySelection( jet ) ) continue;
97  if ( not passJetKinematicSelection( jet ) ) continue;
98  if ( not passJetJVTSelection( jet,m_jetKey.key() ) ) continue;
99  qualityJetCollection.push_back( jet );
100  }
101 
102  ATH_CHECK( fillHistogram( "nJets",qualityJetCollection.size() ) );
103 
104  /* =========================================================================================================================================== */
105  /* ==== Run on Jets */
106  /* =========================================================================================================================================== */
107 
108  int nJetsWithMuon = 0;
109  int nJetsWithSV = 0;
110 
111  for ( const xAOD::Jet *jet : qualityJetCollection ) {
112 
113  ATH_MSG_DEBUG( "JET KINEMATICS:" );
114  ATH_MSG_DEBUG( " ** pt=" << jet->p4().Et() / Gaudi::Units::GeV <<
115  " eta=" << jet->eta() <<
116  " phi=" << jet->phi() );
117 
118  ATH_CHECK( fillHistogram( "jet_E" , jet->e() / Gaudi::Units::GeV ) );
119  ATH_CHECK( fillHistogram( "jet_pT" , jet->pt() / Gaudi::Units::GeV ) );
120  ATH_CHECK( fillHistogram( "jet_eta" , jet->eta() ) );
121  ATH_CHECK( fillHistogram( "jet_phi" , jet->phi() ) );
122  //nMuons and nSV1
123  const xAOD::BTagging* bTag = xAOD::BTaggingUtilities::getBTagging( *jet );
124  std::vector< ElementLink< xAOD::VertexContainer > > SV1_vertex = bTag->auxdata<std::vector< ElementLink< xAOD::VertexContainer > > >("SV1_vertices");
125  if(SV1_vertex.size() >= 1) nJetsWithSV++;
126 
127  if (bTag->isAvailable< ElementLink<xAOD::MuonContainer> >("SMT_mu_link")) {
128  ElementLink<xAOD::MuonContainer> muonLink = bTag->auxdata< ElementLink<xAOD::MuonContainer> >("SMT_mu_link");
129  if ( muonLink.isValid() ) {
130  const xAOD::Muon* muon=(*muonLink);
131  if ( muon != 0 ) {
132  nJetsWithMuon++;
133  ATH_CHECK( fillHistogram( "muon_pT_frac" , muon->pt() / jet->pt() ) );
134  }
135  }
136  }
137  else {
138  ATH_MSG_DEBUG( "SMT_mu_link is not available." );
139  }
140 
141  // Retrieve jet flavour
142  std::string flavour = "DATA_";
143  if ( eventInfo->eventType(xAOD::EventInfo::EventType::IS_SIMULATION) ) {
144 
145  if ( jet->isAvailable< int >( "HadronConeExclTruthLabelID" ) == false ) {
146  ATH_MSG_ERROR( "Input sample is MC but jet has no 'HadronConeExclTruthLabelID' aux data. Something is wrong!" );
147  return StatusCode::FAILURE;
148  }
149 
150  int HadronConeExclTruthLabelID = jet->auxdata< int >( "HadronConeExclTruthLabelID");
151  ATH_MSG_DEBUG( " ** 'HadronConeExclTruthLabelID' is " << HadronConeExclTruthLabelID );
152  ATH_CHECK( fillHistogram( "truth_label" , HadronConeExclTruthLabelID ) );
153 
154  if ( HadronConeExclTruthLabelID == 0 ) flavour = "U_";
155  else if ( HadronConeExclTruthLabelID == 4 ) flavour = "C_";
156  else if ( HadronConeExclTruthLabelID == 5 ) flavour = "B_";
157  else continue;
158  }
159 
160  ATH_CHECK( analyseTrackParticleObjects( jet,primaryVertex,flavour ) );
161  ATH_CHECK( analyseBTaggingObject( jet,flavour ) );
162  }
163 
164  ATH_CHECK( fillHistogram( "nJetsWithMuon" , nJetsWithMuon ) );
165  ATH_CHECK( fillHistogram( "fracJetsWithMuon" , double(nJetsWithMuon)/double(qualityJetCollection.size()) ) );
166  ATH_CHECK( fillHistogram( "nJetsWithSV" , nJetsWithSV ) );
167  ATH_CHECK( fillHistogram( "fracJetsWithSV" , double(nJetsWithSV)/double(qualityJetCollection.size()) ) );
168 
169  return StatusCode::SUCCESS;
170  }
171 
172  StatusCode PhysicsVariablePlots::finalize() {
173  ATH_MSG_INFO( "Finalizing " << name() << " ..." );
174  return StatusCode::SUCCESS;
175  }
176 
177  /* ===================================================================== */
178 
179  StatusCode PhysicsVariablePlots::initializeHistograms() {
180 
181  // 1D histograms
182  ATH_MSG_DEBUG( "Defining 1D histograms ..." );
183  for ( const std::vector< std::string >& definitions : m_Histograms1Ddefinitions ) {
184  ATH_MSG_DEBUG( " ** " << definitions.at( HISTO::NAME ) << " of type " << definitions.at( HISTO::TYPE ) );
185 
186  if ( definitions.at( HISTO::TYPE ) == "TH1I" )
187  ATH_CHECK( defineHistogram< TH1I >( definitions.at( HISTO::NAME ),
188  definitions.at( HISTO::TITLE ),
189  std::stoi( definitions.at( HISTO::XBINS ) ),
190  std::stoi( definitions.at( HISTO::XMIN ) ),
191  std::stoi( definitions.at( HISTO::XMAX ) ),
192  definitions.at( HISTO::PATH ) ) );
193  else if ( definitions.at( HISTO::TYPE ) == "TH1F" )
194  ATH_CHECK( defineHistogram< TH1F >( definitions.at( HISTO::NAME ),
195  definitions.at( HISTO::TITLE ),
196  std::stoi( definitions.at( HISTO::XBINS ) ),
197  std::stof( definitions.at( HISTO::XMIN ) ),
198  std::stof( definitions.at( HISTO::XMAX ) ),
199  definitions.at( HISTO::PATH )) );
200  else if ( definitions.at( HISTO::TYPE ) == "TH1D" )
201  ATH_CHECK( defineHistogram< TH1D >( definitions.at( HISTO::NAME ),
202  definitions.at( HISTO::TITLE ),
203  std::stoi( definitions.at( HISTO::XBINS ) ),
204  std::stof( definitions.at( HISTO::XMIN ) ),
205  std::stof( definitions.at( HISTO::XMAX ) ),
206  definitions.at( HISTO::PATH )) );
207  }
208 
209  // 2D histograms
210  ATH_MSG_DEBUG( "Defining 2D histograms ..." );
211  for ( const std::vector< std::string >& definitions : m_Histograms2Ddefinitions ) {
212  ATH_MSG_DEBUG( " ** " << definitions.at( HISTO::NAME ) << " of type " << definitions.at( HISTO::TYPE ) );
213 
214  if ( definitions.at( HISTO::TYPE ) == "TH2I" )
215  ATH_CHECK( defineHistogram< TH2I >( definitions.at( HISTO::NAME ),
216  definitions.at( HISTO::TITLE ),
217  std::stoi( definitions.at( HISTO::XBINS ) ),
218  std::stoi( definitions.at( HISTO::XMIN ) ),
219  std::stoi( definitions.at( HISTO::XMAX ) ),
220  std::stoi( definitions.at( HISTO::YBINS ) ),
221  std::stoi( definitions.at( HISTO::YMIN ) ),
222  std::stoi( definitions.at( HISTO::YMAX ) ),
223  definitions.at( HISTO::PATH ) ) );
224  else if ( definitions.at( HISTO::TYPE ) == "TH2F" )
225  ATH_CHECK( defineHistogram< TH2F >( definitions.at( HISTO::NAME ),
226  definitions.at( HISTO::TITLE ),
227  std::stoi( definitions.at( HISTO::XBINS ) ),
228  std::stof( definitions.at( HISTO::XMIN ) ),
229  std::stof( definitions.at( HISTO::XMAX ) ),
230  std::stoi( definitions.at( HISTO::YBINS ) ),
231  std::stof( definitions.at( HISTO::YMIN ) ),
232  std::stof( definitions.at( HISTO::YMAX ) ),
233  definitions.at( HISTO::PATH )) );
234  else if ( definitions.at( HISTO::TYPE ) == "TH2D" )
235  ATH_CHECK( defineHistogram< TH2D >( definitions.at( HISTO::NAME ),
236  definitions.at( HISTO::TITLE ),
237  std::stoi( definitions.at( HISTO::XBINS ) ),
238  std::stof( definitions.at( HISTO::XMIN ) ),
239  std::stof( definitions.at( HISTO::XMAX ) ),
240  std::stoi( definitions.at( HISTO::YBINS ) ),
241  std::stof( definitions.at( HISTO::YMIN ) ),
242  std::stof( definitions.at( HISTO::YMAX ) ),
243  definitions.at( HISTO::PATH )) );
244  }
245 
246 
247  return StatusCode::SUCCESS;
248  }
249 
250  StatusCode PhysicsVariablePlots::analyseTrackParticleObjects( const xAOD::Jet *jet,
251  const xAOD::Vertex *primaryVertex,
252  const std::string& flavour,
253  std::string chain ) {
254 
255  if( chain != "" ) chain = chain + "_";
256 
257  /* =========================================================================================================================================== */
258  /* ==== Ghost Tracks */
259  /* =========================================================================================================================================== */
260 /*
261  if( chain == "" ) { //No ghost tracks at trigger level
262  ATH_MSG_DEBUG( "GHOST TRACKS:" );
263 
264  std::vector< const xAOD::IParticle* > trackVector = jet->getAssociatedObjects< xAOD::IParticle >( xAOD::JetAttribute::GhostTrack );
265  ATH_CHECK( fillHistogram( chain+flavour+"nGhostTracksInJet",trackVector.size() ) );
266  ATH_MSG_DEBUG( " ** nGhostTracks: " << trackVector.size() );
267 
268  for ( const xAOD::IParticle* iparticle : trackVector ) {
269  const xAOD::TrackParticle* trackParticle = dynamic_cast< const xAOD::TrackParticle* >( iparticle );
270  if( not trackParticle ) continue;
271 
272  CHECK( computeAndStoreTrackVariables( flavour,jet,
273  "ghost",trackParticle,
274  primaryVertex ) );
275  }
276  }
277 */
278 
279  /* =========================================================================================================================================== */
280  /* ==== BTagTrackToJetAssociator Tracks */
281  /* =========================================================================================================================================== */
282 
283  ATH_MSG_DEBUG( "BTagTrackToJetAssociator TRACKS:" );
284  const xAOD::BTagging* bTaggingObject = xAOD::BTaggingUtilities::getBTagging( *jet );
285 
286  if ( !bTaggingObject ) {
287  ATH_MSG_ERROR( "Could not retrieve b-tagging object from selected jet." );
288  return StatusCode::FAILURE;
289  }
290 
291  if ( not bTaggingObject->isAvailable< std::vector< ElementLink<xAOD::TrackParticleContainer > > >("BTagTrackToJetAssociator") ) {
292  ATH_MSG_ERROR( "Cannot retrieve 'BTagTrackToJetAssociator' auxdata from b-tagging object!" );
293  return StatusCode::FAILURE;
294  }
295 
296  std::vector< ElementLink< xAOD::TrackParticleContainer > > assocTracks = bTaggingObject->auxdata< std::vector< ElementLink<xAOD::TrackParticleContainer > > >("BTagTrackToJetAssociator");
297  ATH_CHECK( fillHistogram( chain+flavour+"numTracks_perJet",assocTracks.size() ) );
298  ATH_MSG_DEBUG( " ** nBTagTracksInJet: " << assocTracks.size() );
299 
300  for ( const ElementLink< xAOD::TrackParticleContainer >& trackEL : assocTracks ) {
301  if ( not trackEL.isValid() ) continue;
302 
303  const xAOD::TrackParticle* trackParticle = *trackEL;
304 
305  CHECK( computeAndStoreTrackVariables( flavour,jet,
306  "",trackParticle, //Only supporting one track type to simplify merging with PhysVal definitions
307  primaryVertex,chain ) );
308  }
309 
310 
311 
312  return StatusCode::SUCCESS;
313  }
314 
315  StatusCode PhysicsVariablePlots::computeAndStoreTrackVariables( const std::string& jetType, const xAOD::Jet* jet,
316  const std::string& trackType, const xAOD::TrackParticle *trackParticle,
317  const xAOD::Vertex* primaryVertex, const std::string chain) {
318 
319  std::string flavour = jetType + trackType;
320 
321  // Jet Variables
322  float jet_pt = jet->pt();
323  float jet_eta = jet->eta();
324  float jet_phi = jet->phi();
325 
326  // track Variables
327  float track_pt = trackParticle->pt();
328  float fracEt = track_pt / jet_pt;
329 
330  ATH_CHECK( fillHistogram( chain+flavour+"track_pT_frac",fracEt ) );
331  ATH_MSG_DEBUG( " ** pTfrac = " << fracEt );
332 
333  float track_eta = trackParticle->eta();
334  float track_phi = trackParticle->phi();
335 
336  float deltaEta = fabs( jet_eta - track_eta );
337  float deltaPhi = CxxUtils::wrapToPi( jet_phi - track_phi );
338  float deltaR = sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi );
339 
340  ATH_CHECK( fillHistogram( chain+flavour+"DeltaR_jet_track",deltaR ) );
341  ATH_MSG_DEBUG( " ** deltaR = " << deltaR );
342 
343  float d0 = trackParticle->d0();
344  float sigmad0 = sqrt( trackParticle->definingParametersCovMatrix()( Trk::d0, Trk::d0 ) );
345  float z0 = trackParticle->z0() + trackParticle->vz() - primaryVertex->z();
346  float sigmaz0 = sqrt( trackParticle->definingParametersCovMatrix()( Trk::z0, Trk::z0 ) );
347 
348  ATH_CHECK( fillHistogram( chain+flavour+"track_d0",d0 ) );
349  ATH_CHECK( fillHistogram( chain+flavour+"track_sigd0",d0/sigmad0 ) );
350 
351  ATH_CHECK( fillHistogram( chain+flavour+"track_z0",z0 ) );
352  ATH_CHECK( fillHistogram( chain+flavour+"track_sigz0",z0/sigmaz0 ) );
353 
354  ATH_MSG_DEBUG( " ** d0 +/- err [significance] = " << d0 << " +/- " << sigmad0 << " [ " << d0/sigmad0 << " ]" );
355  ATH_MSG_DEBUG( " ** z0 +/- err [significance] = " << z0 << " +/- " << sigmaz0 << " [ " << z0/sigmaz0 << " ]" );
356 
357  if (trackType == "bTag" || trackType == "") {
358 
359  if (chain != "") {
360  BTagTrackIpAccessor accessor("btagIp_");
361  float d0_signed_sig = accessor.getSignedIp(*trackParticle, *jet).ip3d_signed_d0_significance;
362  float z0_signed_sig = accessor.getSignedIp(*trackParticle, *jet).ip3d_signed_z0_significance;
363  ATH_CHECK( fillHistogram( chain+flavour+"track_sigd0_signed", d0_signed_sig) );
364  ATH_CHECK( fillHistogram( chain+flavour+"track_sigz0_signed", z0_signed_sig) );
365  }
366 
367  uint8_t nInnHits = -1;
368  uint8_t nNextToInnHits = -1;
369  uint8_t nBLHits = -1;
370  uint8_t nsharedBLHits = -1;
371  uint8_t nsplitBLHits = -1;
372  uint8_t nPixHits = -1;
373  uint8_t nPixHoles = -1;
374  uint8_t nsharedPixHits = -1;
375  uint8_t nsplitPixHits = -1;
376  uint8_t nSCTHits = -1;
377  uint8_t nSCTHoles = -1;
378  uint8_t nsharedSCTHits = -1;
379 
380  ATH_CHECK( trackParticle->summaryValue(nInnHits,xAOD::numberOfInnermostPixelLayerHits) );
381  ATH_CHECK( trackParticle->summaryValue(nNextToInnHits,xAOD::numberOfNextToInnermostPixelLayerHits) );
382  ATH_CHECK( trackParticle->summaryValue(nBLHits,xAOD::numberOfBLayerHits) );
383  ATH_CHECK( trackParticle->summaryValue(nsharedBLHits,xAOD::numberOfBLayerSharedHits) );
384  ATH_CHECK( trackParticle->summaryValue(nsplitBLHits,xAOD::numberOfBLayerSplitHits) );
385  ATH_CHECK( trackParticle->summaryValue(nPixHits,xAOD::numberOfPixelHits) );
386  ATH_CHECK( trackParticle->summaryValue(nPixHoles,xAOD::numberOfPixelHoles) );
387  ATH_CHECK( trackParticle->summaryValue(nsharedPixHits,xAOD::numberOfPixelSharedHits) );
388  ATH_CHECK( trackParticle->summaryValue(nsplitPixHits,xAOD::numberOfPixelSplitHits) );
389  ATH_CHECK( trackParticle->summaryValue(nSCTHits,xAOD::numberOfSCTHits) );
390  ATH_CHECK( trackParticle->summaryValue(nSCTHoles,xAOD::numberOfSCTHoles) );
391  ATH_CHECK( trackParticle->summaryValue(nsharedSCTHits,xAOD::numberOfSCTSharedHits) );
392 
393  ATH_CHECK( fillHistogram( chain+flavour+"nInnHits", nInnHits) );
394  ATH_CHECK( fillHistogram( chain+flavour+"nNextToInnHits", nNextToInnHits) );
395  ATH_CHECK( fillHistogram( chain+flavour+"nBLHits", nBLHits) );
396  ATH_CHECK( fillHistogram( chain+flavour+"nsharedBLHits", nsharedBLHits) );
397  ATH_CHECK( fillHistogram( chain+flavour+"nsplitBLHits", nsplitBLHits) );
398  ATH_CHECK( fillHistogram( chain+flavour+"nPixHits", nPixHits) );
399  ATH_CHECK( fillHistogram( chain+flavour+"nPixHoles", nPixHoles) );
400  ATH_CHECK( fillHistogram( chain+flavour+"nsharedPixHits", nsharedPixHits) );
401  ATH_CHECK( fillHistogram( chain+flavour+"nsplitPixHits", nsplitPixHits) );
402  ATH_CHECK( fillHistogram( chain+flavour+"nSCTHits", nSCTHits) );
403  ATH_CHECK( fillHistogram( chain+flavour+"nSCTHoles", nSCTHoles) );
404  ATH_CHECK( fillHistogram( chain+flavour+"nsharedSCTHits", nsharedSCTHits) );
405  }
406 
407  return StatusCode::SUCCESS;
408  }
409 
410  StatusCode PhysicsVariablePlots::analyseBTaggingObject( const xAOD::Jet* jet,
411  const std::string& flavour,
412  std::string chain) {
413 
414  if( chain != "" ) chain = chain + "_";
415 
416  float jetPt = jet->p4().Et() / Gaudi::Units::GeV;
417  float jetEta = jet->eta();
418 
419  // Retrieve b-tagging object
420  const xAOD::BTagging *bTaggingObject = xAOD::BTaggingUtilities::getBTagging( *jet );
421  if ( !bTaggingObject ) {
422  ATH_MSG_ERROR( "Could not retrieve b-tagging object from selected jet." );
423  return StatusCode::FAILURE;
424  }
425 
426  // Available variables listed in PhysicsAnalysis/DerivationFramework/DerivationFrameworkFlavourTag/python/BTaggingContent.py
427  ATH_MSG_DEBUG( "BTAGGING:" );
428 
429  // IP2D
430  double IP2D_pu = -1;
431  double IP2D_pb = -1;
432  double IP2D_pc = -1;
433 // double IP2D_LLR = bTaggingObject->IP2D_loglikelihoodratio();
434  bTaggingObject->pu( "IP2D",IP2D_pu );
435  bTaggingObject->pb( "IP2D",IP2D_pb );
436  bTaggingObject->pc( "IP2D",IP2D_pc );
437 
438  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_pu",IP2D_pu ) );
439  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_pb",IP2D_pb ) );
440  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_pc",IP2D_pc ) );
441 // ATH_CHECK( fillHistogram( chain+flavour+"IP2D_LLR",IP2D_LLR ) );
442  ATH_MSG_DEBUG( " ** IP2D [pu,pb,pc] = [" << IP2D_pu <<"," << IP2D_pb << "," << IP2D_pc << "]" );
443 
444 
445  int IP2D_nTrks = -1;
446  std::vector< float > IP2D_weightBOfTracks;
447  std::vector< float > IP2D_weightCOfTracks;
448  std::vector< float > IP2D_weightUOfTracks;
449  std::vector< int > IP2D_gradeOfTracks;
450 // std::vector< float > IP2D_valD0wrtPVOfTracks;
451 // std::vector< float > IP2D_sigD0wrtPVOfTracks;
452 // std::vector< float > IP2D_valZ0wrtPVOfTracks;
453 // std::vector< float > IP2D_sigZ0wrtPVOfTracks;
454 
455  bTaggingObject->variable< int >( "IP2D", "nTrks", IP2D_nTrks );
456  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_weightBOfTracks" ) )
457  IP2D_weightBOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_weightBOfTracks" );
458  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_weightCOfTracks" ) )
459  IP2D_weightCOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_weightCOfTracks" );
460  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_weightUOfTracks" ) )
461  IP2D_weightUOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_weightUOfTracks" );
462  if ( bTaggingObject->isAvailable< std::vector< int > >( "IP2D_gradeOfTracks" ) )
463  IP2D_gradeOfTracks = bTaggingObject->auxdata< std::vector< int > >( "IP2D_gradeOfTracks" );
464 // if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_valD0wrtPVOfTracks" ) )
465 // IP2D_valD0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_valD0wrtPVOfTracks" );
466 // if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_valZ0wrtPVOfTracks" ) )
467 // IP2D_valZ0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_valZ0wrtPVOfTracks" );
468 
469 // if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_sigD0wrtPVOfTracks" ) )
470 // IP2D_sigD0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_sigD0wrtPVOfTracks" );
471 // if ( bTaggingObject->isAvailable< std::vector< float > >( "IP2D_sigZ0wrtPVOfTracks" ) )
472 // IP2D_sigZ0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP2D_sigZ0wrtPVOfTracks" );
473 
474  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_nTracks",IP2D_nTrks ) );
475  for ( unsigned int i(0); i < IP2D_gradeOfTracks.size(); i++ )
476  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_gradeOfTracks", IP2D_gradeOfTracks.at(i) ) );
477  for ( unsigned int i(0); i < IP2D_weightBOfTracks.size(); i++ )
478  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_weightBOfTracks", IP2D_weightBOfTracks.at(i) ) );
479  for ( unsigned int i(0); i < IP2D_weightCOfTracks.size(); i++ )
480  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_weightCOfTracks", IP2D_weightCOfTracks.at(i) ) );
481  for ( unsigned int i(0); i < IP2D_weightUOfTracks.size(); i++ )
482  ATH_CHECK( fillHistogram( chain+flavour+"IP2D_weightUOfTracks", IP2D_weightUOfTracks.at(i) ) );
483 // for ( unsigned int i(0); i < IP2D_valD0wrtPVOfTracks.size(); i++ )
484 // ATH_CHECK( fillHistogram( chain+flavour+"IP2D_valD0wrtPVOfTracks", IP2D_valD0wrtPVOfTracks.at(i) ) ); //value
485 // for ( unsigned int i(0); i < IP2D_sigD0wrtPVOfTracks.size(); i++ )
486 // ATH_CHECK( fillHistogram( chain+flavour+"IP2D_sigD0wrtPVOfTracks", IP2D_sigD0wrtPVOfTracks.at(i) ) ); //significance
487 // for ( unsigned int i(0); i < IP2D_valZ0wrtPVOfTracks.size(); i++ )
488 // ATH_CHECK( fillHistogram( chain+flavour+"IP2D_valZ0wrtPVOfTracks", IP2D_valZ0wrtPVOfTracks.at(i) ) ); //value
489 // for ( unsigned int i(0); i < IP2D_sigZ0wrtPVOfTracks.size(); i++ )
490 // ATH_CHECK( fillHistogram( chain+flavour+"IP2D_sigZ0wrtPVOfTracks", IP2D_sigZ0wrtPVOfTracks.at(i) ) ); //significance
491 
492 
493  // IP3D
494  double IP3D_pu = -1;
495  double IP3D_pb = -1;
496  double IP3D_pc = -1;
497  double IP3D_LLR = bTaggingObject->IP3D_loglikelihoodratio();
498  bTaggingObject->pu( "IP3D",IP3D_pu );
499  bTaggingObject->pb( "IP3D",IP3D_pb );
500  bTaggingObject->pc( "IP3D",IP3D_pc );
501 
502  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_pu",IP3D_pu ) );
503  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_pb",IP3D_pb ) );
504  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_pc",IP3D_pc ) );
505  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_LLR",IP3D_LLR ) );
506  ATH_MSG_DEBUG( " ** IP3D [pu,pb,pc] = [" << IP3D_pu <<"," << IP3D_pb << "," << IP3D_pc << "]" );
507 
508  int IP3D_nTrks = -1;
509  std::vector< float > IP3D_weightBOfTracks;
510  std::vector< float > IP3D_weightCOfTracks;
511  std::vector< float > IP3D_weightUOfTracks;
512  std::vector< int > IP3D_gradeOfTracks;
513  std::vector< float > IP3D_D0wrtPVOfTracks;
514  std::vector< float > IP3D_sigD0wrtPVOfTracks;
515  std::vector< float > IP3D_Z0wrtPVOfTracks;
516  std::vector< float > IP3D_sigZ0wrtPVOfTracks;
517 
518  bTaggingObject->variable< int >( "IP3D", "nTrks", IP3D_nTrks );
519  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_weightBOfTracks" ) )
520  IP3D_weightBOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_weightBOfTracks" );
521  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_weightCOfTracks" ) )
522  IP3D_weightCOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_weightCOfTracks" );
523  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_weightUOfTracks" ) )
524  IP3D_weightUOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_weightUOfTracks" );
525  if ( bTaggingObject->isAvailable< std::vector< int > >( "IP3D_gradeOfTracks" ) )
526  IP3D_gradeOfTracks = bTaggingObject->auxdata< std::vector< int > >( "IP3D_gradeOfTracks" );
527 
528  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_D0wrtPVOfTracks" ) )
529  IP3D_D0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_D0wrtPVOfTracks" );
530  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_Z0wrtPVOfTracks" ) )
531  IP3D_Z0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_Z0wrtPVOfTracks" );
532  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_sigD0wrtPVOfTracks" ) )
533  IP3D_sigD0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_sigD0wrtPVOfTracks" );
534  if ( bTaggingObject->isAvailable< std::vector< float > >( "IP3D_sigZ0wrtPVOfTracks" ) )
535  IP3D_sigZ0wrtPVOfTracks = bTaggingObject->auxdata< std::vector< float > >( "IP3D_sigZ0wrtPVOfTracks" );
536 
537  ATH_MSG_DEBUG("Size IP3D_gradeOfTracks/_weightBOfTracks/_weightUOfTracks/_D0wrtPVOfTracks/_sigD0wrtPVOfTracks/_Z0wrtPVOfTracks/_sigZ0wrtPVOfTracks: " << IP3D_gradeOfTracks.size() <<", "<< IP3D_weightBOfTracks.size() << ", " << IP3D_weightUOfTracks.size() << ", " << IP3D_D0wrtPVOfTracks.size() << ", " << IP3D_sigD0wrtPVOfTracks.size() << ", " << IP3D_Z0wrtPVOfTracks.size() << ", " << IP3D_sigZ0wrtPVOfTracks.size() );
538  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_nTracks",IP3D_nTrks ) );
539  for ( unsigned int i(0); i < IP3D_gradeOfTracks.size(); i++ )
540  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_gradeOfTracks", IP3D_gradeOfTracks.at(i) ) );
541  for ( unsigned int i(0); i < IP3D_weightBOfTracks.size(); i++ )
542  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_weightBOfTracks", IP3D_weightBOfTracks.at(i) ) );
543  for ( unsigned int i(0); i < IP3D_weightCOfTracks.size(); i++ )
544  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_weightCOfTracks", IP3D_weightCOfTracks.at(i) ) );
545  for ( unsigned int i(0); i < IP3D_weightUOfTracks.size(); i++ )
546  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_weightUOfTracks", IP3D_weightUOfTracks.at(i) ) );
547  for ( unsigned int i(0); i < IP3D_D0wrtPVOfTracks.size(); i++ )
548  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_D0wrtPVOfTracks", IP3D_D0wrtPVOfTracks.at(i) ) ); //value
549  for ( unsigned int i(0); i < IP3D_sigD0wrtPVOfTracks.size(); i++ )
550  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_sigD0wrtPVOfTracks", IP3D_sigD0wrtPVOfTracks.at(i) ) ); //significance
551  for ( unsigned int i(0); i < IP3D_Z0wrtPVOfTracks.size(); i++ )
552  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_Z0wrtPVOfTracks", IP3D_Z0wrtPVOfTracks.at(i) ) ); //value
553  for ( unsigned int i(0); i < IP3D_sigZ0wrtPVOfTracks.size(); i++ )
554  ATH_CHECK( fillHistogram( chain+flavour+"IP3D_sigZ0wrtPVOfTracks", IP3D_sigZ0wrtPVOfTracks.at(i) ) ); //significance
555 
556  // SV1
557  double SV1_pu = -1;
558  double SV1_pb = -1;
559  double SV1_pc = -1;
560 // double SV1_LLR = bTaggingObject->SV1_loglikelihoodratio();
561 
562  bTaggingObject->pu( "SV1",SV1_pu );
563  bTaggingObject->pb( "SV1",SV1_pb );
564  bTaggingObject->pc( "SV1",SV1_pc );
565 
566  ATH_CHECK( fillHistogram( chain+flavour+"SV1_pu",SV1_pu ) );
567  ATH_CHECK( fillHistogram( chain+flavour+"SV1_pb",SV1_pb ) );
568  ATH_CHECK( fillHistogram( chain+flavour+"SV1_pc",SV1_pc ) );
569 // ATH_CHECK( fillHistogram( chain+flavour+"SV1_LLR",SV1_LLR ));
570  ATH_MSG_DEBUG( " ** SV1 [pu,pb,pc] = [" << SV1_pu <<"," << SV1_pb << "," << SV1_pc << "]" );
571 
572  float SV1_masssvx = -1;
573  float SV1_efracsvx = -1;
574  float SV1_deltaR = -1;
575  int SV1_N2Tpair = -1;
576  float SV1_significance3d = -1;
577  float SV1_energyTrkInJet = -1;
578  int SV1_NGTinSvx = -1;
579  float SV1_Lxy = -1;
580 
581  bTaggingObject->variable< float >( "SV1", "masssvx", SV1_masssvx );
582  bTaggingObject->variable< float >( "SV1", "efracsvx", SV1_efracsvx );
583  bTaggingObject->variable< float >( "SV1", "deltaR", SV1_deltaR );
584  bTaggingObject->variable< int >( "SV1", "N2Tpair", SV1_N2Tpair );
585  bTaggingObject->variable< float >( "SV1", "significance3d", SV1_significance3d );
586  bTaggingObject->variable< float >( "SV1", "energyTrkInJet", SV1_energyTrkInJet );
587  bTaggingObject->variable< int >( "SV1", "NGTinSvx", SV1_NGTinSvx );
588  bTaggingObject->variable< float >( "SV1", "Lxy", SV1_Lxy );
589 
590  ATH_CHECK( fillHistogram( chain+flavour+"SV1_masssvx",SV1_masssvx ) );
591  ATH_CHECK( fillHistogram( chain+flavour+"SV1_efracsvx",SV1_efracsvx ) );
592  ATH_CHECK( fillHistogram( chain+flavour+"SV1_deltaR",SV1_deltaR ) );
593  ATH_CHECK( fillHistogram( chain+flavour+"SV1_N2Tpair",SV1_N2Tpair ) );
594  ATH_CHECK( fillHistogram( chain+flavour+"SV1_significance3d",SV1_significance3d ) );
595  ATH_CHECK( fillHistogram( chain+flavour+"SV1_energyTrkInJet",SV1_energyTrkInJet ) );
596  ATH_CHECK( fillHistogram( chain+flavour+"SV1_NGTinSvx",SV1_NGTinSvx ) );
597  ATH_CHECK( fillHistogram( chain+flavour+"SV1_Lxy",SV1_Lxy ) );
598 
599  ATH_CHECK( fillHistogram( chain+flavour+"SV1_masssvx_vs_pT_2D",jetPt,SV1_masssvx ) );
600  ATH_CHECK( fillHistogram( chain+flavour+"SV1_N2Tpair_vs_pT_2D",jetPt,SV1_N2Tpair ) );
601  ATH_CHECK( fillHistogram( chain+flavour+"SV1_efracsvx_vs_pT_2D",jetPt,SV1_efracsvx ) );
602  ATH_CHECK( fillHistogram( chain+flavour+"SV1_deltaR_vs_pT_2D",jetPt,SV1_deltaR ) );
603  ATH_CHECK( fillHistogram( chain+flavour+"SV1_masssvx_vs_eta_2D",jetEta,SV1_masssvx ) );
604  ATH_CHECK( fillHistogram( chain+flavour+"SV1_N2Tpair_vs_eta_2D",jetEta,SV1_N2Tpair ) );
605  ATH_CHECK( fillHistogram( chain+flavour+"SV1_efracsvx_vs_eta_2D",jetEta,SV1_efracsvx ) );
606  ATH_CHECK( fillHistogram( chain+flavour+"SV1_deltaR_vs_eta_2D",jetEta,SV1_deltaR ) );
607 
608 
609  ATH_MSG_DEBUG( " ** SV1 [masssvx,efracsvx,deltaR,N2Tpair] = [" << SV1_masssvx <<
610  "," << SV1_efracsvx <<
611  "," << SV1_deltaR <<
612  "," << SV1_N2Tpair << "]" );
613 
614  // Jet Fitter
615  int JetFitter_N2Tpair = -1;
616  int JetFitter_nVTX = -1;
617  int JetFitter_nSingleTracks = -1;
618  int JetFitter_nTracksAtVtx = -1;
619  float JetFitter_mass = -1;
620  float JetFitter_energyFraction = -1;
621  float JetFitter_significance3d = -1;
622  bTaggingObject->variable< int >( "JetFitter","N2Tpair",JetFitter_N2Tpair );
623  bTaggingObject->variable< int >( "JetFitter","nVTX",JetFitter_nVTX );
624  bTaggingObject->variable< int >( "JetFitter","nSingleTracks",JetFitter_nSingleTracks );
625  bTaggingObject->variable< int >( "JetFitter","nTracksAtVtx",JetFitter_nTracksAtVtx );
626  bTaggingObject->variable< float >( "JetFitter","mass",JetFitter_mass );
627  bTaggingObject->variable< float >( "JetFitter","energyFraction",JetFitter_energyFraction );
628  bTaggingObject->variable< float >( "JetFitter","significance3d",JetFitter_significance3d );
629 
630  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_N2Tpair",JetFitter_N2Tpair ) );
631  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_nVTX",JetFitter_nVTX ) );
632  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_nSingleTracks",JetFitter_nSingleTracks ) );
633  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_nTracksAtVtx",JetFitter_nTracksAtVtx ) );
634  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_mass",JetFitter_mass ) );
635  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_energyFraction",JetFitter_energyFraction ) );
636  ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_significance3d",JetFitter_significance3d ) );
637  ATH_MSG_DEBUG( " ** JetFitter [mass] = [" << JetFitter_mass <<"]" );
638 
639 // double JetFitter_pu = bTaggingObject->JetFitter_pu();
640 // double JetFitter_pb = bTaggingObject->JetFitter_pb();
641 // double JetFitter_pc = bTaggingObject->JetFitter_pc();
642 // double JetFitter_LLR = bTaggingObject->JetFitter_loglikelihoodratio();
643 
644 // ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_pu",JetFitter_pu ) );
645 // ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_pb",JetFitter_pb ) );
646 // ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_pc",JetFitter_pc ) );
647 // ATH_CHECK( fillHistogram( chain+flavour+"JetFitter_LLR",JetFitter_LLR ) );
648 
649  // RNNIP
650  double RNNIP_pu = -1;
651  double RNNIP_pb = -1;
652  double RNNIP_pc = -1;
653  double RNNIP_LLR = -1;
654  bTaggingObject->pu( "rnnip",RNNIP_pu );
655  bTaggingObject->pb( "rnnip",RNNIP_pb );
656  bTaggingObject->pc( "rnnip",RNNIP_pc );
657  bTaggingObject->loglikelihoodratio( "rnnip", RNNIP_LLR);
658 
659  ATH_CHECK( fillHistogram( chain+flavour+"RNNIP_pu",RNNIP_pu ) );
660  ATH_CHECK( fillHistogram( chain+flavour+"RNNIP_pb",RNNIP_pb ) );
661  ATH_CHECK( fillHistogram( chain+flavour+"RNNIP_pc",RNNIP_pc ) );
662  ATH_CHECK( fillHistogram( chain+flavour+"RNNIP_LLR",RNNIP_LLR ) );
663  ATH_MSG_DEBUG( " ** RNNIP [pu,pb,pc] = [" << RNNIP_pu <<"," << RNNIP_pb << "," << RNNIP_pc << "]" );
664 
665  // DL1
666  double DL1_pu = -1;
667  double DL1_pb = -1;
668  double DL1_pc = -1;
669  bTaggingObject->pu( "DL1",DL1_pu );
670  bTaggingObject->pb( "DL1",DL1_pb );
671  bTaggingObject->pc( "DL1",DL1_pc );
672  ATH_CHECK( fillHistogram( chain+flavour+"DL1_pu",DL1_pu ) );
673  ATH_CHECK( fillHistogram( chain+flavour+"DL1_pb",DL1_pb ) );
674  ATH_CHECK( fillHistogram( chain+flavour+"DL1_pc",DL1_pc ) );
675 
676  // DL1r
677  double DL1r_pu = -1;
678  double DL1r_pb = -1;
679  double DL1r_pc = -1;
680  bTaggingObject->pu( "DL1r",DL1r_pu );
681  bTaggingObject->pb( "DL1r",DL1r_pb );
682  bTaggingObject->pc( "DL1r",DL1r_pc );
683 
684  if ( DL1r_pu == -1 &&
685  DL1r_pb == -1 &&
686  DL1r_pc == -1 ) {
687  bTaggingObject->pu( "DL1rnn",DL1r_pu );
688  bTaggingObject->pb( "DL1rnn",DL1r_pb );
689  bTaggingObject->pc( "DL1rnn",DL1r_pc );
690  }
691 
692  float cFraction = 0.03;
693  float DL1r = 0;
694  if ( DL1r_pu != -1 && DL1r_pb != -1 && DL1r_pc != -1 )
695  DL1r = log( DL1r_pb / ( DL1r_pu * ( 1 - cFraction ) + DL1r_pc * cFraction ) );
696 
697  float bFraction = 0.03;
698  float DL1rc = 0;
699  if ( DL1r_pu != -1 && DL1r_pb != -1 && DL1r_pc != -1 )
700  DL1rc = log( DL1r_pb / ( DL1r_pu * ( 1 - bFraction ) + DL1r_pc * bFraction ) );
701 
702  ATH_CHECK( fillHistogram( chain+flavour+"DL1r_LLR",DL1r ) );
703  ATH_CHECK( fillHistogram( chain+flavour+"DL1rc",DL1rc ) );
704  ATH_CHECK( fillHistogram( chain+flavour+"DL1r_pu",DL1r_pu ) );
705  ATH_CHECK( fillHistogram( chain+flavour+"DL1r_pb",DL1r_pb ) );
706  ATH_CHECK( fillHistogram( chain+flavour+"DL1r_pc",DL1r_pc ) );
707  ATH_MSG_DEBUG( " ** DL1r = " << DL1r );
708  ATH_MSG_DEBUG( " ** DL1r [pu,pb,pc] = [" << DL1r_pu <<"," << DL1r_pb << "," << DL1r_pc << "]" );
709 
710  // MV2
711  double mv2c10_discriminant = -2;
712  bTaggingObject->MVx_discriminant( "MV2c10",mv2c10_discriminant );
713 
714  ATH_CHECK( fillHistogram( chain+flavour+"MV2c10_discriminant",mv2c10_discriminant ) );
715  ATH_MSG_DEBUG( " ** MV2c10 = " << mv2c10_discriminant );
716 
717  return StatusCode::SUCCESS;
718  }
719 
720 }
721 
722 
723 
PhysicsVariablePlots.h
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
BTaggingUtilities.h
xAOD::Vertex_v1::x
float x() const
Returns the x position.
FTAGValidation::FTAGValidationAlgorithm
Definition: FTAGValidationAlgorithm.h:19
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
BTagTrackIpAccessor.h
FTAGValidation::FTAGValidationAlgorithm::m_minJetEta
Gaudi::Property< float > m_minJetEta
Definition: FTAGValidationAlgorithm.h:50
FTAGValidation::PhysicsVariablePlots::m_jetKey
SG::ReadHandleKey< xAOD::JetContainer > m_jetKey
Definition: PhysicsVariablePlots.h:68
FTAGValidation::PhysicsVariablePlots::m_Histograms2Ddefinitions
Gaudi::Property< std::vector< std::vector< std::string > > > m_Histograms2Ddefinitions
Definition: PhysicsVariablePlots.h:80
xAOD::Vertex_v1::nTrackParticles
size_t nTrackParticles() const
Get the number of tracks associated with this vertex.
Definition: Vertex_v1.cxx:270
FTAGValidation::PhysicsVariablePlots::analyseTrackParticleObjects
StatusCode analyseTrackParticleObjects(const xAOD::Jet *, const xAOD::Vertex *, const std::string &, std::string="")
Definition: PhysicsVariablePlots.cxx:250
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:272
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
FTAGValidation::PhysicsVariablePlots::analyseBTaggingObject
StatusCode analyseBTaggingObject(const xAOD::Jet *, const std::string &, std::string="")
Definition: PhysicsVariablePlots.cxx:410
FTAGValidation::FTAGValidationAlgorithm::retrieveCollectionfromStoreGate
StatusCode retrieveCollectionfromStoreGate(const EventContext &, const CONTAINER *&, const SG::ReadHandleKey< CONTAINER > &) const
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
FTAGValidation::FTAGValidationAlgorithm::passJetQualitySelection
bool passJetQualitySelection(const xAOD::Jet *) const
Definition: FTAGValidationAlgorithm.cxx:38
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
xAOD::BTagging_v1::loglikelihoodratio
bool loglikelihoodratio(const std::string &taggername, double &value, const std::string &signal="pb", const std::string &bckgd="pu") const
Definition: BTagging_v1.cxx:322
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
CxxUtils::wrapToPi
T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
Definition: phihelper.h:24
xAOD::JetFitter_nSingleTracks
@ JetFitter_nSingleTracks
JetFitter : Number of single tracks.
Definition: BTaggingEnums.h:46
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:736
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
Trk::z0
@ z0
Definition: ParamDefs.h:70
FTAGValidation::PhysicsVariablePlots::~PhysicsVariablePlots
virtual ~PhysicsVariablePlots()
Definition: PhysicsVariablePlots.cxx:23
xAOD::SV1_N2Tpair
@ SV1_N2Tpair
SV1 : Number of 2-track pairs.
Definition: BTaggingEnums.h:35
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
FTAGValidation::PhysicsVariablePlots::initialize
virtual StatusCode initialize() override
Definition: PhysicsVariablePlots.cxx:27
xAOD::IP2D_gradeOfTracks
@ IP2D_gradeOfTracks
IP2D: track grade.
Definition: BTaggingEnums.h:65
FTAGValidation::PhysicsVariablePlots::initializeHistograms
StatusCode initializeHistograms()
Definition: PhysicsVariablePlots.cxx:179
xAOD::IP2D_pu
IP2D_pu
Definition: BTagging_v1.cxx:168
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
xAOD::numberOfBLayerSplitHits
@ numberOfBLayerSplitHits
number of Pixel b-layer hits split by cluster splitting [unit8_t].
Definition: TrackingPrimitives.h:234
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
MuonAuxContainer.h
xAOD::JetFitter_energyFraction
@ JetFitter_energyFraction
JetFitter : Jet efrac.
Definition: BTaggingEnums.h:52
xAOD::JetFitter_nVTX
@ JetFitter_nVTX
JetFitter : Number of vertices.
Definition: BTaggingEnums.h:44
BTagTrackIpAccessor
Definition: BTagTrackIpAccessor.h:29
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:262
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
BTaggingAuxContainer.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FTAGValidation
Definition: FTAGValidationAlgorithm.h:16
xAOD::BTagging_v1::pc
bool pc(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:367
P4Helpers::deltaEta
double deltaEta(const I4Momentum &p1, const I4Momentum &p2)
Computes efficiently .
Definition: P4Helpers.h:53
lumiFormat.i
int i
Definition: lumiFormat.py:92
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
FTAGValidation::PhysicsVariablePlots::m_Histograms1Ddefinitions
Gaudi::Property< std::vector< std::vector< std::string > > > m_Histograms1Ddefinitions
Definition: PhysicsVariablePlots.h:78
SG::ReadHandle::get
const_pointer_type get() const
Dereference the pointer, but don't cache anything.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::IP3D_gradeOfTracks
@ IP3D_gradeOfTracks
IP3D: track grade.
Definition: BTaggingEnums.h:82
FTAGValidation::PhysicsVariablePlots::execute
virtual StatusCode execute() override
Definition: PhysicsVariablePlots.cxx:50
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
xAOD::JetFitter_mass
@ JetFitter_mass
JetFitter : Jet mass.
Definition: BTaggingEnums.h:50
xAOD::JetFitter_nTracksAtVtx
@ JetFitter_nTracksAtVtx
JetFitter : Number of tracks at vertex.
Definition: BTaggingEnums.h:48
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
xAOD::SV1_efracsvx
@ SV1_efracsvx
SV1 : energy fraction.
Definition: BTaggingEnums.h:39
xAOD::Vertex_v1::z
float z() const
Returns the z position.
FTAGValidation::FTAGValidationAlgorithm::m_minJetPt
Gaudi::Property< float > m_minJetPt
Definition: FTAGValidationAlgorithm.h:56
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::numberOfPixelSplitHits
@ numberOfPixelSplitHits
number of Pixel all-layer hits split by cluster splitting [unit8_t].
Definition: TrackingPrimitives.h:263
FTAGValidation::PhysicsVariablePlots::computeAndStoreTrackVariables
StatusCode computeAndStoreTrackVariables(const std::string &, const xAOD::Jet *, const std::string &, const xAOD::TrackParticle *, const xAOD::Vertex *, const std::string="")
Definition: PhysicsVariablePlots.cxx:315
FTAGValidation::FTAGValidationAlgorithm::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: FTAGValidationAlgorithm.h:47
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
xAOD::BTagging_v1
Definition: BTagging_v1.h:39
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
FTAGValidation::PhysicsVariablePlots::m_vertexKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey
Definition: PhysicsVariablePlots.h:70
SG::AuxElement::auxdata
Accessor< T, ALLOC >::reference_type auxdata(const std::string &name)
Fetch an aux data variable, as a non-const reference.
xAOD::JetFitter_significance3d
@ JetFitter_significance3d
JetFitter : 3D vertex significance.
Definition: BTaggingEnums.h:54
FTAGValidation::PhysicsVariablePlots::finalize
virtual StatusCode finalize() override
Definition: PhysicsVariablePlots.cxx:172
xAOD::JetFitter_N2Tpair
@ JetFitter_N2Tpair
JetFitter : Number of 2-track pairs.
Definition: BTaggingEnums.h:60
TYPE
#define TYPE(CODE, TYP, IOTYP)
xAOD::BTagging_v1::pu
bool pu(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:353
BTaggingContainer.h
xAOD::SV1_NGTinSvx
@ SV1_NGTinSvx
SV1 : Number of good tracks in vertex.
Definition: BTaggingEnums.h:33
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
xAOD::TrackParticle_v1::definingParametersCovMatrix
const ParametersCovMatrix_t definingParametersCovMatrix() const
Returns the 5x5 symmetric matrix containing the defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:246
SG::AuxElement::isAvailable
bool isAvailable(const std::string &name, const std::string &clsname="") const
Check if an aux variable is available for reading.
xAOD::BTagging_v1::IP3D_loglikelihoodratio
float IP3D_loglikelihoodratio() const
get IP3D log likelihood ratio
Definition: BTagging_v1.h:159
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::d0
@ d0
Definition: ParamDefs.h:69
FTAGValidation::FTAGValidationAlgorithm::passJetJVTSelection
bool passJetJVTSelection(const xAOD::Jet *, const std::string &jetType="AntiKt4EMTopoJets") const
Definition: FTAGValidationAlgorithm.cxx:102
xAOD::numberOfBLayerSharedHits
@ numberOfBLayerSharedHits
number of Pixel b-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:233
phihelper.h
Helper for azimuthal angle calculations.
TauGNNUtils::Variables::Track::nSCTHits
bool nSCTHits(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:549
FTAGValidation::PhysicsVariablePlots::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Definition: PhysicsVariablePlots.h:66
xAOD::JetAttributeAccessor::accessor
const AccessorWrapper< T > * accessor(xAOD::JetAttribute::AttributeID id)
Returns an attribute accessor corresponding to an AttributeID.
Definition: JetAccessorMap.h:26
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
MuonContainer.h
xAOD::BTaggingUtilities::getBTagging
const BTagging * getBTagging(const SG::AuxElement &part)
Access the default xAOD::BTagging object associated to an object.
Definition: BTaggingUtilities.cxx:37
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
ConvertOldUJHistosToNewHistos.jetType
string jetType
Definition: ConvertOldUJHistosToNewHistos.py:121
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
FTAGValidation::PhysicsVariablePlots::m_trackKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackKey
Definition: PhysicsVariablePlots.h:72
PATH
TString PATH
Definition: run_EoverP.cxx:91
xAOD::Vertex_v1::y
float y() const
Returns the y position.
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
xAOD::BTagging_v1::variable
bool variable(const std::string &taggername, const std::string &variablename, T &value) const
get variables by string
Definition: BTagging_v1.h:297
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
FTAGValidation::PhysicsVariablePlots::PhysicsVariablePlots
PhysicsVariablePlots()
FTAGValidation::FTAGValidationAlgorithm::m_maxJetEta
Gaudi::Property< float > m_maxJetEta
Definition: FTAGValidationAlgorithm.h:53
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
FTAGValidation::FTAGValidationAlgorithm::passJetKinematicSelection
bool passJetKinematicSelection(const xAOD::Jet *) const
Definition: FTAGValidationAlgorithm.cxx:21
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
FTAGValidation::PhysicsVariablePlots::fillHistogram
StatusCode fillHistogram(const std::string &, T)
FTAGValidation::FTAGValidationAlgorithm::initialize
virtual StatusCode initialize()
Definition: FTAGValidationAlgorithm.cxx:13
FTAGValidation::FTAGValidationAlgorithm::getPrimaryVertex
const xAOD::Vertex * getPrimaryVertex(const xAOD::VertexContainer *) const
Definition: FTAGValidationAlgorithm.cxx:125
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
xAOD::EventInfo_v1::eventType
bool eventType(EventType type) const
Check for one particular bitmask value.
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
xAOD::SV1_masssvx
@ SV1_masssvx
SV1 : vertex mass.
Definition: BTaggingEnums.h:37
xAOD::BTagging_v1::MVx_discriminant
bool MVx_discriminant(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:381
xAOD::BTagging_v1::pb
bool pb(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:360
Generated on Fri Jul 5 2024 21:24:19 for ATLAS Offline Software by   doxygen 1.8.18