xAOD::TauHelpers Namespace Reference

Functions
template<class T >
const T *	getLink (const xAOD::IParticle *, std::string, bool debug=false)
const xAOD::TruthParticle *	getTruthParticle (const xAOD::IParticle *, bool debug=false)
	return the truthParticle associated to the given IParticle (if any) More...
std::vector< ElementLink< xAOD::TrackParticleContainer > >	allTrackParticleLinks (const xAOD::TauJet *tau)
std::vector< ElementLink< xAOD::TrackParticleContainer > >	trackParticleLinks (const xAOD::TauJet *tau, xAOD::TauJetParameters::TauTrackFlag flag=xAOD::TauJetParameters::TauTrackFlag::classifiedCharged)
std::vector< ElementLink< xAOD::TrackParticleContainer > >	trackParticleLinksWithMask (const xAOD::TauJet *tau, xAOD::TauTrack::TrackFlagType mask)
xAOD::TauTrack *	tauTrackNonConst (const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont, int index, xAOD::TauJetParameters::TauTrackFlag flag=xAOD::TauJetParameters::TauTrackFlag::classifiedCharged)
xAOD::TauTrack *	tauTrackNonConstWithMask (const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont, int index, xAOD::TauTrack::TrackFlagType mask)
std::vector< xAOD::TauTrack * >	tauTracksNonConst (const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont, xAOD::TauJetParameters::TauTrackFlag flag=xAOD::TauJetParameters::TauTrackFlag::classifiedCharged)
std::vector< xAOD::TauTrack * >	tauTracksNonConstWithMask (const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont, xAOD::TauTrack::TrackFlagType mask)
std::vector< xAOD::TauTrack * >	allTauTracksNonConst (const xAOD::TauJet *tau, xAOD::TauTrackContainer *trackCont)
std::vector< const xAOD::IParticle * >	clusters (const xAOD::TauJet &tau, double dRMax)
std::vector< xAOD::CaloVertexedTopoCluster >	vertexedClusters (const xAOD::TauJet &tau, double dRMax)

Function Documentation

allTauTracksNonConst()

std::vector< xAOD::TauTrack * > xAOD::TauHelpers::allTauTracksNonConst	(	const xAOD::TauJet *	tau,
		xAOD::TauTrackContainer *	trackCont
	)

Definition at line 85 of file TauxAODHelpers.cxx.

                                                                                                                      {
  xAOD::TauTrack::TrackFlagType mask=0;
  return tauTracksNonConstWithMask(tau, trackCont, mask);
}

allTrackParticleLinks()

std::vector< ElementLink< xAOD::TrackParticleContainer > > xAOD::TauHelpers::allTrackParticleLinks

(

const xAOD::TauJet *

tau

)

Definition at line 16 of file TauxAODHelpers.cxx.

                                                                                                                 {
  xAOD::TauTrack::TrackFlagType mask=0;
  return trackParticleLinksWithMask(tau, mask);
}

clusters()

std::vector< const xAOD::IParticle * > xAOD::TauHelpers::clusters	(	const xAOD::TauJet &	tau,
		double	dRMax
	)

Definition at line 93 of file TauxAODHelpers.cxx.

                                                            {
  auto vertexedClusterList = xAOD::TauHelpers::vertexedClusters(tau, dRMax);
 
  std::vector<const xAOD::IParticle*> clusterList;
  for (const auto& vertexedCluster : vertexedClusterList) {
    const xAOD::CaloCluster& cluster = vertexedCluster.clust();
    clusterList.push_back(&cluster);
  }
 
  return clusterList;
}

getLink()

template<class T >

const T* xAOD::TauHelpers::getLink	(	const xAOD::IParticle *	,
		std::string	,
		bool	debug = false
	)

getTruthParticle()

const xAOD::TruthParticle * xAOD::TauHelpers::getTruthParticle	(	const xAOD::IParticle *	particle,
		bool	debug = false
	)

return the truthParticle associated to the given IParticle (if any)

Definition at line 10 of file TauxAODHelpers.cxx.

{
  return getLink<xAOD::TruthParticle>(particle, "truthParticleLink", debug);
}

tauTrackNonConst()

xAOD::TauTrack * xAOD::TauHelpers::tauTrackNonConst	(	const xAOD::TauJet *	tau,
		xAOD::TauTrackContainer *	trackCont,
		int	index,
		xAOD::TauJetParameters::TauTrackFlag	flag = xAOD::TauJetParameters::TauTrackFlag::classifiedCharged
	)

Definition at line 41 of file TauxAODHelpers.cxx.

                                                                                                                                                         {
  xAOD::TauTrack::TrackFlagType mask=1<<flag;
  return tauTrackNonConstWithMask(tau, trackCont, index, mask);
  
}

tauTrackNonConstWithMask()

xAOD::TauTrack * xAOD::TauHelpers::tauTrackNonConstWithMask	(	const xAOD::TauJet *	tau,
		xAOD::TauTrackContainer *	trackCont,
		int	index,
		xAOD::TauTrack::TrackFlagType	mask
	)

Definition at line 48 of file TauxAODHelpers.cxx.

                                                                                                                                                           {
  int accepted_track=0;
  for( const ElementLink< xAOD::TauTrackContainer >& link : tau->allTauTrackLinks() ){
    const xAOD::TauTrack* c_trk(nullptr);
    if(link.isValid()) c_trk = *link;
    if(c_trk==nullptr) continue;
    if(c_trk->flagWithMask(mask)){
      
      if(accepted_track==index) {
    if(dynamic_cast<const xAOD::TauTrackContainer*> (link.getStorableObjectPointer())!=trackCont){
      std::cerr << "TauxAODHelpers::tauTrackNonConstWithMask, inconsistent containers given" << std::endl;
      return nullptr;
    }
    return trackCont->at(link.index());
      }
      accepted_track++;
    }
  }
  return nullptr;
}

tauTracksNonConst()

std::vector< xAOD::TauTrack * > xAOD::TauHelpers::tauTracksNonConst	(	const xAOD::TauJet *	tau,
		xAOD::TauTrackContainer *	trackCont,
		xAOD::TauJetParameters::TauTrackFlag	flag = xAOD::TauJetParameters::TauTrackFlag::classifiedCharged
	)

Definition at line 70 of file TauxAODHelpers.cxx.

                                                                                                                                                           {
  xAOD::TauTrack::TrackFlagType mask=1<<flag;
  return tauTracksNonConstWithMask(tau, trackCont, mask);
}

tauTracksNonConstWithMask()

std::vector< xAOD::TauTrack * > xAOD::TauHelpers::tauTracksNonConstWithMask	(	const xAOD::TauJet *	tau,
		xAOD::TauTrackContainer *	trackCont,
		xAOD::TauTrack::TrackFlagType	mask
	)

Definition at line 76 of file TauxAODHelpers.cxx.

                                                                                                                                                           {
  std::vector<xAOD::TauTrack*> v;
  for( const ElementLink< xAOD::TauTrackContainer >& link : tau->allTauTrackLinks() ){
    if(link.isValid() && (*link)->flagWithMask(mask) && dynamic_cast<const xAOD::TauTrackContainer*> (link.getStorableObjectPointer()) == trackCont) v.push_back( trackCont->at(link.index()));
  }
  return v;
}

trackParticleLinks()

std::vector< ElementLink< xAOD::TrackParticleContainer > > xAOD::TauHelpers::trackParticleLinks	(	const xAOD::TauJet *	tau,
		xAOD::TauJetParameters::TauTrackFlag	flag = xAOD::TauJetParameters::TauTrackFlag::classifiedCharged
	)

Definition at line 22 of file TauxAODHelpers.cxx.

                                                                                                                                                      {
  xAOD::TauTrack::TrackFlagType mask=1<<flag;
  return trackParticleLinksWithMask(tau, mask);
}

trackParticleLinksWithMask()

std::vector< ElementLink< xAOD::TrackParticleContainer > > xAOD::TauHelpers::trackParticleLinksWithMask	(	const xAOD::TauJet *	tau,
		xAOD::TauTrack::TrackFlagType	mask
	)

Definition at line 28 of file TauxAODHelpers.cxx.

                                                                                                                                                      {
  std::vector< ElementLink< xAOD::TrackParticleContainer > > links;
  std::vector< const xAOD::TauTrack* > allTracks = tau->allTracks();
  for ( const xAOD::TauTrack* trk : allTracks ){
    if(trk->trackLinks().empty()) continue;
    if(trk->flagWithMask(mask)) 
      links.push_back(trk->trackLinks()[0]);    
  }
  return links;
}

vertexedClusters()

std::vector< xAOD::CaloVertexedTopoCluster > xAOD::TauHelpers::vertexedClusters	(	const xAOD::TauJet &	tau,
		double	dRMax
	)

Definition at line 108 of file TauxAODHelpers.cxx.

                                                                    {
  TLorentzVector tauAxis;
  if (tau.vertexLink().isValid()) {
    tauAxis = tau.p4(xAOD::TauJetParameters::IntermediateAxis); 
  }
  else {
    tauAxis = tau.p4(xAOD::TauJetParameters::DetectorAxis);
  }
 
  auto vertexedClusterList = tau.vertexedClusters();
  
  std::vector<xAOD::CaloVertexedTopoCluster> selectedList;
  for (const auto& vertexedCluster : vertexedClusterList) {
    TLorentzVector clusterP4 = vertexedCluster.p4();
    
    double dR = clusterP4.DeltaR(tauAxis);
    if (dR > dRMax) continue;
 
    selectedList.push_back(vertexedCluster);
  }
 
  return selectedList;
}