TauTagTools Namespace Reference

Classes
class	filterChargedAndNeutralsByPt
class	refVectorPtSorter
class	sortByAscendingPt
class	sortByDescendingPt
class	sortByOpeningAngleAscending
class	sortByOpeningAngleDescending
class	sortByOpeningDistance
class	sortRefsByOpeningDistance

Functions
double	computeAngle (const math::XYZVector &vec1, const math::XYZVector &vec2)
TFormula	computeConeSizeTFormula (const string &ConeSizeFormula, const char *errorMessage)
TFormula	computeConeSizeTFormula (const std::string &ConeSizeFormula, const char *errorMessage)
double	computeDeltaR (const math::XYZVector &vec1, const math::XYZVector &vec2)
std::vector< reco::CandidatePtr >	filteredPFChargedHadrCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double ChargedHadrCand_tkminPt, int ChargedHadrCand_tkminPixelHitsn, int ChargedHadrCand_tkminTrackerHitsn, double ChargedHadrCand_tkmaxipt, double ChargedHadrCand_tkmaxChi2, reco::Vertex pV)
std::vector< reco::CandidatePtr >	filteredPFChargedHadrCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double ChargedHadrCand_tkminPt, int ChargedHadrCand_tkminPixelHitsn, int ChargedHadrCand_tkminTrackerHitsn, double ChargedHadrCand_tkmaxipt, double ChargedHadrCand_tkmaxChi2, double ChargedHadrCand_tktorefpointmaxDZ, reco::Vertex pV, double refpoint_Z)
std::vector< reco::CandidatePtr >	filteredPFChargedHadrCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double ChargedHadrCand_tkminPt, int ChargedHadrCand_tkminPixelHitsn, int ChargedHadrCand_tkminTrackerHitsn, double ChargedHadrCand_tkmaxipt, double ChargedHadrCand_tkmaxChi2, Vertex pv)
std::vector< reco::CandidatePtr >	filteredPFChargedHadrCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double ChargedHadrCand_tkminPt, int ChargedHadrCand_tkminPixelHitsn, int ChargedHadrCand_tkminTrackerHitsn, double ChargedHadrCand_tkmaxipt, double ChargedHadrCand_tkmaxChi2, double ChargedHadrCand_tktorefpointmaxDZ, Vertex pv, double refpoint_Z)
std::vector< reco::CandidatePtr >	filteredPFChargedHadrCandsByNumTrkHits (const std::vector< reco::CandidatePtr > &theInitialPFCands, int ChargedHadrCand_tkminTrackerHitsn)
std::vector< reco::CandidatePtr >	filteredPFChargedHadrCandsByNumTrkHits (const std::vector< reco::CandidatePtr > &theInitialPFCands, int ChargedHadrCand_tkminTrackerHitsn)
std::vector< reco::CandidatePtr >	filteredPFGammaCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double GammaCand_EcalclusMinEt)
std::vector< reco::CandidatePtr >	filteredPFGammaCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double GammaCand_EcalclusMinEt)
std::vector< reco::CandidatePtr >	filteredPFNeutrHadrCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double NeutrHadrCand_HcalclusMinEt)
std::vector< reco::CandidatePtr >	filteredPFNeutrHadrCands (const std::vector< reco::CandidatePtr > &theInitialPFCands, double NeutrHadrCand_HcalclusMinEt)
reco::TrackRefVector	filteredTracks (const reco::TrackRefVector &theInitialTracks, double tkminPt, int tkminPixelHitsn, int tkminTrackerHitsn, double tkmaxipt, double tkmaxChi2, reco::Vertex pV)
reco::TrackRefVector	filteredTracks (const reco::TrackRefVector &theInitialTracks, double tkminPt, int tkminPixelHitsn, int tkminTrackerHitsn, double tkmaxipt, double tkmaxChi2, double tktorefpointmaxDZ, reco::Vertex pV, double refpoint_Z)
reco::TrackRefVector	filteredTracksByNumTrkHits (const reco::TrackRefVector &theInitialTracks, int tkminTrackerHitsn)
math::XYZPoint	propagTrackECALSurfContactPoint (const MagneticField *, reco::TrackRef)
void	replaceSubStr (std::string &s, const std::string &oldSubStr, const std::string &newSubStr)
void	replaceSubStr (string &s, const string &oldSubStr, const string &newSubStr)
void	sortRefVectorByPt (std::vector< reco::CandidatePtr > &)
void	sortRefVectorByPt (std::vector< reco::CandidatePtr > &vec)

Function Documentation

double TauTagTools::computeAngle	(	const math::XYZVector &	vec1,
		const math::XYZVector &	vec2
	)

Definition at line 13 of file TauTagTools.cc.

Referenced by PFTauElementsOperators::computeInsideOutContents().

   {  
      Angle<math::XYZVector> myMetricAngle_;
      return myMetricAngle_(vec1, vec2); 
   }

TFormula TauTagTools::computeConeSizeTFormula	(	const string &	ConeSizeFormula,
		const char *	errorMessage
	)

Definition at line 18 of file TauTagTools.cc.

References Exception, and replaceSubStr().

                                                                                        {
  //--- check functional form 
  //    given as configuration parameter for matching and signal cone sizes;
  //
  //    The size of a cone may depend on the energy "E" and/or transverse energy "ET" of the tau-jet candidate.
  //    Alternatively one can additionally use "JetOpeningDR", which specifies the opening angle of the seed jet.
  //    Any functional form that is supported by ROOT's TFormula class can be used (e.g. "3.0/E", "0.25/sqrt(ET)")
  //
  //    replace "E"  by TFormula variable "x"
  //            "ET"                      "y"
  TFormula ConeSizeTFormula;
  string ConeSizeFormulaStr = ConeSizeFormula;
  replaceSubStr(ConeSizeFormulaStr,"JetOpeningDR", "z");
  replaceSubStr(ConeSizeFormulaStr,"ET","y");
  replaceSubStr(ConeSizeFormulaStr,"E","x");
  ConeSizeTFormula.SetName("ConeSize");
  ConeSizeTFormula.SetTitle(ConeSizeFormulaStr.data()); // the function definition is actually stored in the "Title" data-member of the TFormula object
  int errorFlag = ConeSizeTFormula.Compile();
  if (errorFlag!= 0) {
    throw cms::Exception("") << "\n unsupported functional Form for " << errorMessage << " " << ConeSizeFormula << std::endl
                 << "Please check that the Definition in \"" << ConeSizeTFormula.GetName() << "\" only contains the variables \"E\" or \"ET\""
                 << " and Functions that are supported by ROOT's TFormular Class." << std::endl;
  }else return ConeSizeTFormula;
}

TFormula TauTagTools::computeConeSizeTFormula	(	const std::string &	ConeSizeFormula,
		const char *	errorMessage
	)

Referenced by CaloRecoTauAlgorithm::CaloRecoTauAlgorithm(), HPSPFRecoTauAlgorithm::configure(), and PFRecoTauAlgorithm::PFRecoTauAlgorithm().

double TauTagTools::computeDeltaR	(	const math::XYZVector &	vec1,
		const math::XYZVector &	vec2
	)

Definition at line 8 of file TauTagTools.cc.

Referenced by PFRecoTauAlgorithm::buildPFTau(), and PFTauElementsOperators::computeInsideOutContents().

   { 
      DeltaR<math::XYZVector> myMetricDR_;
      return myMetricDR_(vec1, vec2); 
   }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFChargedHadrCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	ChargedHadrCand_tkminPt,
		int	ChargedHadrCand_tkminPixelHitsn,
		int	ChargedHadrCand_tkminTrackerHitsn,
		double	ChargedHadrCand_tkmaxipt,
		double	ChargedHadrCand_tkmaxChi2,
		reco::Vertex	pV
	)

Definition at line 119 of file TauTagTools.cc.

References funct::abs(), PFRecoTauTagInfoProducer_cfi::ChargedHadrCand_tkminPixelHitsn, filteredPFChargedHadrCands(), and reco::Vertex::position().

Referenced by PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo(), PFTauElementsOperators::PFGammaCandsInOutEllipse(), and PFTauElementsOperators::setAreaMetricrecoElementsmaxabsEta().

                                                                                                                                                                                                                                                                                                   {
    std::vector<reco::CandidatePtr> filteredPFChargedHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 211 || std::abs((*iPFCand)->pdgId()) == 13 || std::abs((*iPFCand)->pdgId()) == 11){
    // *** Whether the charged hadron candidate will be selected or not depends on its rec. tk properties. 
    const reco::Track* PFChargedHadrCand_rectk = (*iPFCand)->bestTrack();
    if (PFChargedHadrCand_rectk != nullptr) {
      if ((*PFChargedHadrCand_rectk).pt()>=ChargedHadrCand_tkminPt &&
          (*PFChargedHadrCand_rectk).normalizedChi2()<=ChargedHadrCand_tkmaxChi2 &&
          fabs((*PFChargedHadrCand_rectk).dxy(pv.position()))<=ChargedHadrCand_tkmaxipt &&
          (*PFChargedHadrCand_rectk).numberOfValidHits()>=ChargedHadrCand_tkminTrackerHitsn &&
          (*PFChargedHadrCand_rectk).hitPattern().numberOfValidPixelHits()>=ChargedHadrCand_tkminPixelHitsn) 
        filteredPFChargedHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFChargedHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFChargedHadrCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	ChargedHadrCand_tkminPt,
		int	ChargedHadrCand_tkminPixelHitsn,
		int	ChargedHadrCand_tkminTrackerHitsn,
		double	ChargedHadrCand_tkmaxipt,
		double	ChargedHadrCand_tkmaxChi2,
		double	ChargedHadrCand_tktorefpointmaxDZ,
		reco::Vertex	pV,
		double	refpoint_Z
	)

Definition at line 137 of file TauTagTools.cc.

References funct::abs(), reco::Vertex::isFake(), and reco::Vertex::position().

Referenced by filteredPFChargedHadrCands(), and filteredPFChargedHadrCandsByNumTrkHits().

                                                                                                                                                                                                                                                                                                                                                              {
    if(pv.isFake()) ChargedHadrCand_tktorefpointmaxDZ = 30.;
    std::vector<reco::CandidatePtr> filteredPFChargedHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 211 || std::abs((*iPFCand)->pdgId()) == 13 || std::abs((*iPFCand)->pdgId()) == 11){
    // *** Whether the charged hadron candidate will be selected or not depends on its rec. tk properties. 
    const reco::Track* PFChargedHadrCand_rectk = (*iPFCand)->bestTrack();
    if (PFChargedHadrCand_rectk != nullptr) {
      if ((*PFChargedHadrCand_rectk).pt()>=ChargedHadrCand_tkminPt &&
          (*PFChargedHadrCand_rectk).normalizedChi2()<=ChargedHadrCand_tkmaxChi2 &&
          fabs((*PFChargedHadrCand_rectk).dxy(pv.position()))<=ChargedHadrCand_tkmaxipt &&
          (*PFChargedHadrCand_rectk).numberOfValidHits()>=ChargedHadrCand_tkminTrackerHitsn &&
          (*PFChargedHadrCand_rectk).hitPattern().numberOfValidPixelHits()>=ChargedHadrCand_tkminPixelHitsn &&
          fabs((*PFChargedHadrCand_rectk).dz(pv.position()))<=ChargedHadrCand_tktorefpointmaxDZ)
        filteredPFChargedHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFChargedHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFChargedHadrCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	ChargedHadrCand_tkminPt,
		int	ChargedHadrCand_tkminPixelHitsn,
		int	ChargedHadrCand_tkminTrackerHitsn,
		double	ChargedHadrCand_tkmaxipt,
		double	ChargedHadrCand_tkmaxChi2,
		Vertex	pv
	)

Definition at line 119 of file TauTagTools.cc.

References funct::abs(), PFRecoTauTagInfoProducer_cfi::ChargedHadrCand_tkminPixelHitsn, filteredPFChargedHadrCands(), and reco::Vertex::position().

Referenced by PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo(), PFTauElementsOperators::PFGammaCandsInOutEllipse(), and PFTauElementsOperators::setAreaMetricrecoElementsmaxabsEta().

                                                                                                                                                                                                                                                                                                   {
    std::vector<reco::CandidatePtr> filteredPFChargedHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 211 || std::abs((*iPFCand)->pdgId()) == 13 || std::abs((*iPFCand)->pdgId()) == 11){
    // *** Whether the charged hadron candidate will be selected or not depends on its rec. tk properties. 
    const reco::Track* PFChargedHadrCand_rectk = (*iPFCand)->bestTrack();
    if (PFChargedHadrCand_rectk != nullptr) {
      if ((*PFChargedHadrCand_rectk).pt()>=ChargedHadrCand_tkminPt &&
          (*PFChargedHadrCand_rectk).normalizedChi2()<=ChargedHadrCand_tkmaxChi2 &&
          fabs((*PFChargedHadrCand_rectk).dxy(pv.position()))<=ChargedHadrCand_tkmaxipt &&
          (*PFChargedHadrCand_rectk).numberOfValidHits()>=ChargedHadrCand_tkminTrackerHitsn &&
          (*PFChargedHadrCand_rectk).hitPattern().numberOfValidPixelHits()>=ChargedHadrCand_tkminPixelHitsn) 
        filteredPFChargedHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFChargedHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFChargedHadrCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	ChargedHadrCand_tkminPt,
		int	ChargedHadrCand_tkminPixelHitsn,
		int	ChargedHadrCand_tkminTrackerHitsn,
		double	ChargedHadrCand_tkmaxipt,
		double	ChargedHadrCand_tkmaxChi2,
		double	ChargedHadrCand_tktorefpointmaxDZ,
		Vertex	pv,
		double	refpoint_Z
	)

Definition at line 137 of file TauTagTools.cc.

References funct::abs(), reco::Vertex::isFake(), and reco::Vertex::position().

Referenced by filteredPFChargedHadrCands(), and filteredPFChargedHadrCandsByNumTrkHits().

                                                                                                                                                                                                                                                                                                                                                              {
    if(pv.isFake()) ChargedHadrCand_tktorefpointmaxDZ = 30.;
    std::vector<reco::CandidatePtr> filteredPFChargedHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 211 || std::abs((*iPFCand)->pdgId()) == 13 || std::abs((*iPFCand)->pdgId()) == 11){
    // *** Whether the charged hadron candidate will be selected or not depends on its rec. tk properties. 
    const reco::Track* PFChargedHadrCand_rectk = (*iPFCand)->bestTrack();
    if (PFChargedHadrCand_rectk != nullptr) {
      if ((*PFChargedHadrCand_rectk).pt()>=ChargedHadrCand_tkminPt &&
          (*PFChargedHadrCand_rectk).normalizedChi2()<=ChargedHadrCand_tkmaxChi2 &&
          fabs((*PFChargedHadrCand_rectk).dxy(pv.position()))<=ChargedHadrCand_tkmaxipt &&
          (*PFChargedHadrCand_rectk).numberOfValidHits()>=ChargedHadrCand_tkminTrackerHitsn &&
          (*PFChargedHadrCand_rectk).hitPattern().numberOfValidPixelHits()>=ChargedHadrCand_tkminPixelHitsn &&
          fabs((*PFChargedHadrCand_rectk).dz(pv.position()))<=ChargedHadrCand_tktorefpointmaxDZ)
        filteredPFChargedHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFChargedHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFChargedHadrCandsByNumTrkHits	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		int	ChargedHadrCand_tkminTrackerHitsn
	)

Definition at line 104 of file TauTagTools.cc.

References funct::abs(), PFRecoTauTagInfoProducer_cfi::ChargedHadrCand_tkminTrackerHitsn, and filteredPFChargedHadrCands().

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                 {
    std::vector<reco::CandidatePtr> filteredPFChargedHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 211 || std::abs((*iPFCand)->pdgId()) == 13 || std::abs((*iPFCand)->pdgId()) == 11){
    // *** Whether the charged hadron candidate will be selected or not depends on its rec. tk properties. 
    const reco::Track* PFChargedHadrCand_rectk = (*iPFCand)->bestTrack();
    if (PFChargedHadrCand_rectk != nullptr) {
      if ( (*PFChargedHadrCand_rectk).numberOfValidHits()>=ChargedHadrCand_tkminTrackerHitsn )
        filteredPFChargedHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFChargedHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFChargedHadrCandsByNumTrkHits	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		int	ChargedHadrCand_tkminTrackerHitsn
	)

Definition at line 104 of file TauTagTools.cc.

References funct::abs(), PFRecoTauTagInfoProducer_cfi::ChargedHadrCand_tkminTrackerHitsn, and filteredPFChargedHadrCands().

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                 {
    std::vector<reco::CandidatePtr> filteredPFChargedHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 211 || std::abs((*iPFCand)->pdgId()) == 13 || std::abs((*iPFCand)->pdgId()) == 11){
    // *** Whether the charged hadron candidate will be selected or not depends on its rec. tk properties. 
    const reco::Track* PFChargedHadrCand_rectk = (*iPFCand)->bestTrack();
    if (PFChargedHadrCand_rectk != nullptr) {
      if ( (*PFChargedHadrCand_rectk).numberOfValidHits()>=ChargedHadrCand_tkminTrackerHitsn )
        filteredPFChargedHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFChargedHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFGammaCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	GammaCand_EcalclusMinEt
	)

Definition at line 171 of file TauTagTools.cc.

References funct::abs(), and PFRecoTauTagInfoProducer_cfi::GammaCand_EcalclusMinEt.

Referenced by PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo().

                                                                                                                                       {
    std::vector<reco::CandidatePtr> filteredPFGammaCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 22){
    // *** Whether the gamma candidate will be selected or not depends on its rec. ECAL cluster properties. 
    if ((**iPFCand).et()>=GammaCand_EcalclusMinEt){
      filteredPFGammaCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFGammaCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFGammaCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	GammaCand_EcalclusMinEt
	)

Definition at line 171 of file TauTagTools.cc.

References funct::abs(), and PFRecoTauTagInfoProducer_cfi::GammaCand_EcalclusMinEt.

Referenced by PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo().

                                                                                                                                       {
    std::vector<reco::CandidatePtr> filteredPFGammaCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 22){
    // *** Whether the gamma candidate will be selected or not depends on its rec. ECAL cluster properties. 
    if ((**iPFCand).et()>=GammaCand_EcalclusMinEt){
      filteredPFGammaCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFGammaCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFNeutrHadrCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	NeutrHadrCand_HcalclusMinEt
	)

Definition at line 158 of file TauTagTools.cc.

References funct::abs(), and PFRecoTauTagInfoProducer_cfi::NeutrHadrCand_HcalclusMinEt.

Referenced by PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo().

                                                                                                                                               {
    std::vector<reco::CandidatePtr> filteredPFNeutrHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 130){
    // *** Whether the neutral hadron candidate will be selected or not depends on its rec. HCAL cluster properties. 
    if ((**iPFCand).et()>=NeutrHadrCand_HcalclusMinEt){
      filteredPFNeutrHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFNeutrHadrCands;
  }

std::vector<reco::CandidatePtr> TauTagTools::filteredPFNeutrHadrCands	(	const std::vector< reco::CandidatePtr > &	theInitialPFCands,
		double	NeutrHadrCand_HcalclusMinEt
	)

Definition at line 158 of file TauTagTools.cc.

References funct::abs(), and PFRecoTauTagInfoProducer_cfi::NeutrHadrCand_HcalclusMinEt.

Referenced by PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo().

                                                                                                                                               {
    std::vector<reco::CandidatePtr> filteredPFNeutrHadrCands;
    for(std::vector<reco::CandidatePtr>::const_iterator iPFCand=theInitialPFCands.begin();iPFCand!=theInitialPFCands.end();iPFCand++){
      if (std::abs((*iPFCand)->pdgId()) == 130){
    // *** Whether the neutral hadron candidate will be selected or not depends on its rec. HCAL cluster properties. 
    if ((**iPFCand).et()>=NeutrHadrCand_HcalclusMinEt){
      filteredPFNeutrHadrCands.push_back(*iPFCand);
    }
      }
    }
    return filteredPFNeutrHadrCands;
  }

TrackRefVector TauTagTools::filteredTracks	(	const reco::TrackRefVector &	theInitialTracks,
		double	tkminPt,
		int	tkminPixelHitsn,
		int	tkminTrackerHitsn,
		double	tkmaxipt,
		double	tkmaxChi2,
		reco::Vertex	pV
	)

Definition at line 77 of file TauTagTools.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::end(), reco::Vertex::position(), edm::RefVector< C, T, F >::push_back(), and CaloRecoTauTagInfoProducer_cfi::tkminPixelHitsn.

Referenced by CaloRecoTauTagInfoAlgorithm::buildCaloTauTagInfo(), PFRecoTauTagInfoAlgorithm::buildPFTauTagInfo(), filteredTracks(), filteredTracksByNumTrkHits(), and CaloRecoTauTagInfoAlgorithm::filterTracksByQualityBit().

                                                                                                                                                                            {
    TrackRefVector filteredTracks;
    for(TrackRefVector::const_iterator iTk=theInitialTracks.begin();iTk!=theInitialTracks.end();iTk++){
      if ((**iTk).pt()>=tkminPt &&
      (**iTk).normalizedChi2()<=tkmaxChi2 &&
      fabs((**iTk).dxy(pv.position()))<=tkmaxipt &&
      (**iTk).numberOfValidHits()>=tkminTrackerHitsn &&
      (**iTk).hitPattern().numberOfValidPixelHits()>=tkminPixelHitsn)
    filteredTracks.push_back(*iTk);
    }
    return filteredTracks;
  }

TrackRefVector TauTagTools::filteredTracks	(	const reco::TrackRefVector &	theInitialTracks,
		double	tkminPt,
		int	tkminPixelHitsn,
		int	tkminTrackerHitsn,
		double	tkmaxipt,
		double	tkmaxChi2,
		double	tktorefpointmaxDZ,
		reco::Vertex	pV,
		double	refpoint_Z
	)

Definition at line 89 of file TauTagTools.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::end(), filteredTracks(), reco::Vertex::isFake(), reco::Vertex::position(), and edm::RefVector< C, T, F >::push_back().

                                                                                                                                                                                                                       {
    TrackRefVector filteredTracks;
    for(TrackRefVector::const_iterator iTk=theInitialTracks.begin();iTk!=theInitialTracks.end();iTk++){
      if(pv.isFake()) tktorefpointmaxDZ=30.;
      if ((**iTk).pt()>=tkminPt &&
      (**iTk).normalizedChi2()<=tkmaxChi2 &&
      fabs((**iTk).dxy(pv.position()))<=tkmaxipt &&
      (**iTk).numberOfValidHits()>=tkminTrackerHitsn &&
      (**iTk).hitPattern().numberOfValidPixelHits()>=tkminPixelHitsn &&
      fabs((**iTk).dz(pv.position()))<=tktorefpointmaxDZ)
    filteredTracks.push_back(*iTk);
    }
    return filteredTracks;
  }

TrackRefVector TauTagTools::filteredTracksByNumTrkHits	(	const reco::TrackRefVector &	theInitialTracks,
		int	tkminTrackerHitsn
	)

Definition at line 68 of file TauTagTools.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::end(), filteredTracks(), edm::RefVector< C, T, F >::push_back(), and CaloRecoTauTagInfoProducer_cfi::tkminTrackerHitsn.

Referenced by CaloRecoTauAlgorithm::buildCaloTau(), and PFRecoTauAlgorithm::buildPFTau().

                                                                                                          {
    TrackRefVector filteredTracks;
    for(TrackRefVector::const_iterator iTk=theInitialTracks.begin();iTk!=theInitialTracks.end();iTk++){
      if ( (**iTk).numberOfValidHits() >= tkminTrackerHitsn )
    filteredTracks.push_back(*iTk);
    }
    return filteredTracks;
  }

math::XYZPoint TauTagTools::propagTrackECALSurfContactPoint	(	const MagneticField *	theMagField,
		reco::TrackRef	theTrack
	)

Definition at line 184 of file TauTagTools.cc.

References alongMomentum, AnalyticalPropagator_cfi::AnalyticalPropagator, ECALBounds::barrel_halfLength(), ECALBounds::barrel_innerradius(), ECALBounds::barrelBound(), MillePedeFileConverter_cfg::e, PV3DBase< T, PVType, FrameType >::eta(), TrajectoryStateOnSurface::globalParameters(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), ECALBounds::negativeEndcapDisk(), PV3DBase< T, PVType, FrameType >::perp(), GlobalTrajectoryParameters::position(), ECALBounds::positiveEndcapDisk(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by CaloRecoTauAlgorithm::buildCaloTau(), and CaloRecoTauTagInfoAlgorithm::getNeutralEcalBasicClusters().

                                                                                                  { 
    AnalyticalPropagator thefwdPropagator(theMagField,alongMomentum);
    math::XYZPoint propTrack_XYZPoint(0.,0.,0.);
    
    // get the initial Track FreeTrajectoryState - at outermost point position if possible, else at innermost point position:
    GlobalVector theTrack_initialGV(0.,0.,0.);
    GlobalPoint theTrack_initialGP(0.,0.,0.);
    if(theTrack->outerOk()){
      GlobalVector theTrack_initialoutermostGV(theTrack->outerMomentum().x(),theTrack->outerMomentum().y(),theTrack->outerMomentum().z());
      GlobalPoint theTrack_initialoutermostGP(theTrack->outerPosition().x(),theTrack->outerPosition().y(),theTrack->outerPosition().z());
      theTrack_initialGV=theTrack_initialoutermostGV;
      theTrack_initialGP=theTrack_initialoutermostGP;
    } else if(theTrack->innerOk()){
      GlobalVector theTrack_initialinnermostGV(theTrack->innerMomentum().x(),theTrack->innerMomentum().y(),theTrack->innerMomentum().z());
      GlobalPoint theTrack_initialinnermostGP(theTrack->innerPosition().x(),theTrack->innerPosition().y(),theTrack->innerPosition().z());
      theTrack_initialGV=theTrack_initialinnermostGV;
      theTrack_initialGP=theTrack_initialinnermostGP;
    } else return (propTrack_XYZPoint);
    GlobalTrajectoryParameters theTrack_initialGTPs(theTrack_initialGP,theTrack_initialGV,theTrack->charge(),&*theMagField);
    // FIX THIS !!!
    // need to convert from perigee to global or helix (curvilinear) frame
    // for now just an arbitrary matrix.
    AlgebraicSymMatrix66 covM=AlgebraicMatrixID(); covM *= 1e-6; // initialize to sigma=1e-3
    CartesianTrajectoryError cov_CTE(covM);
    FreeTrajectoryState Track_initialFTS(theTrack_initialGTPs,cov_CTE);
    // ***
  
    // propagate to ECAL surface: 
    double ECALcorner_tantheta=ECALBounds::barrel_innerradius()/ECALBounds::barrel_halfLength();
    TrajectoryStateOnSurface Track_propagatedonECAL_TSOS=thefwdPropagator.propagate((Track_initialFTS),ECALBounds::barrelBound());
    if(!Track_propagatedonECAL_TSOS.isValid() || fabs(Track_propagatedonECAL_TSOS.globalParameters().position().perp()/Track_propagatedonECAL_TSOS.globalParameters().position().z())<ECALcorner_tantheta) {
      if(Track_propagatedonECAL_TSOS.isValid() && fabs(Track_propagatedonECAL_TSOS.globalParameters().position().perp()/Track_propagatedonECAL_TSOS.globalParameters().position().z())<ECALcorner_tantheta){     
    if(Track_propagatedonECAL_TSOS.globalParameters().position().eta()>0.){
      Track_propagatedonECAL_TSOS=thefwdPropagator.propagate((Track_initialFTS),ECALBounds::positiveEndcapDisk());
    }else{ 
      Track_propagatedonECAL_TSOS=thefwdPropagator.propagate((Track_initialFTS),ECALBounds::negativeEndcapDisk());
    }
      }
      if(!Track_propagatedonECAL_TSOS.isValid()){
    if((Track_initialFTS).position().eta()>0.){
      Track_propagatedonECAL_TSOS=thefwdPropagator.propagate((Track_initialFTS),ECALBounds::positiveEndcapDisk());
    }else{ 
      Track_propagatedonECAL_TSOS=thefwdPropagator.propagate((Track_initialFTS),ECALBounds::negativeEndcapDisk());
    }
      }
    }
    if(Track_propagatedonECAL_TSOS.isValid()){
      math::XYZPoint validpropTrack_XYZPoint(Track_propagatedonECAL_TSOS.globalPosition().x(),
                         Track_propagatedonECAL_TSOS.globalPosition().y(),
                         Track_propagatedonECAL_TSOS.globalPosition().z());
      propTrack_XYZPoint=validpropTrack_XYZPoint;
    }
    return (propTrack_XYZPoint);
  }

void TauTagTools::replaceSubStr	(	std::string &	s,
		const std::string &	oldSubStr,
		const std::string &	newSubStr
	)

void TauTagTools::replaceSubStr	(	string &	s,
		const string &	oldSubStr,
		const string &	newSubStr
	)

Definition at line 42 of file TauTagTools.cc.

Referenced by computeConeSizeTFormula().

                                                                             {
  //--- protect replacement algorithm
  //    from case that oldSubStr and newSubStr are equal
  //    (nothing to be done anyway)
  if ( oldSubStr == newSubStr ) return;
  
  //--- protect replacement algorithm
  //    from case that oldSubStr contains no characters
  //    (i.e. matches everything)
  if ( oldSubStr.empty() ) return;
  
  const string::size_type lengthOldSubStr = oldSubStr.size();
  const string::size_type lengthNewSubStr = newSubStr.size();
  
  string::size_type positionPreviousMatch = 0;
  string::size_type positionNextMatch = 0;
  
  //--- consecutively replace all occurences of oldSubStr by newSubStr;
  //    keep iterating until no occurence of oldSubStr left
  while ( (positionNextMatch = s.find(oldSubStr, positionPreviousMatch)) != string::npos ) {
    s.replace(positionNextMatch, lengthOldSubStr, newSubStr);
    positionPreviousMatch = positionNextMatch + lengthNewSubStr;
  } 
}

void TauTagTools::sortRefVectorByPt

(

std::vector< reco::CandidatePtr > &

)

Definition at line 242 of file TauTagTools.cc.

References mps_fire::i, jetUpdater_cfi::sort, and MCScenario_CRAFT1_22X::sorter().

Referenced by HPSPFRecoTauAlgorithm::buildPFTau(), and PFCandidateStripMerger::mergeCandidates().

  {

    std::vector<size_t> indices;
    indices.reserve(vec.size());
    for(unsigned int i=0;i<vec.size();++i)
      indices.push_back(i);
    
    refVectorPtSorter sorter(vec);
    std::sort(indices.begin(),indices.end(),sorter);
    
    
    std::vector<reco::CandidatePtr> sorted;
    sorted.reserve(vec.size());
    
    for(unsigned int i=0;i<indices.size();++i)
      sorted.push_back(vec.at(indices.at(i)));

    vec = sorted;
  }

void TauTagTools::sortRefVectorByPt

(

std::vector< reco::CandidatePtr > &

vec

)

Definition at line 242 of file TauTagTools.cc.

References mps_fire::i, jetUpdater_cfi::sort, and MCScenario_CRAFT1_22X::sorter().

Referenced by HPSPFRecoTauAlgorithm::buildPFTau(), and PFCandidateStripMerger::mergeCandidates().

  {

    std::vector<size_t> indices;
    indices.reserve(vec.size());
    for(unsigned int i=0;i<vec.size();++i)
      indices.push_back(i);
    
    refVectorPtSorter sorter(vec);
    std::sort(indices.begin(),indices.end(),sorter);
    
    
    std::vector<reco::CandidatePtr> sorted;
    sorted.reserve(vec.size());
    
    for(unsigned int i=0;i<indices.size();++i)
      sorted.push_back(vec.at(indices.at(i)));

    vec = sorted;
  }