Class-algorithm for pseudo track selection. More...

#include <PseudoTrackSelector.h>

Inheritance diagram for DerivationFramework::PseudoTrackSelector:

Collaboration diagram for DerivationFramework::PseudoTrackSelector:

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

Protected Member Functions
void	fillRecoReplacedWithPseudo (const xAOD::TrackParticleContainer recoTrackParticleCol, const xAOD::TrackParticleContainer pseudoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
	Output track collection.
void	fillRecoPlusPseudo (const xAOD::TrackParticleContainer recoTrackParticleCol, const xAOD::TrackParticleContainer pseudoTrackParticleCol, xAOD::TrackParticleContainer *outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const
void	fillRecoNoFakes (const xAOD::TrackParticleContainer recoTrackParticleCol, xAOD::TrackParticleContainer outputCol, bool onlyFromB=false, bool onlyNotFromB=false) const

Static Protected Member Functions
static const xAOD::TruthParticle *	getTruth (const xAOD::TrackParticle *track)

Protected Attributes
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_in_recoTrackParticleLocation {this, "RecoTrackParticleLocation", ""}
	Protected data:
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_in_pseudoTrackParticleLocation {this, "PseudoTrackParticleLocation", ""}
	Reco track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoReplacedWithPseudo {this, "OutputRecoReplacedWithPseudo", ""}
	Pseudo track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoReplacedWithPseudoFromB {this, "OutputRecoReplacedWithPseudoFromB", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoReplacedWithPseudoNotFromB {this, "OutputRecoReplacedWithPseudoNotFromB", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoPlusPseudo {this, "OutputRecoPlusPseudo", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoPlusPseudoFromB {this, "OutputRecoPlusPseudoFromB", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoPlusPseudoNotFromB {this, "OutputRecoPlusPseudoNotFromB", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoNoFakes {this, "OutputRecoNoFakes", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoNoFakesFromB {this, "OutputRecoNoFakesFromB", ""}
	Output track collection.
SG::WriteHandleKey< xAOD::TrackParticleContainer >	m_out_recoNoFakesNotFromB {this, "OutputRecoNoFakesNotFromB", ""}
	Output track collection.

Private Types
typedef ElementLink< xAOD::TruthParticleContainer >	TruthLink

Private Attributes
ToolHandle< InDet::IInDetTrackTruthOriginTool >	m_trackOriginTool {this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool", "truth track origin tool"}

Detailed Description

Class-algorithm for pseudo track selection.

Definition at line 31 of file PseudoTrackSelector.h.

Member Typedef Documentation

◆ TruthLink

typedef ElementLink<xAOD::TruthParticleContainer> DerivationFramework::PseudoTrackSelector::TruthLink

private

Definition at line 83 of file PseudoTrackSelector.h.

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::PseudoTrackSelector::addBranches ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 51 of file PseudoTrackSelector.cxx.

  {
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudo = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoReplacedWithPseudo->setStore(outputRecoReplacedWithPseudoAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoReplacedWithPseudoFromB->setStore(outputRecoReplacedWithPseudoFromBAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoReplacedWithPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoReplacedWithPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoReplacedWithPseudoNotFromB->setStore(outputRecoReplacedWithPseudoNotFromBAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudo = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoPlusPseudo->setStore(outputRecoPlusPseudoAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoFromB = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoPlusPseudoFromB->setStore(outputRecoPlusPseudoFromBAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoPlusPseudoNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoPlusPseudoNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoPlusPseudoNotFromB->setStore(outputRecoPlusPseudoNotFromBAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakes = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoNoFakes->setStore(outputRecoNoFakesAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesFromB = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoNoFakesFromB->setStore(outputRecoNoFakesFromBAux.get());
    std::unique_ptr<xAOD::TrackParticleContainer> outputRecoNoFakesNotFromB = std::make_unique<xAOD::TrackParticleContainer>();
    std::unique_ptr<xAOD::TrackParticleAuxContainer> outputRecoNoFakesNotFromBAux = std::make_unique<xAOD::TrackParticleAuxContainer>();
    outputRecoNoFakesNotFromB->setStore(outputRecoNoFakesNotFromBAux.get());
    
    // retrieve reco and pseudo tracks
    SG::ReadHandle<xAOD::TrackParticleContainer> recoTrackParticleCol (m_in_recoTrackParticleLocation, ctx);
    SG::ReadHandle<xAOD::TrackParticleContainer> pseudoTrackParticleCol (m_in_pseudoTrackParticleLocation, ctx);
 
    // fail if containers not available
    if (!recoTrackParticleCol.isValid()){
      ATH_MSG_ERROR( m_in_recoTrackParticleLocation.key() << " not valid!" );
      return StatusCode::FAILURE;
    }
    if (!pseudoTrackParticleCol.isValid()){
      ATH_MSG_ERROR( m_in_pseudoTrackParticleLocation.key() << " not valid!" );
      return StatusCode::FAILURE;
    }
    
    // select subset of tracks
    fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudo.get());
    fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoFromB.get(), true, false);
    fillRecoReplacedWithPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoReplacedWithPseudoNotFromB.get(), false, true);
    fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudo.get());
    fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoFromB.get(), true, false);
    fillRecoPlusPseudo(recoTrackParticleCol.cptr(), pseudoTrackParticleCol.cptr(), outputRecoPlusPseudoNotFromB.get(), false, true);
    fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakes.get());
    fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesFromB.get(), true, false);
    fillRecoNoFakes(recoTrackParticleCol.cptr(), outputRecoNoFakesNotFromB.get(), false, true);
 
    // Write tracks to store
    ATH_MSG_DEBUG("outputRecoReplacedWithPseudo has "<<outputRecoReplacedWithPseudo.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudo(m_out_recoReplacedWithPseudo, ctx);
    ATH_CHECK(h_write_recoReplacedWithPseudo.record(std::move(outputRecoReplacedWithPseudo), std::move(outputRecoReplacedWithPseudoAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudo<<" to store");
 
    ATH_MSG_DEBUG("outputRecoReplacedWithPseudoFromB has "<<outputRecoReplacedWithPseudoFromB.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoFromB(m_out_recoReplacedWithPseudoFromB, ctx);
    ATH_CHECK(h_write_recoReplacedWithPseudoFromB.record(std::move(outputRecoReplacedWithPseudoFromB), std::move(outputRecoReplacedWithPseudoFromBAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoFromB<<" to store");
 
    ATH_MSG_DEBUG("outputRecoReplacedWithPseudoNotFromB has "<<outputRecoReplacedWithPseudoNotFromB.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoReplacedWithPseudoNotFromB(m_out_recoReplacedWithPseudoNotFromB, ctx);
    ATH_CHECK(h_write_recoReplacedWithPseudoNotFromB.record(std::move(outputRecoReplacedWithPseudoNotFromB), std::move(outputRecoReplacedWithPseudoNotFromBAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoReplacedWithPseudoNotFromB<<" to store");
 
    ATH_MSG_DEBUG("outputRecoPlusPseudo has "<<outputRecoPlusPseudo.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudo(m_out_recoPlusPseudo, ctx);
    ATH_CHECK(h_write_recoPlusPseudo.record(std::move(outputRecoPlusPseudo), std::move(outputRecoPlusPseudoAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudo<<" to store");
 
    ATH_MSG_DEBUG("outputRecoPlusPseudoFromB has "<<outputRecoPlusPseudoFromB.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoFromB(m_out_recoPlusPseudoFromB, ctx);
    ATH_CHECK(h_write_recoPlusPseudoFromB.record(std::move(outputRecoPlusPseudoFromB), std::move(outputRecoPlusPseudoFromBAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoFromB<<" to store");
 
    ATH_MSG_DEBUG("outputRecoPlusPseudoNotFromB has "<<outputRecoPlusPseudoNotFromB.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoPlusPseudoNotFromB(m_out_recoPlusPseudoNotFromB, ctx);
    ATH_CHECK(h_write_recoPlusPseudoNotFromB.record(std::move(outputRecoPlusPseudoNotFromB), std::move(outputRecoPlusPseudoNotFromBAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoPlusPseudoNotFromB<<" to store");
 
    ATH_MSG_DEBUG("outputRecoNoFakes has "<<outputRecoNoFakes.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakes(m_out_recoNoFakes, ctx);
    ATH_CHECK(h_write_recoNoFakes.record(std::move(outputRecoNoFakes), std::move(outputRecoNoFakesAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakes<<" to store");
    
    ATH_MSG_DEBUG("outputRecoNoFakesFromB has "<<outputRecoNoFakesFromB.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesFromB(m_out_recoNoFakesFromB, ctx);
    ATH_CHECK(h_write_recoNoFakesFromB.record(std::move(outputRecoNoFakesFromB), std::move(outputRecoNoFakesFromBAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesFromB<<" to store");
 
    ATH_MSG_DEBUG("outputRecoNoFakesNotFromB has "<<outputRecoNoFakesNotFromB.get()->size()<<" tracks");
    SG::WriteHandle<xAOD::TrackParticleContainer> h_write_recoNoFakesNotFromB(m_out_recoNoFakesNotFromB, ctx);
    ATH_CHECK(h_write_recoNoFakesNotFromB.record(std::move(outputRecoNoFakesNotFromB), std::move(outputRecoNoFakesNotFromBAux)));
    ATH_MSG_DEBUG("wrote "<<m_out_recoNoFakesNotFromB<<" to store");
 
    return StatusCode::SUCCESS;
  }

◆ fillRecoNoFakes()

void DerivationFramework::PseudoTrackSelector::fillRecoNoFakes	(	const xAOD::TrackParticleContainer *	recoTrackParticleCol,
		xAOD::TrackParticleContainer *	outputCol,
		bool	onlyFromB = false,
		bool	onlyNotFromB = false ) const

protected

Definition at line 313 of file PseudoTrackSelector.cxx.

  {
    ATH_MSG_DEBUG("Start fillRecoNoFakes with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
    // loop over tracks, accept them and add them into output collection
    if((recoTrackParticleCol && !recoTrackParticleCol->empty())){
      ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
      int n_saved = 0;
      static const SG::ConstAccessor< float > acc_truthProb("truthMatchProbability");
 
      // loop over tracks
      for(const auto *const tp_reco: *recoTrackParticleCol){
        // place cut on truth match probability
        if (!onlyFromB && !onlyNotFromB){
          if( acc_truthProb( *tp_reco ) < 0.5) {
            ATH_MSG_DEBUG("Fake track!");
            continue;
          }
        }
        int origin = m_trackOriginTool->getTrackOrigin(tp_reco);
        ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
        if (onlyFromB && InDet::TrkOrigin::isFromB(origin)){
          if( acc_truthProb( *tp_reco ) < 0.5) {
            ATH_MSG_DEBUG("Fake track fromB!");
            continue;
          }
        }
        if (onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
          if( acc_truthProb( *tp_reco ) < 0.5) {
            ATH_MSG_DEBUG("Fake track notFromB!");
            continue;
          }
        }
        // add track into output
        xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
        outputCol->push_back(newTrackParticle);
        n_saved++;
      }
      ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
    }
  }

◆ fillRecoPlusPseudo()

void DerivationFramework::PseudoTrackSelector::fillRecoPlusPseudo	(	const xAOD::TrackParticleContainer *	recoTrackParticleCol,
		const xAOD::TrackParticleContainer *	pseudoTrackParticleCol,
		xAOD::TrackParticleContainer *	outputCol,
		bool	onlyFromB = false,
		bool	onlyNotFromB = false ) const

protected

Definition at line 245 of file PseudoTrackSelector.cxx.

  {
    ATH_MSG_DEBUG("Start fillRecoPlusPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
    // loop over tracks, accept them and add them into output collection
    if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
       (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
      ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
      ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
      int n_saved = 0;
      // Start by keeping reco tracks
      for(const auto *const tp_reco: *recoTrackParticleCol){
        xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
        outputCol->push_back(newTrackParticle);
        n_saved++;
      }
      // Now add pseudo tracks that are not matched to reco tracks
      for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
        bool match_found = false;
        const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
        for(const auto *const tp_reco: *recoTrackParticleCol){
          // Get truth particle
          const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
          if (truth_reco){
            if (truth_reco == truth_pseudo){
              ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
              match_found = true;
              break;
            }
          }
          else{
            ATH_MSG_DEBUG("no truth particle for reco track!");
          }
        }
        if(!match_found){
          ATH_MSG_DEBUG("no match found, so adding pseudo track to output");
          if(!onlyFromB && !onlyNotFromB){
            xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
            outputCol->push_back(newTrackParticle);
            n_saved++;
            ATH_MSG_DEBUG("saving pseudo track");
          }
          int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
          ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
          if(onlyFromB && InDet::TrkOrigin::isFromB(origin)){
            xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
            outputCol->push_back(newTrackParticle);
            n_saved++;
            ATH_MSG_DEBUG("saving fromB pseudo track");
          }
          if(onlyNotFromB && !InDet::TrkOrigin::isFromB(origin)){
            xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
            outputCol->push_back(newTrackParticle);
            n_saved++;
            ATH_MSG_DEBUG("saving notFromB pseudo track");
          }
        }
        else{
          ATH_MSG_DEBUG("match found so not adding pseudo track to output");
        }
      }
      ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
    }
  }

◆ fillRecoReplacedWithPseudo()

void DerivationFramework::PseudoTrackSelector::fillRecoReplacedWithPseudo	(	const xAOD::TrackParticleContainer *	recoTrackParticleCol,
		const xAOD::TrackParticleContainer *	pseudoTrackParticleCol,
		xAOD::TrackParticleContainer *	outputCol,
		bool	onlyFromB = false,
		bool	onlyNotFromB = false ) const

protected

Output track collection.

Protected methods:

Routines that selects the relevant (pseudo) tracks.

Definition at line 159 of file PseudoTrackSelector.cxx.

  {
    ATH_MSG_DEBUG("Start fillRecoReplacedWithPseudo with onlyFromB = "<<onlyFromB<<" and onlyNotFromB = "<<onlyNotFromB);
    // loop over tracks, accept them and add them into output collection
    if((recoTrackParticleCol && !recoTrackParticleCol->empty()) &&
       (pseudoTrackParticleCol && !pseudoTrackParticleCol->empty())) {
      ATH_MSG_DEBUG("Size of reco track particle collection " << recoTrackParticleCol->size());
      ATH_MSG_DEBUG("Size of pseudo track particle collection " << pseudoTrackParticleCol->size());
      int n_saved = 0;
      // loop over reco tracks
      for(const auto *const tp_reco: *recoTrackParticleCol){
        // Get truth particle
        const xAOD::TruthParticle* truth_reco = getTruth(tp_reco);
        if (truth_reco){
          bool match_found = false;
          // loop over pseudo tracks to look for a match
          for(const auto *const tp_pseudo: *pseudoTrackParticleCol){
            const xAOD::TruthParticle* truth_pseudo = getTruth(tp_pseudo);
            if (truth_reco == truth_pseudo){
              ATH_MSG_DEBUG("reco track has truth-matched pseudo track!");
              match_found = true;
              // add pseudo track into output
              if (!onlyFromB && !onlyNotFromB){
                xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
                outputCol->push_back(newTrackParticle);
                n_saved++;
                ATH_MSG_DEBUG("saving pseudo track");
              }
              // Check origin of track
              int origin = m_trackOriginTool->getTrackOrigin(tp_pseudo);
              ATH_MSG_DEBUG("fromB: "<<InDet::TrkOrigin::isFromB(origin));
              if (onlyFromB){
                if (InDet::TrkOrigin::isFromB(origin)){
                  // Track is from B hadron, replace with pseudo track
                  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
                  outputCol->push_back(newTrackParticle);
                  n_saved++;
                  ATH_MSG_DEBUG("saving fromB pseudo track");
                }
                else{
                  // Track is not from B hadron, keep reco track
                  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
                  outputCol->push_back(newTrackParticle);
                  n_saved++;
                  ATH_MSG_DEBUG("keeping notFromB reco track");
                }
              }
              if (onlyNotFromB){
                if (!InDet::TrkOrigin::isFromB(origin)){
                  // Track is not from B hadron, replace with pseudo track
                  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_pseudo);
                  outputCol->push_back(newTrackParticle);
                  n_saved++;
                  ATH_MSG_DEBUG("saving notFromB pseudo track");
                }
                else{
                  // Track is from B hadron, keep reco track
                  xAOD::TrackParticle* newTrackParticle = new xAOD::TrackParticle(*tp_reco);
                  outputCol->push_back(newTrackParticle);
                  n_saved++;
                  ATH_MSG_DEBUG("keeping FromB reco track");
                }
              }
              // Found match and replaced relevant track
              break;
            }
            else{
              ATH_MSG_VERBOSE("truth-matched pseudo track not found yet...");
            }
          }
          if(!match_found){
            ATH_MSG_DEBUG("reco track that has truth link DOES NOT have truth-matched pseudo track! :(");
          }
        }
        else{
          ATH_MSG_DEBUG("no truth particle for reco track!");
        }
      }
      ATH_MSG_DEBUG("Size of output track particle collection " << outputCol->size() <<" (sanity: "<<n_saved<<")");
    }
  }

◆ getTruth()

const xAOD::TruthParticle * DerivationFramework::PseudoTrackSelector::getTruth ( const xAOD::TrackParticle * track )

staticprotected

Definition at line 357 of file PseudoTrackSelector.cxx.

                                                                                         {
    // create a pointer to a truth particle which will correspond to this track
    const xAOD::TruthParticle* linkedTruthParticle = nullptr;
 
    // if the track doesnt't have a valid truth link, skip to the next track
    // in practice, all tracks seem to have a truth link, but we need to also
    // check whether it's valid
    static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
    if ( !truthParticleLinkAcc.isAvailable(*track) ) {
      return nullptr;
    }
 
    // retrieve the link and check its validity
    const TruthLink &link = truthParticleLinkAcc(*track);
 
    // a missing or invalid link implies truth particle has been dropped from
    // the truth record at some stage - probably it was a pileup or low pT GEANT
    // particle.
    if(!link or !link.isValid()) {
      return nullptr;
    }
 
    // seems safe to access and return the linked truth particle
    linkedTruthParticle = (*link);
    return linkedTruthParticle;
  }

◆ initialize()

StatusCode DerivationFramework::PseudoTrackSelector::initialize ( )

finaloverridevirtual

Definition at line 33 of file PseudoTrackSelector.cxx.

  {
    ATH_MSG_DEBUG("Initializing PseudoTrackSelector");
    ATH_CHECK( m_in_recoTrackParticleLocation.initialize() );
    ATH_CHECK( m_in_pseudoTrackParticleLocation.initialize() );
    ATH_CHECK( m_out_recoReplacedWithPseudo.initialize() );
    ATH_CHECK( m_out_recoReplacedWithPseudoFromB.initialize() );
    ATH_CHECK( m_out_recoReplacedWithPseudoNotFromB.initialize() );
    ATH_CHECK( m_out_recoPlusPseudo.initialize() );
    ATH_CHECK( m_out_recoPlusPseudoFromB.initialize() );
    ATH_CHECK( m_out_recoPlusPseudoNotFromB.initialize() );
    ATH_CHECK( m_out_recoNoFakes.initialize() );
    ATH_CHECK( m_out_recoNoFakesFromB.initialize() );
    ATH_CHECK( m_out_recoNoFakesNotFromB.initialize() );
    ATH_CHECK( m_trackOriginTool.retrieve() );
    return StatusCode::SUCCESS;
  }

Member Data Documentation

◆ m_in_pseudoTrackParticleLocation

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_in_pseudoTrackParticleLocation {this, "PseudoTrackParticleLocation", ""}

protected

Reco track collection.

Definition at line 48 of file PseudoTrackSelector.h.

48{this, "PseudoTrackParticleLocation", ""};

◆ m_in_recoTrackParticleLocation

SG::ReadHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_in_recoTrackParticleLocation {this, "RecoTrackParticleLocation", ""}

protected

Protected data:

Definition at line 47 of file PseudoTrackSelector.h.

47{this, "RecoTrackParticleLocation", ""};

◆ m_out_recoNoFakes

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoNoFakes {this, "OutputRecoNoFakes", ""}

protected

Output track collection.

Definition at line 55 of file PseudoTrackSelector.h.

55{this, "OutputRecoNoFakes", ""};

◆ m_out_recoNoFakesFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesFromB {this, "OutputRecoNoFakesFromB", ""}

protected

Output track collection.

Definition at line 56 of file PseudoTrackSelector.h.

56{this, "OutputRecoNoFakesFromB", ""};

◆ m_out_recoNoFakesNotFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoNoFakesNotFromB {this, "OutputRecoNoFakesNotFromB", ""}

protected

Output track collection.

Definition at line 57 of file PseudoTrackSelector.h.

57{this, "OutputRecoNoFakesNotFromB", ""};

◆ m_out_recoPlusPseudo

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudo {this, "OutputRecoPlusPseudo", ""}

protected

Output track collection.

Definition at line 52 of file PseudoTrackSelector.h.

52{this, "OutputRecoPlusPseudo", ""};

◆ m_out_recoPlusPseudoFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoFromB {this, "OutputRecoPlusPseudoFromB", ""}

protected

Output track collection.

Definition at line 53 of file PseudoTrackSelector.h.

53{this, "OutputRecoPlusPseudoFromB", ""};

◆ m_out_recoPlusPseudoNotFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoPlusPseudoNotFromB {this, "OutputRecoPlusPseudoNotFromB", ""}

protected

Output track collection.

Definition at line 54 of file PseudoTrackSelector.h.

54{this, "OutputRecoPlusPseudoNotFromB", ""};

◆ m_out_recoReplacedWithPseudo

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudo {this, "OutputRecoReplacedWithPseudo", ""}

protected

Pseudo track collection.

Definition at line 49 of file PseudoTrackSelector.h.

49{this, "OutputRecoReplacedWithPseudo", ""};

◆ m_out_recoReplacedWithPseudoFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoFromB {this, "OutputRecoReplacedWithPseudoFromB", ""}

protected

Output track collection.

Definition at line 50 of file PseudoTrackSelector.h.

50{this, "OutputRecoReplacedWithPseudoFromB", ""};

◆ m_out_recoReplacedWithPseudoNotFromB

SG::WriteHandleKey<xAOD::TrackParticleContainer> DerivationFramework::PseudoTrackSelector::m_out_recoReplacedWithPseudoNotFromB {this, "OutputRecoReplacedWithPseudoNotFromB", ""}

protected

Output track collection.

Definition at line 51 of file PseudoTrackSelector.h.

51{this, "OutputRecoReplacedWithPseudoNotFromB", ""};

◆ m_trackOriginTool

ToolHandle< InDet::IInDetTrackTruthOriginTool > DerivationFramework::PseudoTrackSelector::m_trackOriginTool {this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool", "truth track origin tool"}

private

Definition at line 85 of file PseudoTrackSelector.h.

85{this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool", "truth track origin tool"};

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

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Attributes

Detailed Description

Member Typedef Documentation

◆ TruthLink

Member Function Documentation

◆ addBranches()

◆ fillRecoNoFakes()

◆ fillRecoPlusPseudo()

◆ fillRecoReplacedWithPseudo()

◆ getTruth()

◆ initialize()

Member Data Documentation

◆ m_in_pseudoTrackParticleLocation

◆ m_in_recoTrackParticleLocation

◆ m_out_recoNoFakes

◆ m_out_recoNoFakesFromB

◆ m_out_recoNoFakesNotFromB

◆ m_out_recoPlusPseudo

◆ m_out_recoPlusPseudoFromB

◆ m_out_recoPlusPseudoNotFromB

◆ m_out_recoReplacedWithPseudo

◆ m_out_recoReplacedWithPseudoFromB

◆ m_out_recoReplacedWithPseudoNotFromB

◆ m_trackOriginTool