PFTauElementsOperators Class Reference

#include <PFTauElementsOperators.h>

Inheritance diagram for PFTauElementsOperators:

Public Member Functions
void	computeInsideOutContents (const std::vector< reco::PFCandidatePtr > &theChargedCands, const std::vector< reco::PFCandidatePtr > &theGammaCands, const math::XYZVector &leadTrackVector, const TFormula &coneSizeFormula, double(*ptrToMetricFunction)(const math::XYZVector &, const math::XYZVector &), const double minChargedSize, const double maxChargedSize, const double minNeutralSize, const double maxNeutralSize, const double minChargedPt, const double minNeutralPt, const std::string &outlierCollectorConeMetric, const double outlierCollectorConeSize, std::vector< reco::PFCandidatePtr > &signalChargedObjects, std::vector< reco::PFCandidatePtr > &outlierChargedObjects, std::vector< reco::PFCandidatePtr > &signalGammaObjects, std::vector< reco::PFCandidatePtr > &outlierGammaObjects, bool useScanningAxis)
	compute size of cone using the Inside-Out cone (Author Evan Friis, UC Davis) More...
void	copyCandRefsFilteredByPt (const std::vector< reco::PFCandidatePtr > &theInputCands, std::vector< reco::PFCandidatePtr > &theOutputCands, const double minPt)
	append elements of theInputCands that pass Pt requirement to the end of theOutputCands More...
double	discriminatorByIsolPFCandsEtSum (double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFCandsEtSum (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFCandsEtSum (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFCandsN (int IsolPFCands_maxN=0)
double	discriminatorByIsolPFCandsN (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFCandsN (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFChargedHadrCandsEtSum (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFChargedHadrCandsEtSum (double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFChargedHadrCandsEtSum (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFChargedHadrCandsN (int IsolPFCands_maxN=0)
double	discriminatorByIsolPFChargedHadrCandsN (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFChargedHadrCandsN (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFGammaCandsEtSum (double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFGammaCandsEtSum (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFGammaCandsEtSum (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFGammaCandsN (int IsolPFCands_maxN=0)
double	discriminatorByIsolPFGammaCandsN (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFGammaCandsN (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFNeutrHadrCandsEtSum (double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFNeutrHadrCandsEtSum (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFNeutrHadrCandsEtSum (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, double IsolPFCands_maxEtSum=0)
double	discriminatorByIsolPFNeutrHadrCandsN (int IsolPFCands_maxN=0)
double	discriminatorByIsolPFNeutrHadrCandsN (std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
double	discriminatorByIsolPFNeutrHadrCandsN (const math::XYZVector &myVector, std::string matchingcone_metric, double matchingcone_size, std::string signalcone_metric, double signalcone_size, std::string isolcone_metric, double isolcone_size, bool useOnlyChargedHadrforleadPFCand, double minPt_leadPFCand, double minPt_PFCand, int IsolPFCands_maxN=0)
reco::PFCandidatePtr	leadPFCand (const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFCand (const math::XYZVector &myVector, const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFChargedHadrCand (const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFChargedHadrCand (const math::XYZVector &myVector, const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFGammaCand (const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFGammaCand (const math::XYZVector &myVector, const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFNeutrHadrCand (const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
reco::PFCandidatePtr	leadPFNeutrHadrCand (const math::XYZVector &myVector, const std::string matchingcone_metric, const double matchingcone_size, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFCandsInAnnulus (const std::vector< reco::PFCandidatePtr > &PFCands, const math::XYZVector &myVector, const std::string innercone_metric, const double innercone_size, const std::string outercone_metric, const double outercone_size, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFCandsInAnnulus (const math::XYZVector &myVector, const std::string innercone_metric, const double innercone_size, const std::string outercone_metric, const double outercone_size, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFCandsInCone (const std::vector< reco::PFCandidatePtr > &PFCands, const math::XYZVector &myVector, const std::string conemetric, const double conesize, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFCandsInCone (const math::XYZVector &myVector, const std::string conemetric, const double conesize, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFChargedHadrCandsInAnnulus (const math::XYZVector &myVector, const std::string innercone_metric, const double innercone_size, const std::string outercone_metric, const double outercone_size, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFChargedHadrCandsInAnnulus (const math::XYZVector &myVector, const std::string innercone_metric, const double innercone_size, const std::string outercone_metric, const double outercone_size, const double minPt, const double PFChargedHadrCand_tracktorefpoint_maxDZ, const double refpoint_Z, const reco::Vertex &myPV) const
std::vector< reco::PFCandidatePtr >	PFChargedHadrCandsInCone (const math::XYZVector &myVector, const std::string conemetric, const double conesize, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFChargedHadrCandsInCone (const math::XYZVector &myVector, const std::string conemetric, const double conesize, const double minPt, const double PFChargedHadrCand_tracktorefpoint_maxDZ, const double refpoint_Z, const reco::Vertex &mPV) const
std::vector< reco::PFCandidatePtr >	PFGammaCandsInAnnulus (const math::XYZVector &myVector, const std::string innercone_metric, const double innercone_size, const std::string outercone_metric, const double outercone_size, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFGammaCandsInCone (const math::XYZVector &myVector, const std::string conemetric, const double conesize, const double minPt) const
std::pair< std::vector < reco::PFCandidatePtr > , std::vector < reco::PFCandidatePtr > >	PFGammaCandsInOutEllipse (const std::vector< reco::PFCandidatePtr > &, const reco::PFCandidate &, double rPhi, double rEta, double maxPt) const
std::vector< reco::PFCandidatePtr >	PFNeutrHadrCandsInAnnulus (const math::XYZVector &myVector, const std::string innercone_metric, const double innercone_size, const std::string outercone_metric, const double outercone_size, const double minPt) const
std::vector< reco::PFCandidatePtr >	PFNeutrHadrCandsInCone (const math::XYZVector &myVector, const std::string conemetric, const double conesize, const double minPt) const
	PFTauElementsOperators (reco::PFTau &thePFTau)
void	setAreaMetricrecoElementsmaxabsEta (double x)
	~PFTauElementsOperators ()
Public Member Functions inherited from TauElementsOperators
double	computeConeSize (const TFormula &ConeSizeTFormula, double ConeSizeMin, double ConeSizeMax)
double	computeConeSize (const TFormula &ConeSizeTFormula, double ConeSizeMin, double ConeSizeMax, double transverseEnergy, double energy, double jetOpeningAngle=0.)
double	discriminatorByIsolTracksN (unsigned int isolationAnnulus_Tracksmaxn) const
double	discriminatorByIsolTracksN (const math::XYZVector &coneAxis, std::string matchingConeMetric, double matchingConeSize, double ptLeadingTrackMin, double ptOtherTracksMin, std::string signalConeMetric, double signalConeSize, std::string isolationConeMetric, double isolationConeSize, unsigned int isolationAnnulus_Tracksmaxn) const
double	discriminatorByIsolTracksN (std::string matchingConeMetric, double matchingConeSize, double ptLeadingTrackMin, double ptOtherTracksMin, std::string signalConeMetric, double signalConeSize, std::string isolationConeMetric, double isolationConeSize, unsigned int isolationAnnulus_Tracksmaxn) const
const reco::TrackRef	leadTk (std::string matchingConeMetric, double matchingConeSize, double ptTrackMin) const
const reco::TrackRef	leadTk (const math::XYZVector &jetAxis, std::string matchingConeMetric, double matchingConeSize, double ptTrackMin) const
void	replaceSubStr (std::string &s, const std::string &oldSubStr, const std::string &newSubStr)
	TauElementsOperators ()
	TauElementsOperators (reco::BaseTau &)
const reco::TrackRefVector	tracksInAnnulus (const math::XYZVector &coneAxis, const std::string innerconeMetric, const double innerconeSize, const std::string outerconeMetric, const double outerconeSize, const double ptTrackMin) const
const reco::TrackRefVector	tracksInAnnulus (const math::XYZVector &coneAxis, const std::string innerconeMetric, const double innerconeSize, const std::string outerconeMetric, const double outerconeSize, const double ptTrackMin, const double tracktorefpoint_maxDZ, const double refpoint_Z, const reco::Vertex &myPV) const
const reco::TrackRefVector	tracksInCone (const math::XYZVector &coneAxis, const std::string coneMetric, const double coneSize, const double ptTrackMin) const
const reco::TrackRefVector	tracksInCone (const math::XYZVector &coneAxis, const std::string coneMetric, const double coneSize, const double ptTrackMin, const double tracktorefpoint_maxDZ, const double refpoint_Z, const reco::Vertex &myPV) const
	~TauElementsOperators ()

Private Member Functions
double	computeAngle (const math::XYZVector &vec1, const math::XYZVector &vec2)
double	computeDeltaR (const math::XYZVector &vec1, const math::XYZVector &vec2)

Private Attributes
double	AreaMetric_recoElements_maxabsEta_
std::vector< reco::PFCandidatePtr >	IsolPFCands_
std::vector< reco::PFCandidatePtr >	IsolPFChargedHadrCands_
std::vector< reco::PFCandidatePtr >	IsolPFGammaCands_
std::vector< reco::PFCandidatePtr >	IsolPFNeutrHadrCands_
Angle< math::XYZVector >	metricAngle_
DeltaR< math::XYZVector >	metricDR_
ElementsInEllipse < reco::PFCandidate, reco::PFCandidate >	PFCandidatesInEllipse_
std::vector< reco::PFCandidatePtr >	PFCands_
ElementsInAnnulus < math::XYZVector, Angle < math::XYZVector >, Angle < math::XYZVector > , reco::PFCandidate >	PFCandsinAnnulus_innerAngleouterAnglemetrics_
ElementsInAnnulus < math::XYZVector, Angle < math::XYZVector >, DeltaR < math::XYZVector > , reco::PFCandidate >	PFCandsinAnnulus_innerAngleouterDRmetrics_
ElementsInAnnulus < math::XYZVector, DeltaR < math::XYZVector >, Angle < math::XYZVector > , reco::PFCandidate >	PFCandsinAnnulus_innerDRouterAnglemetrics_
ElementsInAnnulus < math::XYZVector, DeltaR < math::XYZVector >, DeltaR < math::XYZVector > , reco::PFCandidate >	PFCandsinAnnulus_innerDRouterDRmetrics_
ElementsInCone < math::XYZVector, Angle < math::XYZVector > , reco::PFCandidate >	PFCandsinCone_Anglemetric_
ElementsInCone < math::XYZVector, DeltaR < math::XYZVector > , reco::PFCandidate >	PFCandsinCone_DRmetric_
std::vector< reco::PFCandidatePtr >	PFChargedHadrCands_
std::vector< reco::PFCandidatePtr >	PFGammaCands_
reco::PFJetRef	PFJetRef_
std::vector< reco::PFCandidatePtr >	PFNeutrHadrCands_

Additional Inherited Members
Protected Attributes inherited from TauElementsOperators
double	AreaMetric_recoElements_maxabsEta_
reco::BaseTau &	BaseTau_
TFormula	ConeSizeTFormula
reco::TrackRefVector	IsolTracks_
Angle< math::XYZVector >	metricAngle_
DeltaR< math::XYZVector >	metricDR_
reco::TrackRefVector	Tracks_
ElementsInAnnulusRef < math::XYZVector, Angle < math::XYZVector >, Angle < math::XYZVector > , reco::TrackCollection >	TracksinAnnulus_innerAngleouterAnglemetrics_
ElementsInAnnulusRef < math::XYZVector, Angle < math::XYZVector >, DeltaR < math::XYZVector > , reco::TrackCollection >	TracksinAnnulus_innerAngleouterDRmetrics_
ElementsInAnnulusRef < math::XYZVector, DeltaR < math::XYZVector >, Angle < math::XYZVector > , reco::TrackCollection >	TracksinAnnulus_innerDRouterAnglemetrics_
ElementsInAnnulusRef < math::XYZVector, DeltaR < math::XYZVector >, DeltaR < math::XYZVector > , reco::TrackCollection >	TracksinAnnulus_innerDRouterDRmetrics_
ElementsInConeRef < math::XYZVector, Angle < math::XYZVector > , reco::TrackCollection >	TracksinCone_Anglemetric_
ElementsInConeRef < math::XYZVector, DeltaR < math::XYZVector > , reco::TrackCollection >	TracksinCone_DRmetric_

Detailed Description

Definition at line 31 of file PFTauElementsOperators.h.

Constructor & Destructor Documentation

PFTauElementsOperators::PFTauElementsOperators

(

reco::PFTau &

thePFTau

)

Definition at line 6 of file PFTauElementsOperators.cc.

References reco::PFTau::isolationPFCands(), reco::PFTau::isolationPFChargedHadrCands(), reco::PFTau::isolationPFGammaCands(), reco::PFTau::isolationPFNeutrHadrCands(), IsolPFCands_, IsolPFChargedHadrCands_, IsolPFGammaCands_, IsolPFNeutrHadrCands_, PFCands_, PFChargedHadrCands_, PFGammaCands_, PFJetRef_, PFNeutrHadrCands_, reco::PFTau::pfTauTagInfoRef(), and TauElementsOperators::Tracks_.

                                                              : TauElementsOperators(thePFTau),AreaMetric_recoElements_maxabsEta_(2.5){
   PFJetRef_=thePFTau.pfTauTagInfoRef()->pfjetRef();
   PFCands_=thePFTau.pfTauTagInfoRef()->PFCands();
   PFChargedHadrCands_=thePFTau.pfTauTagInfoRef()->PFChargedHadrCands();
   PFNeutrHadrCands_=thePFTau.pfTauTagInfoRef()->PFNeutrHadrCands();
   PFGammaCands_=thePFTau.pfTauTagInfoRef()->PFGammaCands();
   IsolPFCands_=thePFTau.isolationPFCands();
   IsolPFChargedHadrCands_=thePFTau.isolationPFChargedHadrCands();
   IsolPFNeutrHadrCands_=thePFTau.isolationPFNeutrHadrCands();
   IsolPFGammaCands_=thePFTau.isolationPFGammaCands();
   Tracks_=thePFTau.pfTauTagInfoRef()->Tracks();
}

PFTauElementsOperators::~PFTauElementsOperators ( )

inline

Definition at line 34 of file PFTauElementsOperators.h.

{}   

Member Function Documentation

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

private

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

private

void PFTauElementsOperators::computeInsideOutContents	(	const std::vector< reco::PFCandidatePtr > &	theChargedCands,
		const std::vector< reco::PFCandidatePtr > &	theGammaCands,
		const math::XYZVector &	leadTrackVector,
		const TFormula &	coneSizeFormula,
		double(*)(const math::XYZVector &, const math::XYZVector &)	ptrToMetricFunction,
		const double	minChargedSize,
		const double	maxChargedSize,
		const double	minNeutralSize,
		const double	maxNeutralSize,
		const double	minChargedPt,
		const double	minNeutralPt,
		const std::string &	outlierCollectorConeMetric,
		const double	outlierCollectorConeSize,
		std::vector< reco::PFCandidatePtr > &	signalChargedObjects,
		std::vector< reco::PFCandidatePtr > &	outlierChargedObjects,
		std::vector< reco::PFCandidatePtr > &	signalGammaObjects,
		std::vector< reco::PFCandidatePtr > &	outlierGammaObjects,
		bool	useScanningAxis
	)

compute size of cone using the Inside-Out cone (Author Evan Friis, UC Davis)

Definition at line 298 of file PFTauElementsOperators.cc.

References TauTagTools::computeAngle(), TauTagTools::computeDeltaR(), copyCandRefsFilteredByPt(), FixedAreaIsolationCone::setAcceptanceLimit(), python.multivaluedict::sort(), and theIndex().

{
   if (theChargedCands.empty() && theGammaCands.empty()) 
      return;
   //copy the vector of PFCands filtering by Pt
   std::vector<reco::PFCandidatePtr> filteredCands;
   filteredCands.reserve(theChargedCands.size() + theGammaCands.size());

   copyCandRefsFilteredByPt(theChargedCands, filteredCands, minChargedPt);
   copyCandRefsFilteredByPt(theGammaCands, filteredCands, minNeutralPt);

   if (filteredCands.empty())
      return;


   //create vector of indexes as RefVectors can't use STL algos?
   unsigned int numberOfCandidates = filteredCands.size();
   std::vector<uint32_t> filteredCandIndexes(numberOfCandidates);
   for(uint32_t theIndex = 0; theIndex < numberOfCandidates; theIndex++)
      filteredCandIndexes[theIndex] = theIndex;
   
   TauTagTools::sortRefsByOpeningDistance myAngularSorter(leadTrackVector, ptrToMetricFunction, filteredCands);

   //sort the remaining candidates by angle to seed track
   sort(filteredCandIndexes.begin(), filteredCandIndexes.end(), myAngularSorter);

   std::vector<reco::PFCandidatePtr> sortedCands;
   for(std::vector<uint32_t>::const_iterator theSortedIndex = filteredCandIndexes.begin();
                                        theSortedIndex != filteredCandIndexes.end();
                                        ++theSortedIndex)
   {
      sortedCands.push_back(filteredCands.at(*theSortedIndex));
   }

   //get first candidate (seed trk by definition)
   std::vector<reco::PFCandidatePtr>::const_iterator signalObjectCandidate = sortedCands.begin();
   double totalEnergySoFar                                    = (**signalObjectCandidate).energy();
   double totalEtSoFar                                        = (**signalObjectCandidate).et();
   math::XYZVector axisVectorSoFar                            = leadTrackVector;
   double currentDelToCenter = ptrToMetricFunction(leadTrackVector, axisVectorSoFar);
   //advance to next object
   ++signalObjectCandidate;
   bool doneBuilding = false;
   while (!doneBuilding && signalObjectCandidate != sortedCands.end())
   {
      //compute cutoff quanity
      math::XYZVector testAxis       = axisVectorSoFar;
      if (useScanningAxis)
         testAxis           += (**signalObjectCandidate).momentum();
      currentDelToCenter    = ptrToMetricFunction((**signalObjectCandidate).momentum(), testAxis);
      double testEnergy     = totalEnergySoFar + (**signalObjectCandidate).energy();
      double testEt         = totalEtSoFar     + (**signalObjectCandidate).et();
      bool isCharged        = (**signalObjectCandidate).charge();
      bool addThisObject    = true;
      if (currentDelToCenter > ((isCharged)?maxChargedSize:maxNeutralSize) ) {
         //max conesize is reached
         addThisObject = false;
      }
      else if (currentDelToCenter > ((isCharged)?minChargedSize:minNeutralSize) )
      {
         //only do calculation if we are in the region above the minimum size
         double cutOffQuantity = coneSizeFormula.Eval(testEnergy, testEt);
         if (currentDelToCenter > cutOffQuantity)
            addThisObject = false;
         else if (useScanningAxis)
         {
            //make sure we don't make the seed track kinematically inconsistent  
            //(stop growth if axis-lead track distance greater than computed opening angle
            if (ptrToMetricFunction(testAxis, leadTrackVector) > cutOffQuantity)
               addThisObject = false;
         }
      }
      if (addThisObject)
      {
         axisVectorSoFar  = testAxis;
         totalEnergySoFar = testEnergy;
         totalEtSoFar     = testEt;
         ++signalObjectCandidate;  //signal object candidate now points to one past the
      }
      else
      {
         doneBuilding = true;
      }
   }
   // split the collection into two collections
   double largest3DOpeningAngleSignal = 0.;  //used for area outlier collection cone
   for (std::vector<reco::PFCandidatePtr>::const_iterator iterCand =  sortedCands.begin();
                                             iterCand != signalObjectCandidate;
                                             ++iterCand)
   {
      double angleToAxis = TauTagTools::computeAngle((*iterCand)->momentum(), axisVectorSoFar);
      if (angleToAxis > largest3DOpeningAngleSignal)
         largest3DOpeningAngleSignal = angleToAxis;

      if ((*iterCand)->charge())
         signalChargedObjects.push_back(*iterCand);
      else
         signalGammaObjects.push_back(*iterCand);
   }

   //function pointer to outlier collection cutoff quantity
   double (*outlierCollectionCalculator)(const math::XYZVector&, const math::XYZVector&) = TauTagTools::computeAngle;
   double outlierCollectionComputedMaxSize = 0;

   if (!outlierCollectorConeMetric.compare("angle"))
   {
      outlierCollectionCalculator       = TauTagTools::computeAngle;
      outlierCollectionComputedMaxSize  = outlierCollectionMaxSize;
   } else if (!outlierCollectorConeMetric.compare("area"))
   {
      //determine opening angle (in 3D space of signal objects)
      
      outlierCollectionCalculator       = TauTagTools::computeAngle;  //the area cone outside angle is defined in 3D
      FixedAreaIsolationCone theFixedAreaCone;
      theFixedAreaCone.setAcceptanceLimit(2.5);
      //calculate new iso cone size
      int errorFlagForConeSizeCalc = 0;
      outlierCollectionComputedMaxSize = theFixedAreaCone(axisVectorSoFar.theta(), axisVectorSoFar.phi(), largest3DOpeningAngleSignal, outlierCollectionMaxSize, errorFlagForConeSizeCalc);
      if (errorFlagForConeSizeCalc != 0)
      {
         edm::LogError("PFRecoTauAlgorithm") << "Error: " << errorFlagForConeSizeCalc << " when calculated const area annulus.  Taking all non-signal PFJet consituents!";
         outlierCollectionComputedMaxSize = 1000.;  //takes everything...
      }
   } else if (!outlierCollectorConeMetric.compare("DR"))
   {
      outlierCollectionCalculator       = TauTagTools::computeDeltaR;
      outlierCollectionComputedMaxSize  = outlierCollectionMaxSize;
   } 
   else //warn if metric choice for outlier collection is not consistent
   {
      edm::LogWarning("PFRecoTauAlgorithm") << "Error in computeInsideOutContents(...):  Outlier (isolation) collector cone metric (" << outlierCollectorConeMetric 
                                            << ") is not recognized! All non-signal associated PFJet constituents will be included in the outliers!";
   }

   for (std::vector<reco::PFCandidatePtr>::const_iterator iterCand =  signalObjectCandidate;
                                             iterCand != sortedCands.end();
                                             ++iterCand)
   {
      //stop adding objects if we have reached the maximum outleir collector size
      double outlierOpeningQuantity = outlierCollectionCalculator(axisVectorSoFar, (*iterCand)->momentum());
      if (outlierOpeningQuantity > outlierCollectionComputedMaxSize) break;

      if ((*iterCand)->charge())
         outlierChargedObjects.push_back(*iterCand);
      else
         outlierGammaObjects.push_back(*iterCand);
   }
   //done
}

void PFTauElementsOperators::copyCandRefsFilteredByPt	(	const std::vector< reco::PFCandidatePtr > &	theInputCands,
		std::vector< reco::PFCandidatePtr > &	theOutputCands,
		const double	minPt
	)

append elements of theInputCands that pass Pt requirement to the end of theOutputCands

Definition at line 284 of file PFTauElementsOperators.cc.

Referenced by computeInsideOutContents().

{
   for(std::vector<reco::PFCandidatePtr>::const_iterator iPFCand  = theInputCands.begin();
                                            iPFCand != theInputCands.end();
                                            ++iPFCand)
   {
      if ( (*iPFCand)->pt() > minPt )
         theOutputCands.push_back(*iPFCand);
   }
}

double PFTauElementsOperators::discriminatorByIsolPFCandsEtSum

(

double

IsolPFCands_maxEtSum = 0

)

Definition at line 572 of file PFTauElementsOperators.cc.

References IsolPFCands_.

                                                                                         {
  double myIsolPFCandsEtSum=0.;
  double myDiscriminator=0.;
  for(std::vector<reco::PFCandidatePtr>::const_iterator iPFCand=IsolPFCands_.begin();iPFCand!=IsolPFCands_.end();iPFCand++) myIsolPFCandsEtSum+=(**iPFCand).et();
  if (myIsolPFCandsEtSum<=IsolPFCands_maxEtSum) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFCandsEtSum	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFCandsEtSum	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFCandsN

(

int

IsolPFCands_maxN = 0

)

Definition at line 456 of file PFTauElementsOperators.cc.

References IsolPFCands_.

                                                                              {
  double myDiscriminator=0.;
  if ((int)IsolPFCands_.size()<=IsolPFCands_maxN) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFCandsN	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFCandsN	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFChargedHadrCandsEtSum	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFChargedHadrCandsEtSum

(

double

IsolPFCands_maxEtSum = 0

)

Definition at line 607 of file PFTauElementsOperators.cc.

References IsolPFChargedHadrCands_.

                                                                                                               {
  double myIsolPFCandsEtSum=0.;
  double myDiscriminator=0.;
  for(std::vector<reco::PFCandidatePtr>::const_iterator iPFCand=IsolPFChargedHadrCands_.begin();iPFCand!=IsolPFChargedHadrCands_.end();iPFCand++) myIsolPFCandsEtSum+=(**iPFCand).et();
  if (myIsolPFCandsEtSum<=IsolPFChargedHadrCands_maxEtSum) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFChargedHadrCandsEtSum	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFChargedHadrCandsN

(

int

IsolPFCands_maxN = 0

)

Definition at line 485 of file PFTauElementsOperators.cc.

References IsolPFChargedHadrCands_.

                                                                                                    {
  double myDiscriminator=0.;
  if ((int)IsolPFChargedHadrCands_.size()<=IsolPFChargedHadrCands_maxN) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFChargedHadrCandsN	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFChargedHadrCandsN	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFGammaCandsEtSum

(

double

IsolPFCands_maxEtSum = 0

)

Definition at line 677 of file PFTauElementsOperators.cc.

References IsolPFGammaCands_.

                                                                                                   {
  double myIsolPFCandsEtSum=0.;
  double myDiscriminator=0.;
  for(std::vector<reco::PFCandidatePtr>::const_iterator iPFCand=IsolPFGammaCands_.begin();iPFCand!=IsolPFGammaCands_.end();iPFCand++) myIsolPFCandsEtSum+=(**iPFCand).et();
  if (myIsolPFCandsEtSum<=IsolPFGammaCands_maxEtSum) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFGammaCandsEtSum	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFGammaCandsEtSum	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFGammaCandsN

(

int

IsolPFCands_maxN = 0

)

Definition at line 543 of file PFTauElementsOperators.cc.

References IsolPFGammaCands_.

                                                                                        {
  double myDiscriminator=0.;
  if ((int)IsolPFGammaCands_.size()<=IsolPFGammaCands_maxN) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFGammaCandsN	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFGammaCandsN	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFNeutrHadrCandsEtSum

(

double

IsolPFCands_maxEtSum = 0

)

Definition at line 642 of file PFTauElementsOperators.cc.

References IsolPFNeutrHadrCands_.

                                                                                                           {
  double myIsolPFCandsEtSum=0.;
  double myDiscriminator=0.;
  for(std::vector<reco::PFCandidatePtr>::const_iterator iPFCand=IsolPFNeutrHadrCands_.begin();iPFCand!=IsolPFNeutrHadrCands_.end();iPFCand++) myIsolPFCandsEtSum+=(**iPFCand).et();
  if (myIsolPFCandsEtSum<=IsolPFNeutrHadrCands_maxEtSum) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFNeutrHadrCandsEtSum	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFNeutrHadrCandsEtSum	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		double	IsolPFCands_maxEtSum = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFNeutrHadrCandsN

(

int

IsolPFCands_maxN = 0

)

Definition at line 514 of file PFTauElementsOperators.cc.

References IsolPFNeutrHadrCands_.

                                                                                                {
  double myDiscriminator=0.;
  if ((int)IsolPFNeutrHadrCands_.size()<=IsolPFNeutrHadrCands_maxN) myDiscriminator=1;
  return myDiscriminator;
}

double PFTauElementsOperators::discriminatorByIsolPFNeutrHadrCandsN	(	std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

double PFTauElementsOperators::discriminatorByIsolPFNeutrHadrCandsN	(	const math::XYZVector &	myVector,
		std::string	matchingcone_metric,
		double	matchingcone_size,
		std::string	signalcone_metric,
		double	signalcone_size,
		std::string	isolcone_metric,
		double	isolcone_size,
		bool	useOnlyChargedHadrforleadPFCand,
		double	minPt_leadPFCand,
		double	minPt_PFCand,
		int	IsolPFCands_maxN = 0
	)

reco::PFCandidatePtr PFTauElementsOperators::leadPFCand	(	const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

reco::PFCandidatePtr PFTauElementsOperators::leadPFCand	(	const math::XYZVector &	myVector,
		const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

reco::PFCandidatePtr PFTauElementsOperators::leadPFChargedHadrCand	(	const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

Referenced by PFRecoTauAlgorithm::buildPFTau().

reco::PFCandidatePtr PFTauElementsOperators::leadPFChargedHadrCand	(	const math::XYZVector &	myVector,
		const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

reco::PFCandidatePtr PFTauElementsOperators::leadPFGammaCand	(	const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

reco::PFCandidatePtr PFTauElementsOperators::leadPFGammaCand	(	const math::XYZVector &	myVector,
		const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

reco::PFCandidatePtr PFTauElementsOperators::leadPFNeutrHadrCand	(	const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

reco::PFCandidatePtr PFTauElementsOperators::leadPFNeutrHadrCand	(	const math::XYZVector &	myVector,
		const std::string	matchingcone_metric,
		const double	matchingcone_size,
		const double	minPt
	)		const

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFCandsInAnnulus	(	const std::vector< reco::PFCandidatePtr > &	PFCands,
		const math::XYZVector &	myVector,
		const std::string	innercone_metric,
		const double	innercone_size,
		const std::string	outercone_metric,
		const double	outercone_size,
		const double	minPt
	)		const

Referenced by PFGammaCandsInAnnulus(), and PFNeutrHadrCandsInAnnulus().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFCandsInAnnulus	(	const math::XYZVector &	myVector,
		const std::string	innercone_metric,
		const double	innercone_size,
		const std::string	outercone_metric,
		const double	outercone_size,
		const double	minPt
	)		const

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFCandsInCone	(	const std::vector< reco::PFCandidatePtr > &	PFCands,
		const math::XYZVector &	myVector,
		const std::string	conemetric,
		const double	conesize,
		const double	minPt
	)		const

Referenced by PFRecoTauAlgorithm::buildPFTau(), PFGammaCandsInCone(), and PFNeutrHadrCandsInCone().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFCandsInCone	(	const math::XYZVector &	myVector,
		const std::string	conemetric,
		const double	conesize,
		const double	minPt
	)		const

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFChargedHadrCandsInAnnulus	(	const math::XYZVector &	myVector,
		const std::string	innercone_metric,
		const double	innercone_size,
		const std::string	outercone_metric,
		const double	outercone_size,
		const double	minPt
	)		const

Referenced by PFRecoTauAlgorithm::buildPFTau().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFChargedHadrCandsInAnnulus	(	const math::XYZVector &	myVector,
		const std::string	innercone_metric,
		const double	innercone_size,
		const std::string	outercone_metric,
		const double	outercone_size,
		const double	minPt,
		const double	PFChargedHadrCand_tracktorefpoint_maxDZ,
		const double	refpoint_Z,
		const reco::Vertex &	myPV
	)		const

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFChargedHadrCandsInCone	(	const math::XYZVector &	myVector,
		const std::string	conemetric,
		const double	conesize,
		const double	minPt
	)		const

Referenced by PFRecoTauAlgorithm::buildPFTau().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFChargedHadrCandsInCone	(	const math::XYZVector &	myVector,
		const std::string	conemetric,
		const double	conesize,
		const double	minPt,
		const double	PFChargedHadrCand_tracktorefpoint_maxDZ,
		const double	refpoint_Z,
		const reco::Vertex &	mPV
	)		const

std::vector< reco::PFCandidatePtr > PFTauElementsOperators::PFGammaCandsInAnnulus	(	const math::XYZVector &	myVector,
		const std::string	innercone_metric,
		const double	innercone_size,
		const std::string	outercone_metric,
		const double	outercone_size,
		const double	minPt
	)		const

Definition at line 158 of file PFTauElementsOperators.cc.

References PFCandsInAnnulus(), and PFGammaCands_.

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                                                                                                     {     
  std::vector<reco::PFCandidatePtr> theFilteredPFCandsInAnnulus=PFCandsInAnnulus(PFGammaCands_,myVector,innercone_metric,innercone_size,outercone_metric,outercone_size,minPt);
  return theFilteredPFCandsInAnnulus;
}

std::vector< reco::PFCandidatePtr > PFTauElementsOperators::PFGammaCandsInCone	(	const math::XYZVector &	myVector,
		const std::string	conemetric,
		const double	conesize,
		const double	minPt
	)		const

Definition at line 62 of file PFTauElementsOperators.cc.

References PFCandsInCone(), and PFGammaCands_.

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                            {     
  std::vector<reco::PFCandidatePtr> theFilteredPFCandsInCone=PFCandsInCone(PFGammaCands_,myVector,conemetric,conesize,minPt);
  return theFilteredPFCandsInCone;
}

std::pair< std::vector< reco::PFCandidatePtr >, std::vector< reco::PFCandidatePtr > > PFTauElementsOperators::PFGammaCandsInOutEllipse	(	const std::vector< reco::PFCandidatePtr > &	PFGammaCands_,
		const reco::PFCandidate &	leadCand_,
		double	rPhi,
		double	rEta,
		double	maxPt
	)		const

Definition at line 68 of file PFTauElementsOperators.cc.

References PFCandidatesInEllipse_.

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                                                                                                    {
  std::pair<std::vector<reco::PFCandidatePtr>,std::vector<reco::PFCandidatePtr>> myPFGammaCandsInEllipse = PFCandidatesInEllipse_(leadCand_, rPhi, rEta, PFGammaCands_);
  std::vector<reco::PFCandidatePtr> thePFGammaCandsInEllipse = myPFGammaCandsInEllipse.first;
  std::vector<reco::PFCandidatePtr> thePFGammaCandsOutEllipse = myPFGammaCandsInEllipse.second;
  std::vector<reco::PFCandidatePtr> theFilteredPFGammaCandsInEllipse;
  for(std::vector<reco::PFCandidatePtr>::const_iterator iPFGammaCand = thePFGammaCandsInEllipse.begin(); iPFGammaCand != thePFGammaCandsInEllipse.end(); ++iPFGammaCand){
    if((**iPFGammaCand).pt() <= maxPt) theFilteredPFGammaCandsInEllipse.push_back(*iPFGammaCand);
    else thePFGammaCandsOutEllipse.push_back(*iPFGammaCand);
  }
  std::pair<std::vector<reco::PFCandidatePtr>, std::vector<reco::PFCandidatePtr>> theFilteredPFGammaCandsInOutEllipse(theFilteredPFGammaCandsInEllipse, thePFGammaCandsOutEllipse);
  
  return theFilteredPFGammaCandsInOutEllipse;
}

std::vector< reco::PFCandidatePtr > PFTauElementsOperators::PFNeutrHadrCandsInAnnulus	(	const math::XYZVector &	myVector,
		const std::string	innercone_metric,
		const double	innercone_size,
		const std::string	outercone_metric,
		const double	outercone_size,
		const double	minPt
	)		const

Definition at line 154 of file PFTauElementsOperators.cc.

References PFCandsInAnnulus(), and PFNeutrHadrCands_.

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                                                                                                         {     
  std::vector<reco::PFCandidatePtr> theFilteredPFCandsInAnnulus=PFCandsInAnnulus(PFNeutrHadrCands_,myVector,innercone_metric,innercone_size,outercone_metric,outercone_size,minPt);
  return theFilteredPFCandsInAnnulus;
}

std::vector< reco::PFCandidatePtr > PFTauElementsOperators::PFNeutrHadrCandsInCone	(	const math::XYZVector &	myVector,
		const std::string	conemetric,
		const double	conesize,
		const double	minPt
	)		const

Definition at line 58 of file PFTauElementsOperators.cc.

References PFCandsInCone(), and PFNeutrHadrCands_.

Referenced by PFRecoTauAlgorithm::buildPFTau().

                                                                                                                                                                               {     
  std::vector<reco::PFCandidatePtr> theFilteredPFCandsInCone=PFCandsInCone(PFNeutrHadrCands_,myVector,conemetric,conesize,minPt);
  return theFilteredPFCandsInCone;
}

void PFTauElementsOperators::setAreaMetricrecoElementsmaxabsEta

(

double

x

)

Definition at line 18 of file PFTauElementsOperators.cc.

References AreaMetric_recoElements_maxabsEta_, and x.

{AreaMetric_recoElements_maxabsEta_=x;}

Member Data Documentation

double PFTauElementsOperators::AreaMetric_recoElements_maxabsEta_

private

Definition at line 105 of file PFTauElementsOperators.h.

Referenced by setAreaMetricrecoElementsmaxabsEta().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::IsolPFCands_

private

Definition at line 107 of file PFTauElementsOperators.h.

Referenced by discriminatorByIsolPFCandsEtSum(), discriminatorByIsolPFCandsN(), and PFTauElementsOperators().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::IsolPFChargedHadrCands_

private

Definition at line 109 of file PFTauElementsOperators.h.

Referenced by discriminatorByIsolPFChargedHadrCandsEtSum(), discriminatorByIsolPFChargedHadrCandsN(), and PFTauElementsOperators().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::IsolPFGammaCands_

private

Definition at line 113 of file PFTauElementsOperators.h.

Referenced by discriminatorByIsolPFGammaCandsEtSum(), discriminatorByIsolPFGammaCandsN(), and PFTauElementsOperators().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::IsolPFNeutrHadrCands_

private

Definition at line 111 of file PFTauElementsOperators.h.

Referenced by discriminatorByIsolPFNeutrHadrCandsEtSum(), discriminatorByIsolPFNeutrHadrCandsN(), and PFTauElementsOperators().

Angle<math::XYZVector> PFTauElementsOperators::metricAngle_

private

Definition at line 116 of file PFTauElementsOperators.h.

DeltaR<math::XYZVector> PFTauElementsOperators::metricDR_

private

Definition at line 115 of file PFTauElementsOperators.h.

ElementsInEllipse<reco::PFCandidate, reco::PFCandidate> PFTauElementsOperators::PFCandidatesInEllipse_

private

Definition at line 125 of file PFTauElementsOperators.h.

Referenced by PFGammaCandsInOutEllipse().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFCands_

private

Definition at line 106 of file PFTauElementsOperators.h.

Referenced by PFTauElementsOperators().

ElementsInAnnulus<math::XYZVector,Angle<math::XYZVector>,Angle<math::XYZVector>,reco::PFCandidate> PFTauElementsOperators::PFCandsinAnnulus_innerAngleouterAnglemetrics_

private

Definition at line 123 of file PFTauElementsOperators.h.

ElementsInAnnulus<math::XYZVector,Angle<math::XYZVector>,DeltaR<math::XYZVector>,reco::PFCandidate> PFTauElementsOperators::PFCandsinAnnulus_innerAngleouterDRmetrics_

private

Definition at line 124 of file PFTauElementsOperators.h.

ElementsInAnnulus<math::XYZVector,DeltaR<math::XYZVector>,Angle<math::XYZVector>,reco::PFCandidate> PFTauElementsOperators::PFCandsinAnnulus_innerDRouterAnglemetrics_

private

Definition at line 122 of file PFTauElementsOperators.h.

ElementsInAnnulus<math::XYZVector,DeltaR<math::XYZVector>,DeltaR<math::XYZVector>,reco::PFCandidate> PFTauElementsOperators::PFCandsinAnnulus_innerDRouterDRmetrics_

private

Definition at line 121 of file PFTauElementsOperators.h.

ElementsInCone<math::XYZVector,Angle<math::XYZVector>,reco::PFCandidate> PFTauElementsOperators::PFCandsinCone_Anglemetric_

private

Definition at line 120 of file PFTauElementsOperators.h.

ElementsInCone<math::XYZVector,DeltaR<math::XYZVector>,reco::PFCandidate> PFTauElementsOperators::PFCandsinCone_DRmetric_

private

Definition at line 119 of file PFTauElementsOperators.h.

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFChargedHadrCands_

private

Definition at line 108 of file PFTauElementsOperators.h.

Referenced by PFTauElementsOperators().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFGammaCands_

private

Definition at line 112 of file PFTauElementsOperators.h.

Referenced by PFGammaCandsInAnnulus(), PFGammaCandsInCone(), and PFTauElementsOperators().

reco::PFJetRef PFTauElementsOperators::PFJetRef_

private

Definition at line 104 of file PFTauElementsOperators.h.

Referenced by PFTauElementsOperators().

std::vector<reco::PFCandidatePtr> PFTauElementsOperators::PFNeutrHadrCands_

private

Definition at line 110 of file PFTauElementsOperators.h.

Referenced by PFNeutrHadrCandsInAnnulus(), PFNeutrHadrCandsInCone(), and PFTauElementsOperators().