ATLAS Offline Software
Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
FTAGValidation::PhysicsVariablePlots Class Reference

#include <PhysicsVariablePlots.h>

Inheritance diagram for FTAGValidation::PhysicsVariablePlots:
Collaboration diagram for FTAGValidation::PhysicsVariablePlots:

Public Member Functions

 PhysicsVariablePlots (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~PhysicsVariablePlots ()
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

 PhysicsVariablePlots ()
 
StatusCode initializeHistograms ()
 
StatusCode analyseTrackParticleObjects (const xAOD::Jet *, const xAOD::Vertex *, const std::string &, std::string="")
 
StatusCode computeAndStoreTrackVariables (const std::string &, const xAOD::Jet *, const std::string &, const xAOD::TrackParticle *, const xAOD::Vertex *, const std::string="")
 
StatusCode analyseBTaggingObject (const xAOD::Jet *, const std::string &, std::string="")
 
template<typename T >
StatusCode defineHistogram (const std::string &, const std::string &, int, double, double, const std::string &path="")
 
template<typename T >
StatusCode defineHistogram (const std::string &, const std::string &, int, double, double, int, double, double, const std::string &path="")
 
template<typename T >
StatusCode fillHistogram (const std::string &, T)
 
template<typename T , typename U >
StatusCode fillHistogram (const std::string &, T, U)
 
template<class CONTAINER >
StatusCode retrieveCollectionfromStoreGate (const EventContext &, const CONTAINER *&, const SG::ReadHandleKey< CONTAINER > &) const
 
bool passJetKinematicSelection (const xAOD::Jet *) const
 
bool passTriggerJetKinematicSelection (const xAOD::Jet *) const
 
bool passJetQualitySelection (const xAOD::Jet *) const
 
bool passJetJVTSelection (const xAOD::Jet *, const std::string &jetType="AntiKt4EMTopoJets") const
 
const xAOD::Vertex * getPrimaryVertex (const xAOD::VertexContainer *) const
 
int getMatchedOfflineJetIndex (const xAOD::Jet *, std::vector< const xAOD::Jet * >) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
 
Gaudi::Property< float > m_minJetEta
 
Gaudi::Property< float > m_maxJetEta
 
Gaudi::Property< float > m_minJetPt
 
Gaudi::Property< float > m_maxTrigJetEta
 
Gaudi::Property< float > m_minTrigJetPt
 

Private Types

enum  HISTO {
  TYPE =0, NAME =1, TITLE =2, PATH =3,
  XBINS =4, XMIN =5, XMAX =6, YBINS =7,
  YMIN =8, YMAX =9
}
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ServiceHandle< ITHistSvc > m_histSvc { this, "THistSvc", "", "Histogramming svc" }
 
SG::ReadHandleKey< xAOD::JetContainer > m_jetKey
 
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackKey
 
Gaudi::Property< std::vector< std::vector< std::string > > > m_Histograms1Ddefinitions
 
Gaudi::Property< std::vector< std::vector< std::string > > > m_Histograms2Ddefinitions
 
std::map< const std::string, TH1 * > m_Histograms1D
 
std::map< const std::string, TH2 * > m_Histograms2D
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 19 of file PhysicsVariablePlots.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ HISTO

enum FTAGValidation::PhysicsVariablePlots::HISTO
private
Enumerator
TYPE 
NAME 
TITLE 
PATH 
XBINS 
XMIN 
XMAX 
YBINS 
YMIN 
YMAX 

Definition at line 76 of file PhysicsVariablePlots.h.

76 { TYPE=0,NAME=1,TITLE=2,PATH=3,XBINS=4,XMIN=5,XMAX=6,YBINS=7,YMIN=8,YMAX=9 };

Constructor & Destructor Documentation

◆ PhysicsVariablePlots() [1/2]

FTAGValidation::PhysicsVariablePlots::PhysicsVariablePlots ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 19 of file PhysicsVariablePlots.cxx.

20  :
21  FTAGValidationAlgorithm( name, pSvcLocator ) {}

◆ ~PhysicsVariablePlots()

FTAGValidation::PhysicsVariablePlots::~PhysicsVariablePlots ( )
virtual

Definition at line 23 of file PhysicsVariablePlots.cxx.

23 {}

◆ PhysicsVariablePlots() [2/2]

FTAGValidation::PhysicsVariablePlots::PhysicsVariablePlots ( )
protected

Member Function Documentation

◆ analyseBTaggingObject()

StatusCode FTAGValidation::PhysicsVariablePlots::analyseBTaggingObject ( const xAOD::Jet *  jet,
const std::string &  flavour,
std::string  chain = "" 
)
protected

Definition at line 410 of file PhysicsVariablePlots.cxx.

412  {
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  }

◆ analyseTrackParticleObjects()

StatusCode FTAGValidation::PhysicsVariablePlots::analyseTrackParticleObjects ( const xAOD::Jet *  jet,
const xAOD::Vertex *  primaryVertex,
const std::string &  flavour,
std::string  chain = "" 
)
protected

Definition at line 250 of file PhysicsVariablePlots.cxx.

253  {
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  }

◆ computeAndStoreTrackVariables()

StatusCode FTAGValidation::PhysicsVariablePlots::computeAndStoreTrackVariables ( const std::string &  jetType,
const xAOD::Jet *  jet,
const std::string &  trackType,
const xAOD::TrackParticle *  trackParticle,
const xAOD::Vertex *  primaryVertex,
const std::string  chain = "" 
)
protected

Definition at line 315 of file PhysicsVariablePlots.cxx.

317  {
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  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ defineHistogram() [1/2]

template<typename T >
StatusCode FTAGValidation::PhysicsVariablePlots::defineHistogram ( const std::string &  ,
const std::string &  ,
int  ,
double  ,
double  ,
const std::string &  path = "" 
)
protected

◆ defineHistogram() [2/2]

template<typename T >
StatusCode FTAGValidation::PhysicsVariablePlots::defineHistogram ( const std::string &  ,
const std::string &  ,
int  ,
double  ,
double  ,
int  ,
double  ,
double  ,
const std::string &  path = "" 
)
protected

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode FTAGValidation::PhysicsVariablePlots::execute ( )
overridevirtual

Reimplemented in FTAGValidation::PhysicsTriggerVariablePlots.

Definition at line 50 of file PhysicsVariablePlots.cxx.

50  {
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  }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ fillHistogram() [1/2]

template<typename T >
StatusCode FTAGValidation::PhysicsVariablePlots::fillHistogram ( const std::string &  ,
T   
)
protected

◆ fillHistogram() [2/2]

template<typename T , typename U >
StatusCode FTAGValidation::PhysicsVariablePlots::fillHistogram ( const std::string &  ,
T  ,
U   
)
protected

◆ finalize()

StatusCode FTAGValidation::PhysicsVariablePlots::finalize ( )
overridevirtual

Reimplemented in FTAGValidation::PhysicsTriggerVariablePlots.

Definition at line 172 of file PhysicsVariablePlots.cxx.

172  {
173  ATH_MSG_INFO( "Finalizing " << name() << " ..." );
174  return StatusCode::SUCCESS;
175  }

◆ getMatchedOfflineJetIndex()

int FTAGValidation::FTAGValidationAlgorithm::getMatchedOfflineJetIndex ( const xAOD::Jet *  onJet,
std::vector< const xAOD::Jet * >  offJets 
) const
protectedinherited

Definition at line 143 of file FTAGValidationAlgorithm.cxx.

143  {
144  int matchedOffJetIndex = -1;
145  double minDr = 0;
146 
147  TLorentzVector onJet_4vec, offJet_4vec;
148  onJet_4vec.SetPtEtaPhiM(onJet->pt(), onJet->eta(), onJet->phi(), onJet->m());
149 
150  for ( unsigned int index=0; index<offJets.size(); index++ ) {
151  const xAOD::Jet *offJet = offJets.at( index );
152 
153  offJet_4vec.SetPtEtaPhiM(offJet->pt(), offJet->eta(), offJet->phi(), offJet->m());
154  double deltaR = onJet_4vec.DeltaR( offJet_4vec );
155  ATH_MSG_DEBUG("deltaR: " << deltaR );
156 
157  if ( deltaR > 0.1 ) continue;
158  if ( deltaR < minDr || matchedOffJetIndex == -1 ) {
159  minDr = deltaR;
160  matchedOffJetIndex = index;
161  }
162  }
163  ATH_MSG_DEBUG("minDr: " << minDr );
164  ATH_MSG_DEBUG("matchedOffJetIndex: " << matchedOffJetIndex );
165  return matchedOffJetIndex;
166  }

◆ getPrimaryVertex()

const xAOD::Vertex * FTAGValidation::FTAGValidationAlgorithm::getPrimaryVertex ( const xAOD::VertexContainer *  vertexContainer) const
protectedinherited

Definition at line 125 of file FTAGValidationAlgorithm.cxx.

125  {
126 
127  if ( vertexContainer->size() == 0 ) {
128  ATH_MSG_WARNING( "Vertex Container has size 0! This can't be right!" );
129  return nullptr;
130  }
131 
132  for ( unsigned int i(0); i<vertexContainer->size(); i++ ) {
133  const xAOD::Vertex *vertex = vertexContainer->at(i);
134  if ( vertex->vertexType() != xAOD::VxType::VertexType::PriVtx ) continue;
135  return vertex;
136  }
137 
138  ATH_MSG_DEBUG( "None of the vertexes in the vertex container is a primary vertex!" );
139  ATH_MSG_DEBUG( "Using Dummy Vertex." );
140  return vertexContainer->at(0);
141  }

◆ initialize()

StatusCode FTAGValidation::PhysicsVariablePlots::initialize ( )
overridevirtual

Reimplemented from FTAGValidation::FTAGValidationAlgorithm.

Reimplemented in FTAGValidation::PhysicsTriggerVariablePlots.

Definition at line 27 of file PhysicsVariablePlots.cxx.

27  {
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  }

◆ initializeHistograms()

StatusCode FTAGValidation::PhysicsVariablePlots::initializeHistograms ( )
protected

Definition at line 179 of file PhysicsVariablePlots.cxx.

179  {
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  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ passJetJVTSelection()

bool FTAGValidation::FTAGValidationAlgorithm::passJetJVTSelection ( const xAOD::Jet *  jet,
const std::string &  jetType = "AntiKt4EMTopoJets" 
) const
protectedinherited

Definition at line 102 of file FTAGValidationAlgorithm.cxx.

103  {
104 
105  if ( jet->isAvailable< float >( "Jvt" ) == false ) {
106  ATH_MSG_ERROR( "Jet auxdata 'Jvt' is not available." );
107  return false;
108  }
109 
110  float jvt = jet->auxdata< float >( "Jvt" );
111  double jvtCut = 0.59;
112  if ( jetType == "AntiKt4EMPFlowJets" )
113  jvtCut = 0.2;
114 
115  if ( jet->pt() / Gaudi::Units::GeV >= 60. )
116  return true;
117  if ( fabs( jet->eta() ) >= 2.4 )
118  return true;
119  if ( jvt > jvtCut )
120  return true;
121 
122  return false;
123  }

◆ passJetKinematicSelection()

bool FTAGValidation::FTAGValidationAlgorithm::passJetKinematicSelection ( const xAOD::Jet *  jet) const
protectedinherited

Definition at line 21 of file FTAGValidationAlgorithm.cxx.

21  {
22 
23  if ( jet->p4().Et() / Gaudi::Units::GeV < m_minJetPt ) return false;
24  if ( std::fabs( jet->eta() ) < m_minJetEta ) return false;
25  if ( std::fabs( jet->eta() ) > m_maxJetEta ) return false;
26 
27  return true;
28  }

◆ passJetQualitySelection()

bool FTAGValidation::FTAGValidationAlgorithm::passJetQualitySelection ( const xAOD::Jet *  jet) const
protectedinherited

Definition at line 38 of file FTAGValidationAlgorithm.cxx.

38  {
39 
40  // This part is inspired from 'PhysicsAnalysis/JetTagging/JetTagMonitoring/src/JetTagMonitorAlgorithm.cxx'
41 
42  float jetQuality = 0;
43  if ( !jet->getAttribute(xAOD::JetAttribute::LArQuality,jetQuality) ) {
44  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::LArQuality' is not available." );
45  return false;
46  }
47 
48  float jetTime = 0;
49  if ( !jet->getAttribute(xAOD::JetAttribute::Timing,jetTime) ) {
50  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::Timing' is not available." );
51  return false;
52  }
53 
54  float hecq = 0;
55  if ( !jet->getAttribute(xAOD::JetAttribute::HECQuality,hecq) ) {
56  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::HECQuality' is not available." );
57  return false;
58  }
59 
60  float negE = 0;
61  if ( !jet->getAttribute(xAOD::JetAttribute::NegativeE,negE) ) {
62  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::NegativeE' is not available." );
63  return false;
64  }
65 
66  std::vector< float > SumPtTrkPt1000;
67  if ( !jet->getAttribute(xAOD::JetAttribute::SumPtTrkPt1000,SumPtTrkPt1000) ) {
68  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::SumPtTrkPt1000' is not available." );
69  return false;
70  }
71  float chf = SumPtTrkPt1000.size() > 0 ? SumPtTrkPt1000.at(0)/jet->pt() : -1;
72 
73  float emf = 0;
74  if ( !jet->getAttribute(xAOD::JetAttribute::EMFrac,emf) ) {
75  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::EMFrac' is not available." );
76  return false;
77  }
78 
79  float hecf = 0;
80  if ( !jet->getAttribute(xAOD::JetAttribute::HECFrac,hecf) ) {
81  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::HECFrac' is not available." );
82  return false;
83  }
84 
85  float fracSamplingMax = 0;
86  if ( !jet->getAttribute(xAOD::JetAttribute::FracSamplingMax,fracSamplingMax) ) {
87  ATH_MSG_ERROR( "JetAttribute 'xAOD::JetAttribute::FracSamplingMax' is not available." );
88  return false;
89  }
90 
91  if ( hecf > 0.5 && fabs( hecq ) > 0.5 ) return false;
92  if ( fabs( negE ) > 60*Gaudi::Units::GeV ) return false;
93  if ( emf > 0.95 && fabs( jetQuality ) > 0.8 && fabs( jet->eta() ) < 2.8 ) return false;
94  if ( fabs( jetTime ) > 25 ) return false;
95  if ( emf < 0.05 && chf < 0.05 && fabs( jet->eta() ) < 2 ) return false;
96  if ( emf< 0.05 && fabs( jet->eta() ) >= 2 ) return false;
97  if ( fracSamplingMax > 0.99 && fabs( jet->eta() ) < 2 ) return false;
98 
99  return true;
100  }

◆ passTriggerJetKinematicSelection()

bool FTAGValidation::FTAGValidationAlgorithm::passTriggerJetKinematicSelection ( const xAOD::Jet *  jet) const
protectedinherited

Definition at line 30 of file FTAGValidationAlgorithm.cxx.

30  {
31 
32  if ( jet->p4().Et() / Gaudi::Units::GeV < m_minTrigJetPt ) return false;
33  if ( std::fabs( jet->eta() ) > m_maxTrigJetEta ) return false;
34 
35  return true;
36  }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrieveCollectionfromStoreGate()

template<class CONTAINER >
StatusCode FTAGValidation::FTAGValidationAlgorithm::retrieveCollectionfromStoreGate ( const EventContext &  ,
const CONTAINER *&  ,
const SG::ReadHandleKey< CONTAINER > &   
) const
protectedinherited

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_eventInfoKey

SG::ReadHandleKey< xAOD::EventInfo > FTAGValidation::FTAGValidationAlgorithm::m_eventInfoKey
protectedinherited
Initial value:
{ this,"EventInfoKey","EventInfo",
"Key to read EventInfo."}

Definition at line 47 of file FTAGValidationAlgorithm.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_Histograms1D

std::map< const std::string,TH1* > FTAGValidation::PhysicsVariablePlots::m_Histograms1D
private

Definition at line 83 of file PhysicsVariablePlots.h.

◆ m_Histograms1Ddefinitions

Gaudi::Property< std::vector< std::vector< std::string > > > FTAGValidation::PhysicsVariablePlots::m_Histograms1Ddefinitions
private
Initial value:
{ this,"Histograms1D",{},
"Map with 1D histograms" }

Definition at line 78 of file PhysicsVariablePlots.h.

◆ m_Histograms2D

std::map< const std::string,TH2* > FTAGValidation::PhysicsVariablePlots::m_Histograms2D
private

Definition at line 84 of file PhysicsVariablePlots.h.

◆ m_Histograms2Ddefinitions

Gaudi::Property< std::vector< std::vector< std::string > > > FTAGValidation::PhysicsVariablePlots::m_Histograms2Ddefinitions
private
Initial value:
{ this,"Histograms2D",{},
"Map with 1D histograms" }

Definition at line 80 of file PhysicsVariablePlots.h.

◆ m_histSvc

ServiceHandle< ITHistSvc > FTAGValidation::PhysicsVariablePlots::m_histSvc { this, "THistSvc", "", "Histogramming svc" }
private

Definition at line 66 of file PhysicsVariablePlots.h.

◆ m_jetKey

SG::ReadHandleKey< xAOD::JetContainer > FTAGValidation::PhysicsVariablePlots::m_jetKey
private
Initial value:
{ this, "JetCollectionKey", "",
"Input Jet collection name" }

Definition at line 68 of file PhysicsVariablePlots.h.

◆ m_maxJetEta

Gaudi::Property< float > FTAGValidation::FTAGValidationAlgorithm::m_maxJetEta
protectedinherited
Initial value:
{ this,"MaxJetEta",2.5,
"Maximum Eta range for jets"}

Definition at line 53 of file FTAGValidationAlgorithm.h.

◆ m_maxTrigJetEta

Gaudi::Property< float > FTAGValidation::FTAGValidationAlgorithm::m_maxTrigJetEta
protectedinherited
Initial value:
{ this,"MaxTrigJetEta",2.5,
"Maximum Trigger Eta range for jets"}

Definition at line 59 of file FTAGValidationAlgorithm.h.

◆ m_minJetEta

Gaudi::Property< float > FTAGValidation::FTAGValidationAlgorithm::m_minJetEta
protectedinherited
Initial value:
{ this,"MinJetEta",0.,
"Minimum Eta range for jets"}

Definition at line 50 of file FTAGValidationAlgorithm.h.

◆ m_minJetPt

Gaudi::Property< float > FTAGValidation::FTAGValidationAlgorithm::m_minJetPt
protectedinherited
Initial value:
{ this,"MinJetPt", 20.,
"Minimum Jet Pt [GeV]" }

Definition at line 56 of file FTAGValidationAlgorithm.h.

◆ m_minTrigJetPt

Gaudi::Property< float > FTAGValidation::FTAGValidationAlgorithm::m_minTrigJetPt
protectedinherited
Initial value:
{ this,"MinTrigJetPt", 20.,
"Minimum Trigger Jet Pt [GeV]" }

Definition at line 62 of file FTAGValidationAlgorithm.h.

◆ m_trackKey

SG::ReadHandleKey< xAOD::TrackParticleContainer > FTAGValidation::PhysicsVariablePlots::m_trackKey
private
Initial value:
{ this, "TrackParticleCollectionKey", "",
"Input Track collection name" }

Definition at line 72 of file PhysicsVariablePlots.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertexKey

SG::ReadHandleKey< xAOD::VertexContainer > FTAGValidation::PhysicsVariablePlots::m_vertexKey
private
Initial value:
{ this, "VertexCollectionKey", "",
"Input Vertex collection name" }

Definition at line 70 of file PhysicsVariablePlots.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
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
xAOD::Vertex_v1::x
float x() const
Returns the x position.
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:195
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
xAOD::JetAttribute::LArQuality
@ LArQuality
Definition: JetAttributes.h:83
FTAGValidation::FTAGValidationAlgorithm::m_minTrigJetPt
Gaudi::Property< float > m_minTrigJetPt
Definition: FTAGValidationAlgorithm.h:62
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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
xAOD::JetAttribute::FracSamplingMax
@ FracSamplingMax
Definition: JetAttributes.h:116
FTAGValidation::PhysicsVariablePlots::YMIN
@ YMIN
Definition: PhysicsVariablePlots.h:76
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::PhysicsVariablePlots::YBINS
@ YBINS
Definition: PhysicsVariablePlots.h:76
FTAGValidation::FTAGValidationAlgorithm::retrieveCollectionfromStoreGate
StatusCode retrieveCollectionfromStoreGate(const EventContext &, const CONTAINER *&, const SG::ReadHandleKey< CONTAINER > &) const
FTAGValidation::FTAGValidationAlgorithm::FTAGValidationAlgorithm
FTAGValidationAlgorithm()
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
FTAGValidation::FTAGValidationAlgorithm::passJetQualitySelection
bool passJetQualitySelection(const xAOD::Jet *) const
Definition: FTAGValidationAlgorithm.cxx:38
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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.
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
Trk::z0
@ z0
Definition: ParamDefs.h:70
xAOD::Jet_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: Jet_v1.cxx:54
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
xAOD::IP2D_gradeOfTracks
@ IP2D_gradeOfTracks
IP2D: track grade.
Definition: BTaggingEnums.h:65
FTAGValidation::PhysicsVariablePlots::initializeHistograms
StatusCode initializeHistograms()
Definition: PhysicsVariablePlots.cxx:179
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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.
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
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::JetAttribute::HECQuality
@ HECQuality
Definition: JetAttributes.h:80
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
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::BTagging_v1::pc
bool pc(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:367
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
P4Helpers::deltaEta
double deltaEta(const I4Momentum &p1, const I4Momentum &p2)
Computes efficiently .
Definition: P4Helpers.h:53
FTAGValidation::PhysicsVariablePlots::XMIN
@ XMIN
Definition: PhysicsVariablePlots.h:76
lumiFormat.i
int i
Definition: lumiFormat.py:92
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
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
xAOD::JetAttribute::SumPtTrkPt1000
@ SumPtTrkPt1000
Definition: JetAttributes.h:107
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:571
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
FTAGValidation::FTAGValidationAlgorithm::m_maxTrigJetEta
Gaudi::Property< float > m_maxTrigJetEta
Definition: FTAGValidationAlgorithm.h:59
xAOD::JetAttribute::Timing
@ Timing
Definition: JetAttributes.h:90
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
FTAGValidation::PhysicsVariablePlots::NAME
@ NAME
Definition: PhysicsVariablePlots.h:76
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
xAOD::Jet_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: Jet_v1.cxx:49
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
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::JetFitter_N2Tpair
@ JetFitter_N2Tpair
JetFitter : Number of 2-track pairs.
Definition: BTaggingEnums.h:60
FTAGValidation::PhysicsVariablePlots::XBINS
@ XBINS
Definition: PhysicsVariablePlots.h:76
TYPE
#define TYPE(CODE, TYP, IOTYP)
xAOD::BTagging_v1::pu
bool pu(const std::string &taggername, double &value) const
Definition: BTagging_v1.cxx:353
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.
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
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
TauGNNUtils::Variables::Track::nSCTHits
bool nSCTHits(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:549
FTAGValidation::PhysicsVariablePlots::YMAX
@ YMAX
Definition: PhysicsVariablePlots.h:76
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
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
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DeMoScan.index
string index
Definition: DeMoScan.py:362
ConvertOldUJHistosToNewHistos.jetType
string jetType
Definition: ConvertOldUJHistosToNewHistos.py:121
xAOD::Jet_v1::m
virtual double m() const
The invariant mass of the particle.
Definition: Jet_v1.cxx:59
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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
FTAGValidation::PhysicsVariablePlots::TYPE
@ TYPE
Definition: PhysicsVariablePlots.h:76
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
FTAGValidation::PhysicsVariablePlots::XMAX
@ XMAX
Definition: PhysicsVariablePlots.h:76
FTAGValidation::PhysicsVariablePlots::TITLE
@ TITLE
Definition: PhysicsVariablePlots.h:76
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
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
xAOD::JetAttribute::HECFrac
@ HECFrac
Definition: JetAttributes.h:113
Trk::jet_phi
@ jet_phi
Definition: JetVtxParamDefs.h:28
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
FTAGValidation::PhysicsVariablePlots::PATH
@ PATH
Definition: PhysicsVariablePlots.h:76
FTAGValidation::FTAGValidationAlgorithm::m_maxJetEta
Gaudi::Property< float > m_maxJetEta
Definition: FTAGValidationAlgorithm.h:53
xAOD::Jet_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
Definition: Jet_v1.cxx:44
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.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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::JetAttribute::NegativeE
@ NegativeE
Definition: JetAttributes.h:84
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
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
ServiceHandle< ICondSvc >
Generated on Fri Jul 5 2024 22:16:28 for ATLAS Offline Software by   doxygen 1.8.18