tauRecTools Namespace Reference

Implementation of a TrackClassifier based on an RNN. More...

Classes
class	BDTHelper
class	TauDecayModeNNHelper
	A closely related class that provides helper functions. More...
class	TauDecayModeNNVariable
	A closely related class that calculates the input variables. More...
class	TauTrackRNNClassifier
class	TrackRNN

Typedefs
typedef std::map< std::string, double >	ValueMap
typedef std::map< std::string, std::vector< double > >	VectorMap
typedef std::map< std::string, ValueMap >	NodeMap
typedef std::map< std::string, VectorMap >	SeqNodeMap

Functions
const xAOD::Vertex *	getJetVertex (const xAOD::Jet &jet)
	Return the vertex of jet candidate.
TLorentzVector	getTauAxis (const xAOD::TauJet &tau, bool doVertexCorrection=true)
	Return the four momentum of the tau axis The tau axis is widely used to select clusters and cells in tau reconstruction.
TLorentzVector	GetConstituentP4 (const xAOD::JetConstituent &constituent)
bool	doPi0andShots (const xAOD::TauJet &tau)
	Determines whether pi0s and shots should be built for a tau candidate.
xAOD::TauTrack::TrackFlagType	isolateClassifiedBits (xAOD::TauTrack::TrackFlagType flag)
bool	sortTracks (const ElementLink< xAOD::TauTrackContainer > &l1, const ElementLink< xAOD::TauTrackContainer > &l2)
std::unique_ptr< MVAUtils::BDT >	configureMVABDT (std::map< TString, float * > &availableVars, const TString &weightFile)
std::unique_ptr< MVAUtils::BDT >	configureMVABDT (std::vector< TString > &variableNames, const TString &weightFile)
std::vector< TString >	parseString (const TString &str, const TString &delim=",")
std::vector< TString >	parseStringMVAUtilsBDT (const TString &str, const TString &delim=",")

Detailed Description

Implementation of a TrackClassifier based on an RNN.

Author

Max Maerker

Typedef Documentation

NodeMap

typedef std::map<std::string, ValueMap> tauRecTools::NodeMap

Definition at line 44 of file TauTrackRNNClassifier.h.

SeqNodeMap

typedef std::map<std::string, VectorMap> tauRecTools::SeqNodeMap

Definition at line 45 of file TauTrackRNNClassifier.h.

ValueMap

typedef std::map<std::string, double> tauRecTools::ValueMap

Definition at line 40 of file TauTrackRNNClassifier.h.

VectorMap

typedef std::map<std::string, std::vector<double> > tauRecTools::VectorMap

Definition at line 42 of file TauTrackRNNClassifier.h.

Function Documentation

configureMVABDT() [1/2]

std::unique_ptr< MVAUtils::BDT > tauRecTools::configureMVABDT	(	std::map< TString, float * > &	availableVars,
		const TString &	weightFile )

configureMVABDT() [2/2]

std::unique_ptr< MVAUtils::BDT > tauRecTools::configureMVABDT	(	std::vector< TString > &	variableNames,
		const TString &	weightFile )

doPi0andShots()

bool tauRecTools::doPi0andShots

(

const xAOD::TauJet &

tau

)

Determines whether pi0s and shots should be built for a tau candidate.

Definition at line 93 of file Reconstruction/tauRecTools/Root/HelperFunctions.cxx.

                                                     {
  // build pi0s and shots for 0-5p taus
  return ( tau.nTracks() <= 5 );
}

GetConstituentP4()

TLorentzVector tauRecTools::GetConstituentP4

(

const xAOD::JetConstituent &

constituent

)

Definition at line 70 of file Reconstruction/tauRecTools/Root/HelperFunctions.cxx.

                                                                                  {
  using namespace tauRecTools::msgHelperFunction;
 
  TLorentzVector constituentP4; 
 
  if( constituent->type() == xAOD::Type::CaloCluster ) {
    const xAOD::CaloCluster* cluster = static_cast<const xAOD::CaloCluster*>( constituent->rawConstituent() );
    constituentP4 = cluster->p4();
  }
  else if ( constituent->type() == xAOD::Type::FlowElement ) {
    const xAOD::FlowElement* fe = static_cast<const xAOD::FlowElement*>( constituent->rawConstituent() );
    constituentP4 = fe->p4();
  }
  else {
    ANA_MSG_ERROR("GetConstituentP4: Seed jet constituent type not supported!");
    constituentP4.SetPtEtaPhiE(constituent.pt(), constituent.eta(), constituent.phi(), constituent.e());
  }
 
  return constituentP4;
}

getJetVertex()

const xAOD::Vertex * tauRecTools::getJetVertex

(

const xAOD::Jet &

jet

)

Return the vertex of jet candidate.

Warning

In trigger, jet candidate does not have a candidate, and an ERROR message will be print out !

Definition at line 20 of file Reconstruction/tauRecTools/Root/HelperFunctions.cxx.

                                                              {
  const xAOD::Vertex* jetVertex = nullptr;
  
  bool isAvailable = jet.getAssociatedObject("OriginVertex", jetVertex); 
  if (! isAvailable) {
    return nullptr;
  }
 
  return jetVertex;
}

getTauAxis()

TLorentzVector tauRecTools::getTauAxis	(	const xAOD::TauJet &	tau,
		bool	doVertexCorrection = true )

Return the four momentum of the tau axis The tau axis is widely used to select clusters and cells in tau reconstruction.

If doVertexCorrection is true, then IntermediateAxis is returned. Otherwise, DetectorAxis is returned.

Definition at line 33 of file Reconstruction/tauRecTools/Root/HelperFunctions.cxx.

                                                                                     {
  TLorentzVector tauAxis;
  if (doVertexCorrection) {
    tauAxis = tau.p4(xAOD::TauJetParameters::IntermediateAxis);
  }
  else {
    tauAxis = tau.p4(xAOD::TauJetParameters::DetectorAxis);
  }
 
  return tauAxis;
}

isolateClassifiedBits()

xAOD::TauTrack::TrackFlagType tauRecTools::isolateClassifiedBits

(

xAOD::TauTrack::TrackFlagType

flag

)

Definition at line 46 of file Reconstruction/tauRecTools/Root/HelperFunctions.cxx.

                                                                                          {
  const int flagsize=sizeof(flag)*8;
  flag=flag<<(flagsize-xAOD::TauJetParameters::classifiedFake-1);
  flag=flag>>(flagsize-xAOD::TauJetParameters::classifiedCharged+1);
  return flag;
}

parseString()

std::vector< TString > tauRecTools::parseString	(	const TString &	str,
		const TString &	delim = "," )

parseStringMVAUtilsBDT()

std::vector< TString > tauRecTools::parseStringMVAUtilsBDT	(	const TString &	str,
		const TString &	delim = "," )

sortTracks()

bool tauRecTools::sortTracks	(	const ElementLink< xAOD::TauTrackContainer > &	l1,
		const ElementLink< xAOD::TauTrackContainer > &	l2 )

Definition at line 54 of file Reconstruction/tauRecTools/Root/HelperFunctions.cxx.

{
  //should we be safe and ask if the links are available?
  const xAOD::TauTrack* xTrack1 = *l1;
  const xAOD::TauTrack* xTrack2 = *l2;
 
  //return classified charged, then isolation (wide tracks), else by pt
  xAOD::TauTrack::TrackFlagType f1 = isolateClassifiedBits(xTrack1->flagSet());
  xAOD::TauTrack::TrackFlagType f2 = isolateClassifiedBits(xTrack2->flagSet());
 
  if(f1==f2)
    return xTrack1->pt()>xTrack2->pt();
  return f1<f2;
}