#include <TrackCounting.h>

Inheritance diagram for Analysis::TrackCounting:

Collaboration diagram for Analysis::TrackCounting:

Public Member Functions
	TrackCounting (const std::string &, const std::string &, const IInterface *)
virtual	~TrackCounting ()
	Implementations of the methods defined in the abstract base class.
StatusCode	initialize ()
StatusCode	finalize ()
void	finalizeHistos ()
	finalize the histos: Normalize other histos and fill the integratedNegativeIP histos.
void	setOrigin (const Trk::VxCandidate *priVtx)
	Set the primary vertex.
void	tagJet (xAOD::Jet &jetToTag)
	called by BJetBuilder
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
	DeclareInterfaceID (ITagTool, 1, 0)
virtual StatusCode	tagJet (const xAOD::Vertex &priVtx, const xAOD::Jet &, xAOD::BTagging &, const std::string &) const =0
	Method to return the name of the tagging tool.

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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
template<class T>
static bool	m_greater (T a, T b)
	sort algorithm for vectors

Private Attributes
ToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool
	TrackToVertex tool.
ToolHandle< TrackSelector >	m_trackSelectorTool
	Track selection cuts for TrackCounting.
std::vector< GradedTrack >	m_tracksInJet
	The jet of TrackParticles to be tagged.
const Trk::VxCandidate *	m_priVtx = 0
	Storage for the primary vertex.
std::vector< std::string >	m_trackGradePartitionsDefinition
	track classification.
std::vector< TrackGradePartition * >	m_trackGradePartitions
bool	m_RejectBadTracks
	possibility to exclude Bad Tracks found with SVTagger and possibility to use the sign of the impact parameter with SVTagger/JetFitter
bool	m_SignWithSvx
bool	m_flipIP
bool	m_writeInfo
	write tagging info to info class
std::string	m_truthMatchingName
double	m_purificationDeltaR
std::vector< std::string >	m_jetCollectionList
std::string	m_secVxFinderNameForV0Removal
std::string	m_secVxFinderNameForIPSign
ToolHandle< SVForIPTool >	m_SVForIPTool
ToolHandle< ITrackGradeFactory >	m_trackGradeFactory
	ToolHandle for the ITrackGradeFactory tool.
ToolHandle< Trk::ITrackToVertexIPEstimator >	m_trackToVertexIPEstimator
	Tool for the estimation of the IPs to the Vertex.
bool	m_unbiasIPEstimation
	option to unbias IP estimation (remove track from vertex)
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 38 of file TrackCounting.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

◆ TrackCounting()

Analysis::TrackCounting::TrackCounting	(	const std::string &	name,
		const std::string &	n,
		const IInterface *	p )

Definition at line 33 of file TrackCounting.cxx.

    : AthAlgTool(name,n,p),
      m_trackToVertexTool("Reco::TrackToVertex"),
      m_trackSelectorTool("Analysis::TrackSelector"),
      m_secVxFinderNameForV0Removal("InDetVKalVxInJetTool"),
      m_secVxFinderNameForIPSign("InDetVKalVxInJetTool"),
      m_SVForIPTool("Analysis::SVForIPTool"),
      m_trackGradeFactory("Analysis::BasicTrackGradeFactory"),
      m_unbiasIPEstimation(false){
    
    declareInterface<ITagTool>(this);
    // global configuration:
    declareProperty("SignWithSvx", m_SignWithSvx = false);
    declareProperty("SVForIPTool", m_SVForIPTool);
 
    // track categories:
    declareProperty("trackGradePartitions", m_trackGradePartitionsDefinition);
    m_trackGradePartitionsDefinition.push_back("Good");
    declareProperty("RejectBadTracks", m_RejectBadTracks = false);
    declareProperty("flipIPSign", m_flipIP = false);
 
    // tools:
    declareProperty("trackSelectorTool", m_trackSelectorTool);
    declareProperty("trackToVertexTool", m_trackToVertexTool);
    declareProperty("trackGradeFactory", m_trackGradeFactory);
    
    // information to persistify:
    declareProperty("writeInfo", m_writeInfo = true);
 
    declareProperty("truthMatchingName", m_truthMatchingName = "TruthInfo");
    declareProperty("purificationDeltaR", m_purificationDeltaR = 0.8);
 
    declareProperty("SecVxFinderNameForV0Removal", m_secVxFinderNameForV0Removal);
    declareProperty("SecVxFinderNameForIPSign", m_secVxFinderNameForIPSign);
 
    declareProperty("TrackToVertexIPEstimator",m_trackToVertexIPEstimator);
    declareProperty("unbiasIPEstimation",m_unbiasIPEstimation);
  }

◆ ~TrackCounting()

Analysis::TrackCounting::~TrackCounting ( )

virtual

Implementations of the methods defined in the abstract base class.

Definition at line 72 of file TrackCounting.cxx.

                               {
    for (size_t i = 0; i < m_trackGradePartitions.size(); i++)
      delete m_trackGradePartitions.at(i);
  }

Member Function Documentation

◆ 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());
 
  }

◆ DeclareInterfaceID()

Analysis::ITagTool::DeclareInterfaceID	(	ITagTool	,
		1	,
		0	)

inherited

◆ 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.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ 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.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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 Analysis::TrackCounting::finalize ( )

Definition at line 154 of file TrackCounting.cxx.

                                     {
    
    return StatusCode::SUCCESS;
  }

◆ finalizeHistos()

void Analysis::TrackCounting::finalizeHistos ( )

inlinevirtual

finalize the histos: Normalize other histos and fill the integratedNegativeIP histos.

This cannot be done in the finalize() of this algtool because the histo service writes the histos BEFORE AlgTool::finalize() methods are called. However, it is closed AFTER Algorithm::finalize() methods are called ... In the calling Algorithm::finalize() method the following method will be called.

Implements Analysis::ITagTool.

Definition at line 47 of file TrackCounting.h.

47{};

◆ initialize()

StatusCode Analysis::TrackCounting::initialize ( )

retrieving TrackToVertex:

creation of TrackSelector: (private instance)

retrieving the track grade factory

prepare the track partitions:

Definition at line 78 of file TrackCounting.cxx.

                                       {
    
    if ( m_trackToVertexTool.retrieve().isFailure() ) {
      ATH_MSG_FATAL("#BTAG# Failed to retrieve tool " << m_trackToVertexTool);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackToVertexTool);
    }
 
    if(m_SVForIPTool.retrieve().isFailure()) {
      ATH_MSG_FATAL( "#BTAG# Failed to retrieve tool " << m_SVForIPTool);
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_SVForIPTool);
    }
 
    if(m_trackToVertexIPEstimator.retrieve().isFailure()) {
      ATH_MSG_FATAL( "#BTAG# Failed to retrieve tool " << m_trackToVertexIPEstimator);
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackToVertexIPEstimator);
    }
    
    if ( m_trackSelectorTool.retrieve().isFailure() ) {
      ATH_MSG_FATAL( "#BTAG# Failed to retrieve tool " << m_trackSelectorTool);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackSelectorTool);
    }
    
    if ( m_trackGradeFactory.retrieve().isFailure() ) {
      ATH_MSG_FATAL( "#BTAG# Failed to retrieve tool " << m_trackGradeFactory);
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG("#BTAG# Retrieved tool " << m_trackGradeFactory);
    }
    
    int nbPart = m_trackGradePartitionsDefinition.size();
    ATH_MSG_DEBUG("#BTAG# Defining " << nbPart <<" track partitions: ");
    for(int i=0;i<nbPart;i++) {
      TrackGradePartition* part(0);
      try {
        part = new TrackGradePartition(m_trackGradePartitionsDefinition[i], *m_trackGradeFactory);
      }
      catch(std::string error) {
        ATH_MSG_ERROR("#BTAG# Reported error " << error);
        ATH_MSG_ERROR("#BTAG# List of categories provided to TrackCounting by jO : ");
 
        for (int l=0;l<nbPart;l++) {
          ATH_MSG_ERROR("#BTAG# string " << m_trackGradePartitionsDefinition[l]);
        }
 
        ATH_MSG_ERROR("#BTAG# List of categories provided by the TrackGradeFactory " << m_trackGradeFactory);
 
        const TrackGradesDefinition &trackFactoryGradesDefinition = m_trackGradeFactory->getTrackGradesDefinition();
        const std::vector<TrackGrade> &gradeList = trackFactoryGradesDefinition.getList();
 
        std::vector<TrackGrade>::const_iterator listIter=gradeList.begin();
        std::vector<TrackGrade>::const_iterator listEnd=gradeList.end();
 
        for ( ; listIter !=listEnd ; ++listIter ) {
          ATH_MSG_ERROR("#BTAG# n. " << (*listIter).gradeNumber() << " string " << (*listIter).gradeString());
        }
 
        ATH_MSG_ERROR("#BTAG# Terminating now... ");
    return StatusCode::FAILURE;
      }      
      ATH_MSG_INFO("#BTAG# " << (*part));
      m_trackGradePartitions.push_back(part);
    }
    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.

◆ m_greater()

template<class T>

bool Analysis::TrackCounting::m_greater	(	T	a,
		T	b )

inlinestaticprivate

sort algorithm for vectors

Definition at line 106 of file TrackCounting.h.

                                                        {
    return a > b;
      }

◆ 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();
  }

◆ setOrigin()

void Analysis::TrackCounting::setOrigin ( const Trk::VxCandidate * priVtx )

inline

Set the primary vertex.

TODO: This is temporary ! The primary vertex should be part of the JetTag IParticle interface implementation. The trouble with ElementLink and persistency has to be solved for that. Revisit ...

Definition at line 111 of file TrackCounting.h.

111{ m_priVtx=priVtx; }

Analysis::TrackCounting::m_priVtx

const Trk::VxCandidate * m_priVtx

Storage for the primary vertex.

Definition TrackCounting.h:71

◆ 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.

◆ tagJet() [1/2]

virtual StatusCode Analysis::ITagTool::tagJet	(	const xAOD::Vertex &	priVtx,
		const xAOD::Jet &	,
		xAOD::BTagging &	,
		const std::string &	) const

pure virtualinherited

Method to return the name of the tagging tool.

The tagging method.

TODO: The first argument is temporary ! The primary vertex should be part of the JetTag IParticle interface implementation. The trouble with ElementLink and persistency has to be solved for that. Revisit ...

TODO: The second argument will be removed as soon as we have the JetTag containing the necessary pointers to the constituent TrackParticles via navigation. But maybe this is not a very good idea since then a JetTag always must be created even if the tagging does not work. Think ...

◆ tagJet() [2/2]

void Analysis::TrackCounting::tagJet ( xAOD::Jet & jetToTag )

called by BJetBuilder

author to know which jet algorithm:

getting sign from SecVxFinderTool

getting Bad Tracks from SecVxFinderTool

extract the TrackParticles from the jet and apply track selection:

jet direction:

sign of the impact parameter

signed ip and significances

sort vector of significances in descending order

give information to the info class.

tagging done. Fill the JetTag and return ... fill most powerfull discriminating variable it's not a likelihood, but this can directly be accessed from the Jet without changing the getFlavourTagWeight() method

Definition at line 160 of file TrackCounting.cxx.

                                              {
    
    std::string author = jetToTag.jetAuthor();
    ATH_MSG_VERBOSE("#BTAG# Using jet type " << author);
 
    m_tracksInJet.clear();
    int nbPart = m_trackGradePartitionsDefinition.size();
 
    std::vector<const Trk::Track*> TrkFromV0;
    Amg::Vector3D SvxDirection;
    bool canUseSvxDirection=false;
    if (m_SignWithSvx) {
      m_SVForIPTool->getDirectionFromSecondaryVertexInfo(SvxDirection,canUseSvxDirection,//output
                                                         jetToTag,m_secVxFinderNameForIPSign,m_priVtx->recVertex());//input
    }
    
    if (m_RejectBadTracks) {
      m_SVForIPTool->getTrkFromV0FromSecondaryVertexInfo(TrkFromV0,//output
                                                         jetToTag,m_secVxFinderNameForV0Removal);//input
    }
     
    ATH_MSG_VERBOSE("#BTAG# TrkFromV0 : number of reconstructed bad tracks: " << TrkFromV0.size());
 
    int nbTrack = 0;
    std::vector<const xAOD::TrackParticle*>* trackVector = NULL;
    const Analysis::TrackAssociation *trkInJet = jetToTag.getAssociation<TrackAssociation>("Tracks");
    if(!trkInJet){
      ATH_MSG_WARNING("#BTAG#  Could not find tracks in jets");
    }
    else{
      trackVector = jetToTag.getAssociation<TrackAssociation>("Tracks")->tracks();
      std::vector<const xAOD::TrackParticle*>::iterator jetItr;
      for( jetItr = trackVector->begin(); jetItr != trackVector->end() ; ++jetItr ) {
    const xAOD::TrackParticle * aTemp = *jetItr;
    nbTrack++;
    if( m_trackSelectorTool->selectTrack(m_priVtx->recVertex().position(), aTemp) ) {
      
      TrackGrade * theGrade = m_trackGradeFactory->getGrade(*aTemp,
                                jetToTag.p4() );
      
      ATH_MSG_VERBOSE("#BTAG# result of selectTrack is OK, grade= " << (std::string)(*theGrade));
      
      bool tobeUsed = false;
      for(int i=0;i<nbPart;i++) {
        if (std::find( (m_trackGradePartitions[i]->grades()).begin(), 
               (m_trackGradePartitions[i]->grades()).end(), 
               *theGrade ) 
        != (m_trackGradePartitions[i]->grades()).end()) tobeUsed = true;
      }
      // is it a bad track ?
      if (std::find(TrkFromV0.begin(),TrkFromV0.end(),*aTemp->track()) != TrkFromV0.end()) {
        ATH_MSG_VERBOSE("#BTAG# Bad track in jet, pt = " << aTemp->pt() << " eta = " << aTemp->eta() << " phi = " << aTemp->phi());
        if (m_RejectBadTracks) tobeUsed = false;
      }
      if (tobeUsed) m_tracksInJet.push_back(GradedTrack(aTemp, *theGrade));
      delete theGrade;
      theGrade=0;
    }
      } // end loop on trakparticles
 
      delete trackVector; 
    }
 
    ATH_MSG_VERBOSE("#BTAG# #tracks = " << nbTrack);
    ATH_MSG_VERBOSE("#BTAG# the z of the primary Vertex= " << m_priVtx->recVertex().position().z());
    Amg::Vector3D jetDirection(jetToTag.px(),jetToTag.py(),jetToTag.pz());
    Amg::Vector3D unit = jetDirection.unit();
    if (m_SignWithSvx && canUseSvxDirection) {
      unit = SvxDirection.unit();
      ATH_MSG_DEBUG("#BTAG# Using direction from sec vertex finder tool '"
            << m_secVxFinderNameForIPSign << "': "
            << " phi: " << unit.phi() 
            << " theta: " << unit.theta() 
            << " instead of jet direction phi: " << jetDirection.phi() 
            << " theta: " << jetDirection.theta());
    }
 
    FloatVec vectD0Signi;
    FloatVec vectD0Signi_abs;
    // reserve approximate space (optimization):
    const int nbTrackMean = 3;
    vectD0Signi.reserve(nbTrackMean);
    vectD0Signi_abs.reserve(nbTrackMean);
 
    for (std::vector<GradedTrack>::iterator trkItr = m_tracksInJet.begin(); 
         trkItr != m_tracksInJet.end(); ++trkItr) {
      const xAOD::TrackParticle* trk = (*trkItr).track;
 
      double d0wrtPriVtx(0.);
      double d0ErrwrtPriVtx(1.);
      double signOfIP(1.);
 
      /* use new Tool for "unbiased" IP estimation */
      const Trk::ImpactParametersAndSigma* myIPandSigma = m_trackToVertexIPEstimator->estimate(*trk->track(),m_priVtx,m_unbiasIPEstimation);
      if(myIPandSigma==0) {
    ATH_MSG_WARNING("#BTAG# trackToVertexIPEstimator failed !");
      } else {
    d0wrtPriVtx=myIPandSigma->IPd0;
    d0ErrwrtPriVtx=myIPandSigma->sigmad0;
    delete myIPandSigma;
    myIPandSigma=0;
      }
       
      signOfIP=m_trackToVertexIPEstimator->get2DLifetimeSignOfTrack(trk->perigeeParameters(),unit,m_priVtx->recVertex());
 
      if (m_flipIP) signOfIP = -signOfIP; // A.X.
      double sd0             = signOfIP*fabs(d0wrtPriVtx);
      double sd0significance = signOfIP*fabs(d0wrtPriVtx/d0ErrwrtPriVtx);
 
      vectD0Signi.push_back(sd0significance);
      vectD0Signi_abs.push_back( fabs(sd0significance) );
      
      ATH_MSG_VERBOSE("#BTAG# TrackCounting: Trk: grade= " << (std::string)(*trkItr).grade
              << " Eta= " << trk->eta() << " Phi= " << trk->phi() << " pT= " << trk->pt()
              << " d0= " << sd0
              << "+-" << d0ErrwrtPriVtx
              << " d0sig= " << sd0significance );
 
    } // end loop on gradedtracks
 
    
    sort( vectD0Signi.begin(), vectD0Signi.end(), m_greater<float> );
    sort( vectD0Signi_abs.begin(), vectD0Signi_abs.end(), m_greater<float> );
 
 
    std::string instanceName("TrackCounting2D");
    if (m_flipIP) instanceName += "Neg";// A.X.
    TrackCountingInfo* infoTrackCounting = NULL;
  
    if(m_writeInfo) {
      infoTrackCounting = new TrackCountingInfo(instanceName);
    
      int ntrk = vectD0Signi.size();
      infoTrackCounting->setnTracks( ntrk );
 
      ATH_MSG_VERBOSE("#BTAG# Filling TrackCountingInfo...");
      ATH_MSG_DEBUG("#BTAG# " << ntrk << " tracks used for TrackCounting, ordered ip2d significance / |ip2d significance|:" );
      for(uint i=0; i<vectD0Signi.size(); i++){
    ATH_MSG_DEBUG("#BTAG# trk " << i+1 << "/" << ntrk << ": " << vectD0Signi.at(i) << " / " << vectD0Signi_abs.at(i));
      }
      if( ntrk>=2 ){
    ATH_MSG_DEBUG("#BTAG# filling 2nd / 2nd abs: " << vectD0Signi.at(1) << " / " << vectD0Signi_abs.at(1));
    infoTrackCounting->setd0sig_2nd( vectD0Signi.at(1) );
    infoTrackCounting->setd0sig_abs_2nd( vectD0Signi_abs.at(1) );
      }
      if( ntrk>=3 ){
    ATH_MSG_DEBUG("#BTAG# filling 3rd / 3rd abs: " << vectD0Signi.at(2) << " / " << vectD0Signi_abs.at(2));
    infoTrackCounting->setd0sig_3rd( vectD0Signi.at(2) );
    infoTrackCounting->setd0sig_abs_3rd( vectD0Signi_abs.at(2) );
      }
    }
    if(infoTrackCounting){
      std::vector<double> v_tofill;
      double tofill = exp(-20.);
      if(vectD0Signi.size()>=2){
    tofill = exp(vectD0Signi.at(1));
    infoTrackCounting->makeValid();
      }
      v_tofill.push_back( tofill );
      v_tofill.push_back(1.);
      infoTrackCounting->setTagLikelihood( v_tofill );
      jetToTag.addInfo( infoTrackCounting );
    }
    
    m_tracksInJet.clear();
    
    return;
  }

◆ 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_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_flipIP

bool Analysis::TrackCounting::m_flipIP

private

Definition at line 82 of file TrackCounting.h.

◆ m_jetCollectionList

std::vector<std::string> Analysis::TrackCounting::m_jetCollectionList

private

Definition at line 90 of file TrackCounting.h.

◆ m_priVtx

const Trk::VxCandidate* Analysis::TrackCounting::m_priVtx = 0

private

Storage for the primary vertex.

Can be removed when JetTag provides origin().

Definition at line 71 of file TrackCounting.h.

◆ m_purificationDeltaR

double Analysis::TrackCounting::m_purificationDeltaR

private

Definition at line 88 of file TrackCounting.h.

◆ m_RejectBadTracks

bool Analysis::TrackCounting::m_RejectBadTracks

private

possibility to exclude Bad Tracks found with SVTagger and possibility to use the sign of the impact parameter with SVTagger/JetFitter

Definition at line 79 of file TrackCounting.h.

◆ m_secVxFinderNameForIPSign

std::string Analysis::TrackCounting::m_secVxFinderNameForIPSign

private

Definition at line 94 of file TrackCounting.h.

◆ m_secVxFinderNameForV0Removal

std::string Analysis::TrackCounting::m_secVxFinderNameForV0Removal

private

Definition at line 93 of file TrackCounting.h.

◆ m_SignWithSvx

bool Analysis::TrackCounting::m_SignWithSvx

private

Definition at line 80 of file TrackCounting.h.

◆ m_SVForIPTool

ToolHandle< SVForIPTool > Analysis::TrackCounting::m_SVForIPTool

private

Definition at line 95 of file TrackCounting.h.

◆ m_trackGradeFactory

ToolHandle< ITrackGradeFactory > Analysis::TrackCounting::m_trackGradeFactory

private

ToolHandle for the ITrackGradeFactory tool.

Definition at line 98 of file TrackCounting.h.

◆ m_trackGradePartitions

std::vector<TrackGradePartition*> Analysis::TrackCounting::m_trackGradePartitions

private

Definition at line 75 of file TrackCounting.h.

◆ m_trackGradePartitionsDefinition

std::vector<std::string> Analysis::TrackCounting::m_trackGradePartitionsDefinition

private

track classification.

Definition at line 74 of file TrackCounting.h.

◆ m_trackSelectorTool

ToolHandle< TrackSelector > Analysis::TrackCounting::m_trackSelectorTool

private

Track selection cuts for TrackCounting.

Definition at line 63 of file TrackCounting.h.

◆ m_tracksInJet

std::vector<GradedTrack> Analysis::TrackCounting::m_tracksInJet

private

The jet of TrackParticles to be tagged.

Definition at line 66 of file TrackCounting.h.

◆ m_trackToVertexIPEstimator

ToolHandle< Trk::ITrackToVertexIPEstimator > Analysis::TrackCounting::m_trackToVertexIPEstimator

private

Tool for the estimation of the IPs to the Vertex.

Definition at line 101 of file TrackCounting.h.

◆ m_trackToVertexTool

ToolHandle< Reco::ITrackToVertex > Analysis::TrackCounting::m_trackToVertexTool

private

TrackToVertex tool.

Definition at line 60 of file TrackCounting.h.

◆ m_truthMatchingName

std::string Analysis::TrackCounting::m_truthMatchingName

private

Definition at line 87 of file TrackCounting.h.

◆ m_unbiasIPEstimation

bool Analysis::TrackCounting::m_unbiasIPEstimation

private

option to unbias IP estimation (remove track from vertex)

Definition at line 103 of file TrackCounting.h.

◆ 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.

◆ m_writeInfo

bool Analysis::TrackCounting::m_writeInfo

private

write tagging info to info class

Definition at line 85 of file TrackCounting.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TrackCounting()

◆ ~TrackCounting()

Member Function Documentation

◆ declareGaudiProperty()

◆ DeclareInterfaceID()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ finalizeHistos()

◆ initialize()

◆ inputHandles()

◆ m_greater()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setOrigin()

◆ sysInitialize()

◆ sysStart()

◆ tagJet() [1/2]

◆ tagJet() [2/2]

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_evtStore

◆ m_flipIP

◆ m_jetCollectionList

◆ m_priVtx

◆ m_purificationDeltaR

◆ m_RejectBadTracks

◆ m_secVxFinderNameForIPSign

◆ m_secVxFinderNameForV0Removal

◆ m_SignWithSvx

◆ m_SVForIPTool

◆ m_trackGradeFactory

◆ m_trackGradePartitions

◆ m_trackGradePartitionsDefinition

◆ m_trackSelectorTool

◆ m_tracksInJet

◆ m_trackToVertexIPEstimator

◆ m_trackToVertexTool

◆ m_truthMatchingName

◆ m_unbiasIPEstimation

◆ m_varHandleArraysDeclared

◆ m_vhka

◆ m_writeInfo