InDet::JetFitterV0FinderTool Class Reference

#include <JetFitterV0FinderTool.h>

Inheritance diagram for InDet::JetFitterV0FinderTool:

Collaboration diagram for InDet::JetFitterV0FinderTool:

Public Member Functions
StatusCode	initialize ()
StatusCode	finalize ()
	JetFitterV0FinderTool (const std::string &t, const std::string &n, const IInterface *p)
	~JetFitterV0FinderTool ()
const Trk::TwoTrackVerticesInJet *	doV0Finding (const xAOD::Vertex &, const TLorentzVector &, std::vector< const Trk::ITrackLink * > &, const std::vector< const xAOD::Vertex * > &, std::vector< const Trk::ITrackLink * > &, std::vector< const Trk::ITrackLink * > &, Amg::Vector3D &) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< const xAOD::Vertex * >	findV0candidates (const xAOD::Vertex &, const TLorentzVector &, std::vector< const Trk::ITrackLink * > &, const std::vector< const xAOD::Vertex * > &) const
bool	checkCriteriaFirstFit (const xAOD::Vertex &, const TLorentzVector &, const xAOD::Vertex &) const
bool	checkCriteriaSecondFit (const xAOD::Vertex &, const Trk::ITrackLink *) const
Amg::Vector3D	computeSeedDirection (const xAOD::Vertex &, const TLorentzVector &, const std::vector< Trk::PositionAndWeight > &) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< InDet::InDetJetFitterUtils >	m_jetFitterUtils {this,"InDetJetFitterUtils","InDet::InDetJetFitterUtils/InDetJetFitterUtils",""}
ToolHandle< Trk::IMode3dFinder >	m_mode3dfinder {this,"Mode3dFinder","Trk::Mode3dTo1dFinder/Mode3dTo1dFinder",""}
SG::AuxElement::Accessor< float >	m_compatibilityAccessor
SG::AuxElement::Accessor< std::vector< const Trk::ITrackLink * > >	m_tracksAccessor
Gaudi::Property< bool >	m_revertFromPositiveToNegativeTags {this,"revertFromPositiveToNegativeTags",false,""}
Gaudi::Property< double >	m_cutTwoTrkVtxVertexProbForBFirstSelectionFirstCriterium {this,"cutTwoTrkVtxVtxProbForBFirstSelectCriteriumA",0.05,""}
Gaudi::Property< double >	m_cutTwoTrkVtxVertexProbForBFirstSelectionSecondCriterium {this,"cutTwoTrkVtxVtxProbForBFirstSelectCriteriumB",0.034,""}
Gaudi::Property< double >	m_cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection {this,"cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection",1e-1,""}
Gaudi::Property< double >	m_cutCompatibilityPrimaryVertexBothTracksForBFirstSelection {this,"cutCompatibilityPrimaryVertexBothTracksForBFirstSelection",1e-2,""}
Gaudi::Property< double >	m_cutIPD0BothTracksForBFirstSelection {this,"cutIPD0BothTracksForBFirstSelection",3.5,""}
Gaudi::Property< double >	m_cutIPZ0BothTracksForBFirstSelection {this,"cutIPZ0BothTracksForBFirstSelection",5.,""}
Gaudi::Property< double >	m_cutPtBothTracksForBFirstSelection {this,"cutPtBothTracksForBFirstSelection",500.,""}
Gaudi::Property< double >	m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionFirstCriterium {this,"cutTwoTrkVtxLifeSignForBFirstSelectCriteriumA",1.,""}
Gaudi::Property< double >	m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionSecondCriterium {this,"cutTwoTrkVtxLifeSignForBFirstSelectCriteriumB",1.5,""}
Gaudi::Property< double >	m_cutCompatibilityToPrimarySingleTrackForMatInteractions {this,"cutCompToPrimarySingleTrackForMatInterac",1e-4,""}
Gaudi::Property< double >	m_cutCompatibilityToPrimaryBothTracksForMatInteractions {this,"cutCompToPrimaryBothTracksForMatInterac",1e-6,""}
Gaudi::Property< double >	m_firstLayer_min {this,"firstLayer_min",34.0-2.5,""}
Gaudi::Property< double >	m_firstLayer_max {this,"firstLayer_max",34.0+2.5,""}
Gaudi::Property< double >	m_secondLayer_min {this,"secondLayer_min",51.5-3,""}
Gaudi::Property< double >	m_secondLayer_max {this,"secondLayer_max",51.5+3,""}
Gaudi::Property< double >	m_cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection {this,"cutCompPVSinglePosLifeTrackForBSecondSelect",5e-2,""}
Gaudi::Property< double >	m_cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection {this,"cutCompPVSingleNegLifeTrackForBSecondSelect",1e-2,""}
Gaudi::Property< double >	m_cutIPD0SigBoxSingleTrackForBSecondSelection {this,"cutIPD0SigBoxSingleTrackForBSecondSelection",2.,""}
Gaudi::Property< double >	m_cutIPZ0SigBoxSingleTrackForBSecondSelection {this,"cutIPZ0SigBoxSingleTrackForBSecondSelection",5.,""}
Gaudi::Property< double >	m_cutIPD0SingleTrackForBSecondSelection {this,"cutIPD0SingleTrackForBSecondSelection",1.5,""}
Gaudi::Property< double >	m_cutIPZ0SingleTrackForBSecondSelection {this,"cutIPZ0SingleTrackForBSecondSelection",3.,""}
Gaudi::Property< double >	m_cutPtSingleTrackForBSecondSelection {this,"cutPtSingleTrackForBSecondSelection",750,""}
Gaudi::Property< bool >	m_useITkMaterialRejection {this,"useITkMaterialRejection",false,"Reject vertices from hadronic interactions in detector material using ITk layout"}
const BeamPipeDetectorManager *	m_beamPipeMgr = nullptr
const InDetDD::PixelDetectorManager *	m_pixelManager = nullptr
std::unique_ptr< TH2D >	m_ITkPixMaterialMap
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 29 of file JetFitterV0FinderTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

JetFitterV0FinderTool()

JetFitterV0FinderTool::JetFitterV0FinderTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 15 of file JetFitterV0FinderTool.cxx.

  : AthAlgTool(t, n, p),
    m_compatibilityAccessor( "TrackCompatibility" ),
    m_tracksAccessor( "VxTrackAtVertex" )
{
  
  declareInterface< JetFitterV0FinderTool >(this);
  
  std::string toolname = this->name();
  std::string delimiter = "_";
  std::string::size_type firstDelimiter = toolname.find(delimiter);
  std::string sub = toolname.substr(0, firstDelimiter);
  std::string decoratorName = std::string("JetFitter_TrackCompatibility_") + sub;
  m_compatibilityAccessor = SG::AuxElement::Accessor< float >( decoratorName );
  
}

~JetFitterV0FinderTool()

JetFitterV0FinderTool::~JetFitterV0FinderTool ( )

default

Member Function Documentation

checkCriteriaFirstFit()

bool JetFitterV0FinderTool::checkCriteriaFirstFit ( const xAOD::Vertex & primaryVertex, const TLorentzVector & jetMomentum, const xAOD::Vertex & v0candidate ) const

private

Definition at line 177 of file JetFitterV0FinderTool.cxx.

                                                                 {
 
 
  // Check vertex probability
  double vertexProb = TMath::Prob( v0candidate.chiSquared(),
                   v0candidate.numberDoF() );
 
  if ( ( vertexProb < m_cutTwoTrkVtxVertexProbForBFirstSelectionFirstCriterium ) &&
       ( vertexProb < m_cutTwoTrkVtxVertexProbForBFirstSelectionSecondCriterium ) ) {
    ATH_MSG_DEBUG( "V0 candidate does not satisfy the vertex prob criteria!"  );
    return false; 
  }
  
 
 
  // Retrieve and prepare objects
  const std::vector< const Trk::ITrackLink* > vxTrackAtVertex = m_tracksAccessor( v0candidate );
  const Trk::ITrackLink* trackLink1 = vxTrackAtVertex.at( 0 ); 
  const Trk::ITrackLink* trackLink2 = vxTrackAtVertex.at( 1 );
  
  if ( trackLink1 == nullptr || trackLink2 == nullptr ) {
    ATH_MSG_DEBUG( "Zero pointer (ITrackLink): skipping 2-track candidate" );
    return false;
  }
 
  const Trk::LinkToXAODTrackParticle* linkTrackA = dynamic_cast< const Trk::LinkToXAODTrackParticle* >( trackLink1 );
  const Trk::LinkToXAODTrackParticle* linkTrackB = dynamic_cast< const Trk::LinkToXAODTrackParticle* >( trackLink2 );
 
  if ( !linkTrackA || !linkTrackB ) {
    ATH_MSG_DEBUG( "Zero pointer (LinkToXAODTrackParticle): skipping 2-track candidate" );
    return false;
  }
 
 
  // TO-DO
  // remove track candidates that are supposed to be voted !
 
 
 
 
  // Take track compatibility and compute flight significance
  // compatibility is attached to tracks, so we need to retrieve xAOD::TrackParticles objects
  float compatibiltyTrackA = m_compatibilityAccessor( ***linkTrackA );
  float compatibiltyTrackB = m_compatibilityAccessor( ***linkTrackB );
  
  if ( TMath::Prob( fabs(compatibiltyTrackA),2 ) >= m_cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection ) return false;
  if ( TMath::Prob( fabs(compatibiltyTrackB),2 ) >= m_cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection ) return false;
  if ( TMath::Prob( fabs(compatibiltyTrackA) + fabs(compatibiltyTrackB),4 ) >= m_cutCompatibilityPrimaryVertexBothTracksForBFirstSelection ) return false;
 
 
  // Criteria on D0 and Z0 of the tracks w.r.t. primary vertex
  const Trk::TrackParameters* initialPerigee1 = linkTrackA->parameters();
  const Trk::TrackParameters* initialPerigee2 = linkTrackB->parameters();
 
  if ( !initialPerigee1 || !initialPerigee2 ) {
    ATH_MSG_DEBUG( "No refitted parameters available for 2-track vertex. Candidate not accepted..." );
    return false;
  }
 
  if ( initialPerigee1->momentum().perp() <= m_cutPtBothTracksForBFirstSelection ) return false;
  if ( initialPerigee2->momentum().perp() <= m_cutPtBothTracksForBFirstSelection ) return false;
 
 
 
 
  // Need to create Trk::RecVertex object. Is this really necessary?
  Trk::RecVertex primaryVertexRecVertex( primaryVertex.position(),
                     primaryVertex.covariancePosition(),
                     primaryVertex.numberDoF(),
                     primaryVertex.chiSquared());
 
  std::pair<double,double> track1_IPd0z0 = m_jetFitterUtils->getD0andZ0IP( *initialPerigee1,
                                       primaryVertexRecVertex );
  
  std::pair<double,double> track2_IPd0z0 = m_jetFitterUtils->getD0andZ0IP(*initialPerigee2,
                                      primaryVertexRecVertex);
 
 
 
  ATH_MSG_DEBUG( "Checking good quality for track A..." );
  if ( fabs( track1_IPd0z0.first ) >= m_cutIPD0BothTracksForBFirstSelection ) return false;
  if ( fabs( track1_IPd0z0.second ) >= m_cutIPZ0BothTracksForBFirstSelection ) return false;
 
  ATH_MSG_DEBUG( "Checking good quality for track B..." );
  if ( fabs( track2_IPd0z0.first ) >= m_cutIPD0BothTracksForBFirstSelection ) return false;
  if ( fabs( track2_IPd0z0.second ) >= m_cutIPZ0BothTracksForBFirstSelection ) return false;
 
 
 
  
  
  ATH_MSG_DEBUG( "Checking distance and error between two vertices..." );
  std::pair<double,double> distanceAndError = m_jetFitterUtils->getDistanceAndErrorBetweenTwoVertices( v0candidate,primaryVertexRecVertex );
 
  Amg::Vector3D jetMomSpatial( jetMomentum.X(), jetMomentum.Y(), jetMomentum.Z() );
  double sign = ( v0candidate.position() - primaryVertexRecVertex.position() ).dot( jetMomSpatial ); 
 
  double signedDistance = distanceAndError.first;
  if ( sign < 0 ) signedDistance = -signedDistance;
  double significance = signedDistance/distanceAndError.second;
 
  double FirstSelectionFirstCriterium = m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionFirstCriterium;
  double FirstSelectionSecondCriterium = m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionSecondCriterium;
 
  if ( m_revertFromPositiveToNegativeTags ) {
    FirstSelectionFirstCriterium = -FirstSelectionFirstCriterium;
    FirstSelectionSecondCriterium = -FirstSelectionSecondCriterium;
  }
  
  bool firstCriterium = ( vertexProb > m_cutTwoTrkVtxVertexProbForBFirstSelectionFirstCriterium  ) &&
    ( significance > FirstSelectionFirstCriterium );
  bool secondCriterium = ( vertexProb > m_cutTwoTrkVtxVertexProbForBFirstSelectionSecondCriterium ) &&
    ( significance > FirstSelectionSecondCriterium );
 
  if ( not ( firstCriterium || secondCriterium ) ) 
    return false;
 
 
 
 
  ATH_MSG_DEBUG( "Checking material interaction in layer..." );
  double radius = v0candidate.position().perp();
  double z = v0candidate.position().z();
  bool matinteraction = false;
 
  if(m_useITkMaterialRejection){
    int bin = m_ITkPixMaterialMap->FindBin(z,radius);
    if(m_ITkPixMaterialMap->GetBinContent(bin)>0) matinteraction = true;
  }
 
  else{
    if ( (radius>m_firstLayer_min && radius<m_firstLayer_max)
     || (radius>m_secondLayer_min && radius<m_secondLayer_max) )
      matinteraction = true;
  }
 
  if ( matinteraction ) {
    bool signifCutTight = ( TMath::Prob( fabs( compatibiltyTrackA ),2 ) < m_cutCompatibilityToPrimarySingleTrackForMatInteractions ) &&
      ( TMath::Prob( fabs( compatibiltyTrackB ),2 ) < m_cutCompatibilityToPrimarySingleTrackForMatInteractions ) &&
      ( TMath::Prob( fabs( compatibiltyTrackA ) + fabs( compatibiltyTrackB ),4 ) < m_cutCompatibilityToPrimaryBothTracksForMatInteractions );
    
    if ( signifCutTight ) return false;
  }  
 
 
 
  // TO-DO
  // Remove candidates with track overlaps
 
 
 
  return true;
} 

checkCriteriaSecondFit()

bool JetFitterV0FinderTool::checkCriteriaSecondFit ( const xAOD::Vertex & primaryVertex, const Trk::ITrackLink * trackLink ) const

private

Definition at line 334 of file JetFitterV0FinderTool.cxx.

                                                                   {
 
  const Trk::LinkToXAODTrackParticle* linkTrack = dynamic_cast< const Trk::LinkToXAODTrackParticle* >( trackLink );
  if ( linkTrack == nullptr ) {
    ATH_MSG_DEBUG( "Zero pointer (LinkToXAODTrackParticle): skipping 2-track candidate" );
    return false;
  }
  
  float compatibilityTrack = m_compatibilityAccessor( ***linkTrack );
  
  
  const Trk::TrackParameters* perigee = trackLink->parameters();
  const AmgSymMatrix(5) *measPerigee = perigee->covariance();
  
  if ( measPerigee == nullptr ) {
    ATH_MSG_DEBUG( "Track parameters have no covariance. skipping single track candidate..." );
    return false;
  }
  
  // Need to create Trk::RecVertex object. Is this really necessary?
  Trk::RecVertex primaryVertexRecVertex( primaryVertex.position(),
                     primaryVertex.covariancePosition(),
                     primaryVertex.numberDoF(),
                     primaryVertex.chiSquared());
  
  std::pair<double,double> track_IPd0z0 = m_jetFitterUtils->getD0andZ0IP( *perigee,
                                      primaryVertexRecVertex );
  std::pair<double,double> track_IPd0z0Sig = m_jetFitterUtils->getD0andZ0IPSig( *perigee,
                                        primaryVertexRecVertex );
  
  const double IPd0    = track_IPd0z0.first;                                                                                                       
  const double IPz0    = track_IPd0z0.second;                                                                                                      
  const double IPd0Sig = track_IPd0z0Sig.first;                                                                                                 
  const double IPz0Sig = track_IPd0z0Sig.second;                                                                                                
  const double pT      = perigee->momentum().perp();                                                                                                   
  
  double cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection = m_cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection;
  double cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection = m_cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection;
  
  if ( m_revertFromPositiveToNegativeTags ) {
    cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection = m_cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection;
    cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection = m_cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection;
  }                                                                                                                                             
  
  bool passBoxCut = ( fabs(IPd0Sig) < m_cutIPD0SigBoxSingleTrackForBSecondSelection ) && 
    ( fabs(IPz0Sig) > m_cutIPZ0SigBoxSingleTrackForBSecondSelection );
  
  
  if ( fabs(IPd0) > m_cutIPD0SingleTrackForBSecondSelection ||
       fabs(IPz0) > m_cutIPZ0SingleTrackForBSecondSelection ||
       ( compatibilityTrack >= 0 && TMath::Prob( fabs(compatibilityTrack),2) > cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection ) ||
       ( compatibilityTrack < 0 && TMath::Prob( fabs(compatibilityTrack),2) > cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection ) ||
       pT < m_cutPtSingleTrackForBSecondSelection || passBoxCut )
    {
      ATH_MSG_DEBUG( "Candidate didn't pass one of the selection cuts" );
      return false;
    }
  
  return true;
}

computeSeedDirection()

Amg::Vector3D JetFitterV0FinderTool::computeSeedDirection ( const xAOD::Vertex & primaryVertex, const TLorentzVector & jetMomentum, const std::vector< Trk::PositionAndWeight > & positionsOfSeedingVertices ) const

private

Definition at line 396 of file JetFitterV0FinderTool.cxx.

                                                                                                           {
 
  Amg::Vector3D JFseedDirection( jetMomentum.X(),jetMomentum.Y(),jetMomentum.Z() );
  JFseedDirection.normalize();
  ATH_MSG_VERBOSE( "Jet Direction would be: " << JFseedDirection );
 
  if ( positionsOfSeedingVertices.empty() )
    return JFseedDirection;
 
  Amg::Vector3D theSeedVertex = m_mode3dfinder->getMode( primaryVertex.x(),primaryVertex.y(),positionsOfSeedingVertices );
    double sign = ( theSeedVertex - primaryVertex.position() ).dot( JFseedDirection );
 
  if ( m_revertFromPositiveToNegativeTags == false ) {
 
    if ( sign > 0 ) {
      JFseedDirection = ( theSeedVertex - primaryVertex.position() ).unit();
      ATH_MSG_DEBUG( "Using twotrkvtx direction for start: " << JFseedDirection );
    } else ATH_MSG_DEBUG( "NORMAL SEEDING: Seed vertex is on negative side... Using Jet Direction!" );
 
  } else {
 
    if ( sign < 0 ) {
      JFseedDirection = -( theSeedVertex - primaryVertex.position() ).unit();
      ATH_MSG_DEBUG( "Using twotrkvtx direction for start: " << JFseedDirection );
    } else ATH_MSG_DEBUG( "REVERSE SEEDING: Seed vertex is on positive side... Using Jet Direction!" );
 
  }
 
  return JFseedDirection;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

doV0Finding()

const Trk::TwoTrackVerticesInJet * JetFitterV0FinderTool::doV0Finding	(	const xAOD::Vertex &	primaryVertex,
		const TLorentzVector &	jetMomentum,
		std::vector< const Trk::ITrackLink * > &	inputTracks,
		const std::vector< const xAOD::Vertex * > &	vertexCandidates,
		std::vector< const Trk::ITrackLink * > &	tracksToUseInFirstFit,
		std::vector< const Trk::ITrackLink * > &	tracksToUseInSecondFit,
		Amg::Vector3D &	JFseedDirection ) const

Definition at line 65 of file JetFitterV0FinderTool.cxx.

                                                                           {
 
  // Vector of seeding vertices. 
  std::vector< Trk::PositionAndWeight > positionsOfSeedingVertices;
 
  // Using a function here, may become tool in the future!
  // Phase 3, 4 and  5: find and select v0 candidates
  std::vector< const xAOD::Vertex* > v0candidates = findV0candidates( primaryVertex,jetMomentum,inputTracks, vertexCandidates );  
  ATH_MSG_DEBUG( "Found " << v0candidates.size() <<" V0 candidates!" );
      
  // Phase 6
  // Select tracks for first fit using only the "best tracks" from the two-track vertices
  ATH_MSG_DEBUG( "Analyzing two track vertices to select the best tracks" );
  for ( const xAOD::Vertex* v0candidate : v0candidates ) {
 
    // Check quality for first fit
    bool satisfyCriteriaFirstFitQuality = checkCriteriaFirstFit( primaryVertex,jetMomentum,*v0candidate );
    if ( not satisfyCriteriaFirstFitQuality ) { 
      ATH_MSG_DEBUG( "Quality criteria for first fit not satisfied! skipping ... " );
      continue; 
    } 
 
    // The v0 candidate satisfy the selection criteria
    // Filling the vector of tracks to be used in the first fit
    std::vector< const Trk::ITrackLink* > vxTrackAtVertex = m_tracksAccessor( *v0candidate );
    const Trk::ITrackLink *firstTrack  = vxTrackAtVertex.at(0);
    const Trk::ITrackLink *secondTrack = vxTrackAtVertex.at(1);
 
    // Second track added first, legacy from old jetfitter
    bool secondTrackAlreadyStored = InDet::InDetJetFitterUtils::checkIfTrackIsInVector( secondTrack,tracksToUseInFirstFit );
    if ( not secondTrackAlreadyStored )
      tracksToUseInFirstFit.push_back( secondTrack );
 
    // First track
    bool firstTrackAlreadyStored = InDet::InDetJetFitterUtils::checkIfTrackIsInVector( firstTrack,tracksToUseInFirstFit );
    if ( not firstTrackAlreadyStored )
      tracksToUseInFirstFit.push_back( firstTrack );
 
    positionsOfSeedingVertices.emplace_back( v0candidate->position(),1 );
  }
 
 
  // Phase 7
  ATH_MSG_DEBUG( "Determine single good tracks to add in the fit in a second step" );
  for ( const Trk::ITrackLink *trackLink : inputTracks ) {
    
    bool satisfyCriteriaSecondFitQuality = checkCriteriaSecondFit( primaryVertex,trackLink );
    if ( not satisfyCriteriaSecondFitQuality ) {
      ATH_MSG_DEBUG( "Quality criteria for second fit not satisfied! skipping ... " );
      continue;
    } 
 
    bool alreadyUsed = InDet::InDetJetFitterUtils::checkIfTrackIsInVector( trackLink,tracksToUseInFirstFit );
    if ( alreadyUsed ) {
      ATH_MSG_VERBOSE( "Track was already used" );
      continue;
    }
 
    bool trackAlreadyStored = InDet::InDetJetFitterUtils::checkIfTrackIsInVector( trackLink,tracksToUseInSecondFit );
    if ( not trackAlreadyStored )
      tracksToUseInSecondFit.push_back( trackLink );
  }
 
 
  //  Compute JFseedDirection
  JFseedDirection = computeSeedDirection( primaryVertex,jetMomentum,positionsOfSeedingVertices );
 
  // First argument is the list of vertex candidates
  // Second argument is the list of Selected Neutral Tracks To Store
  // The Trk::TwoTrackVerticesInJet takes over the ownership
 
  // We need to use normal pointers instead of smart pointers since the code breaks.
  // We have to fix this issue in the future
  const Trk::TwoTrackVerticesInJet *twoTrackVerticesInJet = new Trk::TwoTrackVerticesInJet( std::move(v0candidates),
                                                                                            std::vector< const Trk::TrackParticleBase* >() );
  return twoTrackVerticesInJet;
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

finalize()

StatusCode JetFitterV0FinderTool::finalize

(

)

Definition at line 59 of file JetFitterV0FinderTool.cxx.

                                           {
  return StatusCode::SUCCESS;
}

findV0candidates()

std::vector< const xAOD::Vertex * > JetFitterV0FinderTool::findV0candidates ( const xAOD::Vertex & , const TLorentzVector & , std::vector< const Trk::ITrackLink * > & , const std::vector< const xAOD::Vertex * > & vertexCandidates ) const

private

Definition at line 149 of file JetFitterV0FinderTool.cxx.

                                                                                                       {
  
  std::vector< const xAOD::Vertex* > v0candidates;
  ATH_MSG_DEBUG( "Looping over " << vertexCandidates.size() <<" input candidates" );
 
  for ( unsigned int indexA(0); indexA<vertexCandidates.size(); indexA++ ) {
    const xAOD::Vertex* myCandidate = vertexCandidates.at( indexA );
 
    // Here a shortlist of candidates will be applied    
    
    // Phase 4 and 5 (not called in old code)!
    // Check for photon convertion, Ks and Lambda
    // Veto candidates and tracks
 
    // Make a copy of the input candidate
    // This way of creating a copy creates a discrepancy w.r.t. the code in rel21, which is propagated to Jet Fitter variables.
    // However, this assures that the vertex positions retrieved via position().x() and x() are consistent
    xAOD::Vertex* toAdd = new xAOD::Vertex();
    v0candidates.push_back( toAdd );
    *toAdd = *myCandidate;
  }
 
  return v0candidates;
}

initialize()

StatusCode JetFitterV0FinderTool::initialize

(

)

Definition at line 35 of file JetFitterV0FinderTool.cxx.

                                             {
 
  if ( m_jetFitterUtils.retrieve().isFailure() ) {
    ATH_MSG_ERROR( "Cannot retrieve InDet::InDetJetFitterUtils/InDetJetFitterUtils" );
    return StatusCode::FAILURE;
  }
 
  if ( m_mode3dfinder.retrieve().isFailure() ) {
    ATH_MSG_ERROR( "Cannot retrieve Trk::Mode3dTo1dFinder/Mode3dTo1dFinder" );
    return StatusCode::FAILURE;
  }
 
  if(m_useITkMaterialRejection){
    ATH_CHECK(detStore()->retrieve(m_beamPipeMgr, "BeamPipe"));
    ATH_CHECK(detStore()->retrieve(m_pixelManager, "ITkPixel"));
 
    InDetMaterialVeto matVeto(m_beamPipeMgr, m_pixelManager);
 
    m_ITkPixMaterialMap = matVeto.ITkPixMaterialMap();
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & InDet::JetFitterV0FinderTool::interfaceID ( )

inlinestatic

Definition at line 32 of file JetFitterV0FinderTool.h.

                                                {
      return IID_JetFitterV0FinderTool;
        }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_beamPipeMgr

const BeamPipeDetectorManager* InDet::JetFitterV0FinderTool::m_beamPipeMgr = nullptr

private

Definition at line 109 of file JetFitterV0FinderTool.h.

m_compatibilityAccessor

SG::AuxElement::Accessor< float > InDet::JetFitterV0FinderTool::m_compatibilityAccessor

private

Definition at line 72 of file JetFitterV0FinderTool.h.

m_cutCompatibilityPrimaryVertexBothTracksForBFirstSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutCompatibilityPrimaryVertexBothTracksForBFirstSelection {this,"cutCompatibilityPrimaryVertexBothTracksForBFirstSelection",1e-2,""}

private

Definition at line 83 of file JetFitterV0FinderTool.h.

{this,"cutCompatibilityPrimaryVertexBothTracksForBFirstSelection",1e-2,""};

m_cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutCompatibilityPrimaryVertexSingleNegativeLifetimeTrackForBSecondSelection {this,"cutCompPVSingleNegLifeTrackForBSecondSelect",1e-2,""}

private

Definition at line 100 of file JetFitterV0FinderTool.h.

{this,"cutCompPVSingleNegLifeTrackForBSecondSelect",1e-2,""};

m_cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutCompatibilityPrimaryVertexSinglePositiveLifetimeTrackForBSecondSelection {this,"cutCompPVSinglePosLifeTrackForBSecondSelect",5e-2,""}

private

Definition at line 99 of file JetFitterV0FinderTool.h.

{this,"cutCompPVSinglePosLifeTrackForBSecondSelect",5e-2,""};

m_cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection {this,"cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection",1e-1,""}

private

Definition at line 82 of file JetFitterV0FinderTool.h.

{this,"cutCompatibilityPrimaryVertexSingleTrackForBFirstSelection",1e-1,""};

m_cutCompatibilityToPrimaryBothTracksForMatInteractions

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutCompatibilityToPrimaryBothTracksForMatInteractions {this,"cutCompToPrimaryBothTracksForMatInterac",1e-6,""}

private

Definition at line 91 of file JetFitterV0FinderTool.h.

{this,"cutCompToPrimaryBothTracksForMatInterac",1e-6,""};

m_cutCompatibilityToPrimarySingleTrackForMatInteractions

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutCompatibilityToPrimarySingleTrackForMatInteractions {this,"cutCompToPrimarySingleTrackForMatInterac",1e-4,""}

private

Definition at line 90 of file JetFitterV0FinderTool.h.

{this,"cutCompToPrimarySingleTrackForMatInterac",1e-4,""};

m_cutIPD0BothTracksForBFirstSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutIPD0BothTracksForBFirstSelection {this,"cutIPD0BothTracksForBFirstSelection",3.5,""}

private

Definition at line 84 of file JetFitterV0FinderTool.h.

{this,"cutIPD0BothTracksForBFirstSelection",3.5,""};

m_cutIPD0SigBoxSingleTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutIPD0SigBoxSingleTrackForBSecondSelection {this,"cutIPD0SigBoxSingleTrackForBSecondSelection",2.,""}

private

Definition at line 101 of file JetFitterV0FinderTool.h.

{this,"cutIPD0SigBoxSingleTrackForBSecondSelection",2.,""};

m_cutIPD0SingleTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutIPD0SingleTrackForBSecondSelection {this,"cutIPD0SingleTrackForBSecondSelection",1.5,""}

private

Definition at line 104 of file JetFitterV0FinderTool.h.

{this,"cutIPD0SingleTrackForBSecondSelection",1.5,""};

m_cutIPZ0BothTracksForBFirstSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutIPZ0BothTracksForBFirstSelection {this,"cutIPZ0BothTracksForBFirstSelection",5.,""}

private

Definition at line 85 of file JetFitterV0FinderTool.h.

{this,"cutIPZ0BothTracksForBFirstSelection",5.,""};

m_cutIPZ0SigBoxSingleTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutIPZ0SigBoxSingleTrackForBSecondSelection {this,"cutIPZ0SigBoxSingleTrackForBSecondSelection",5.,""}

private

Definition at line 102 of file JetFitterV0FinderTool.h.

{this,"cutIPZ0SigBoxSingleTrackForBSecondSelection",5.,""};

m_cutIPZ0SingleTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutIPZ0SingleTrackForBSecondSelection {this,"cutIPZ0SingleTrackForBSecondSelection",3.,""}

private

Definition at line 105 of file JetFitterV0FinderTool.h.

{this,"cutIPZ0SingleTrackForBSecondSelection",3.,""};

m_cutPtBothTracksForBFirstSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutPtBothTracksForBFirstSelection {this,"cutPtBothTracksForBFirstSelection",500.,""}

private

Definition at line 86 of file JetFitterV0FinderTool.h.

{this,"cutPtBothTracksForBFirstSelection",500.,""};

m_cutPtSingleTrackForBSecondSelection

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutPtSingleTrackForBSecondSelection {this,"cutPtSingleTrackForBSecondSelection",750,""}

private

Definition at line 106 of file JetFitterV0FinderTool.h.

{this,"cutPtSingleTrackForBSecondSelection",750,""};

m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionFirstCriterium

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionFirstCriterium {this,"cutTwoTrkVtxLifeSignForBFirstSelectCriteriumA",1.,""}

private

Definition at line 88 of file JetFitterV0FinderTool.h.

{this,"cutTwoTrkVtxLifeSignForBFirstSelectCriteriumA",1.,""};

m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionSecondCriterium

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutTwoTrkVtxLifetimeSignificanceForBFirstSelectionSecondCriterium {this,"cutTwoTrkVtxLifeSignForBFirstSelectCriteriumB",1.5,""}

private

Definition at line 89 of file JetFitterV0FinderTool.h.

{this,"cutTwoTrkVtxLifeSignForBFirstSelectCriteriumB",1.5,""};

m_cutTwoTrkVtxVertexProbForBFirstSelectionFirstCriterium

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutTwoTrkVtxVertexProbForBFirstSelectionFirstCriterium {this,"cutTwoTrkVtxVtxProbForBFirstSelectCriteriumA",0.05,""}

private

Definition at line 79 of file JetFitterV0FinderTool.h.

{this,"cutTwoTrkVtxVtxProbForBFirstSelectCriteriumA",0.05,""};

m_cutTwoTrkVtxVertexProbForBFirstSelectionSecondCriterium

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_cutTwoTrkVtxVertexProbForBFirstSelectionSecondCriterium {this,"cutTwoTrkVtxVtxProbForBFirstSelectCriteriumB",0.034,""}

private

Definition at line 80 of file JetFitterV0FinderTool.h.

{this,"cutTwoTrkVtxVtxProbForBFirstSelectCriteriumB",0.034,""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_firstLayer_max

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_firstLayer_max {this,"firstLayer_max",34.0+2.5,""}

private

Definition at line 95 of file JetFitterV0FinderTool.h.

{this,"firstLayer_max",34.0+2.5,""};

m_firstLayer_min

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_firstLayer_min {this,"firstLayer_min",34.0-2.5,""}

private

Definition at line 94 of file JetFitterV0FinderTool.h.

{this,"firstLayer_min",34.0-2.5,""};

m_ITkPixMaterialMap

std::unique_ptr<TH2D> InDet::JetFitterV0FinderTool::m_ITkPixMaterialMap

private

Definition at line 111 of file JetFitterV0FinderTool.h.

m_jetFitterUtils

ToolHandle< InDet::InDetJetFitterUtils > InDet::JetFitterV0FinderTool::m_jetFitterUtils {this,"InDetJetFitterUtils","InDet::InDetJetFitterUtils/InDetJetFitterUtils",""}

private

Definition at line 68 of file JetFitterV0FinderTool.h.

{this,"InDetJetFitterUtils","InDet::InDetJetFitterUtils/InDetJetFitterUtils",""}; 

m_mode3dfinder

ToolHandle< Trk::IMode3dFinder > InDet::JetFitterV0FinderTool::m_mode3dfinder {this,"Mode3dFinder","Trk::Mode3dTo1dFinder/Mode3dTo1dFinder",""}

private

Definition at line 69 of file JetFitterV0FinderTool.h.

{this,"Mode3dFinder","Trk::Mode3dTo1dFinder/Mode3dTo1dFinder",""};

m_pixelManager

const InDetDD::PixelDetectorManager* InDet::JetFitterV0FinderTool::m_pixelManager = nullptr

private

Definition at line 110 of file JetFitterV0FinderTool.h.

m_revertFromPositiveToNegativeTags

Gaudi::Property< bool > InDet::JetFitterV0FinderTool::m_revertFromPositiveToNegativeTags {this,"revertFromPositiveToNegativeTags",false,""}

private

Definition at line 77 of file JetFitterV0FinderTool.h.

{this,"revertFromPositiveToNegativeTags",false,""};

m_secondLayer_max

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_secondLayer_max {this,"secondLayer_max",51.5+3,""}

private

Definition at line 97 of file JetFitterV0FinderTool.h.

{this,"secondLayer_max",51.5+3,""};

m_secondLayer_min

Gaudi::Property< double > InDet::JetFitterV0FinderTool::m_secondLayer_min {this,"secondLayer_min",51.5-3,""}

private

Definition at line 96 of file JetFitterV0FinderTool.h.

{this,"secondLayer_min",51.5-3,""};

m_tracksAccessor

SG::AuxElement::Accessor< std::vector< const Trk::ITrackLink* > > InDet::JetFitterV0FinderTool::m_tracksAccessor

private

Definition at line 73 of file JetFitterV0FinderTool.h.

m_useITkMaterialRejection

Gaudi::Property< bool > InDet::JetFitterV0FinderTool::m_useITkMaterialRejection {this,"useITkMaterialRejection",false,"Reject vertices from hadronic interactions in detector material using ITk layout"}

private

Definition at line 108 of file JetFitterV0FinderTool.h.

{this,"useITkMaterialRejection",false,"Reject vertices from hadronic interactions in detector material using ITk layout"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• JetFitterV0FinderTool.h
• JetFitterV0FinderTool.cxx