CMS 3D CMS Logo

PFRecoTauAlgorithm Class Reference

#include <RecoTauTag/RecoTau/interface/PFRecoTauAlgorithm.h>

List of all members.

Public Member Functions

PFTau buildPFTau (const PFTauTagInfoRef &, const Vertex &)
 PFRecoTauAlgorithm (const ParameterSet &)
 PFRecoTauAlgorithm ()
void setTransientTrackBuilder (const TransientTrackBuilder *)
 ~PFRecoTauAlgorithm ()

Private Member Functions

bool checkPos (std::vector< math::XYZPoint >, math::XYZPoint) const

Private Attributes

double AreaMetric_recoElements_maxabsEta_
uint32_t ChargedHadrCand_IsolAnnulus_minNhits_
double ChargedHadrCand_minPt_
double ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_
string DataType_
string ECALIsolConeMetric_
double ECALIsolConeSize_max_
double ECALIsolConeSize_min_
string ECALIsolConeSizeFormula_
string ECALSignalConeMetric_
double ECALSignalConeSize_max_
double ECALSignalConeSize_min_
string ECALSignalConeSizeFormula_
double EcalStripSumE_deltaEta_
double EcalStripSumE_deltaPhiOverQ_maxValue_
double EcalStripSumE_deltaPhiOverQ_minValue_
double EcalStripSumE_minClusEnergy_
double ElecPreIDLeadTkMatch_maxDR_
double GammaCand_minPt_
string HCALIsolConeMetric_
double HCALIsolConeSize_max_
double HCALIsolConeSize_min_
string HCALIsolConeSizeFormula_
string HCALSignalConeMetric_
double HCALSignalConeSize_max_
double HCALSignalConeSize_min_
string HCALSignalConeSizeFormula_
double LeadChargedHadrCand_minPt_
double LeadTrack_minPt_
string MatchingConeMetric_
double MatchingConeSize_max_
double MatchingConeSize_min_
string MatchingConeSizeFormula_
TFormula myECALIsolConeSizeTFormula
TFormula myECALSignalConeSizeTFormula
TFormula myHCALIsolConeSizeTFormula
TFormula myHCALSignalConeSizeTFormula
TFormula myMatchingConeSizeTFormula
TFormula myTrackerIsolConeSizeTFormula
TFormula myTrackerSignalConeSizeTFormula
double NeutrHadrCand_minPt_
uint32_t Track_IsolAnnulus_minNhits_
double Track_minPt_
string TrackerIsolConeMetric_
double TrackerIsolConeSize_max_
double TrackerIsolConeSize_min_
string TrackerIsolConeSizeFormula_
string TrackerSignalConeMetric_
double TrackerSignalConeSize_max_
double TrackerSignalConeSize_min_
string TrackerSignalConeSizeFormula_
double TrackLeadTrack_maxDZ_
const TransientTrackBuilder * TransientTrackBuilder_
bool UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_
bool UseTrackLeadTrackDZconstraint_

Detailed Description

Definition at line 24 of file PFRecoTauAlgorithm.h.

Constructor & Destructor Documentation

PFRecoTauAlgorithm::PFRecoTauAlgorithm (  ) 

Definition at line 3 of file PFRecoTauAlgorithm.cc.

00003 : TransientTrackBuilder_(0){}

PFRecoTauAlgorithm::PFRecoTauAlgorithm ( const ParameterSet &  iConfig  ) 

Definition at line 4 of file PFRecoTauAlgorithm.cc.

References AreaMetric_recoElements_maxabsEta_, ChargedHadrCand_IsolAnnulus_minNhits_, ChargedHadrCand_minPt_, ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_, TauTagTools::computeConeSizeTFormula(), DataType_, ECALIsolConeMetric_, ECALIsolConeSize_max_, ECALIsolConeSize_min_, ECALIsolConeSizeFormula_, ECALSignalConeMetric_, ECALSignalConeSize_max_, ECALSignalConeSize_min_, ECALSignalConeSizeFormula_, EcalStripSumE_deltaEta_, EcalStripSumE_deltaPhiOverQ_maxValue_, EcalStripSumE_deltaPhiOverQ_minValue_, EcalStripSumE_minClusEnergy_, ElecPreIDLeadTkMatch_maxDR_, GammaCand_minPt_, edm::ParameterSet::getParameter(), HCALIsolConeMetric_, HCALIsolConeSize_max_, HCALIsolConeSize_min_, HCALIsolConeSizeFormula_, HCALSignalConeMetric_, HCALSignalConeSize_max_, HCALSignalConeSize_min_, HCALSignalConeSizeFormula_, LeadChargedHadrCand_minPt_, LeadTrack_minPt_, MatchingConeMetric_, MatchingConeSize_max_, MatchingConeSize_min_, MatchingConeSizeFormula_, myECALIsolConeSizeTFormula, myECALSignalConeSizeTFormula, myHCALIsolConeSizeTFormula, myHCALSignalConeSizeTFormula, myMatchingConeSizeTFormula, myTrackerIsolConeSizeTFormula, myTrackerSignalConeSizeTFormula, NeutrHadrCand_minPt_, Track_IsolAnnulus_minNhits_, Track_minPt_, TrackerIsolConeMetric_, TrackerIsolConeSize_max_, TrackerIsolConeSize_min_, TrackerIsolConeSizeFormula_, TrackerSignalConeMetric_, TrackerSignalConeSize_max_, TrackerSignalConeSize_min_, TrackerSignalConeSizeFormula_, TrackLeadTrack_maxDZ_, UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_, and UseTrackLeadTrackDZconstraint_.

00004                                                                   : TransientTrackBuilder_(0){
00005   LeadChargedHadrCand_minPt_          = iConfig.getParameter<double>("LeadChargedHadrCand_minPt"); 
00006   ChargedHadrCand_minPt_              = iConfig.getParameter<double>("ChargedHadrCand_minPt");
00007   UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_ = iConfig.getParameter<bool>("UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint");
00008   ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_ = iConfig.getParameter<double>("ChargedHadrCandLeadChargedHadrCand_tksmaxDZ");
00009   NeutrHadrCand_minPt_                = iConfig.getParameter<double>("NeutrHadrCand_minPt");
00010   GammaCand_minPt_                    = iConfig.getParameter<double>("GammaCand_minPt");       
00011   LeadTrack_minPt_                    = iConfig.getParameter<double>("LeadTrack_minPt");
00012   Track_minPt_                        = iConfig.getParameter<double>("Track_minPt");
00013   UseTrackLeadTrackDZconstraint_      = iConfig.getParameter<bool>("UseTrackLeadTrackDZconstraint");
00014   TrackLeadTrack_maxDZ_               = iConfig.getParameter<double>("TrackLeadTrack_maxDZ");
00015   
00016   MatchingConeMetric_                 = iConfig.getParameter<string>("MatchingConeMetric");
00017   MatchingConeSizeFormula_            = iConfig.getParameter<string>("MatchingConeSizeFormula");
00018   MatchingConeSize_min_               = iConfig.getParameter<double>("MatchingConeSize_min");
00019   MatchingConeSize_max_               = iConfig.getParameter<double>("MatchingConeSize_max");
00020   TrackerSignalConeMetric_            = iConfig.getParameter<string>("TrackerSignalConeMetric");
00021   TrackerSignalConeSizeFormula_       = iConfig.getParameter<string>("TrackerSignalConeSizeFormula");
00022   TrackerSignalConeSize_min_          = iConfig.getParameter<double>("TrackerSignalConeSize_min");
00023   TrackerSignalConeSize_max_          = iConfig.getParameter<double>("TrackerSignalConeSize_max");
00024   TrackerIsolConeMetric_              = iConfig.getParameter<string>("TrackerIsolConeMetric"); 
00025   TrackerIsolConeSizeFormula_         = iConfig.getParameter<string>("TrackerIsolConeSizeFormula"); 
00026   TrackerIsolConeSize_min_            = iConfig.getParameter<double>("TrackerIsolConeSize_min");
00027   TrackerIsolConeSize_max_            = iConfig.getParameter<double>("TrackerIsolConeSize_max");
00028   ECALSignalConeMetric_               = iConfig.getParameter<string>("ECALSignalConeMetric");
00029   ECALSignalConeSizeFormula_          = iConfig.getParameter<string>("ECALSignalConeSizeFormula");    
00030   ECALSignalConeSize_min_             = iConfig.getParameter<double>("ECALSignalConeSize_min");
00031   ECALSignalConeSize_max_             = iConfig.getParameter<double>("ECALSignalConeSize_max");
00032   ECALIsolConeMetric_                 = iConfig.getParameter<string>("ECALIsolConeMetric");
00033   ECALIsolConeSizeFormula_            = iConfig.getParameter<string>("ECALIsolConeSizeFormula");      
00034   ECALIsolConeSize_min_               = iConfig.getParameter<double>("ECALIsolConeSize_min");
00035   ECALIsolConeSize_max_               = iConfig.getParameter<double>("ECALIsolConeSize_max");
00036   HCALSignalConeMetric_               = iConfig.getParameter<string>("HCALSignalConeMetric");
00037   HCALSignalConeSizeFormula_          = iConfig.getParameter<string>("HCALSignalConeSizeFormula");    
00038   HCALSignalConeSize_min_             = iConfig.getParameter<double>("HCALSignalConeSize_min");
00039   HCALSignalConeSize_max_             = iConfig.getParameter<double>("HCALSignalConeSize_max");
00040   HCALIsolConeMetric_                 = iConfig.getParameter<string>("HCALIsolConeMetric");
00041   HCALIsolConeSizeFormula_            = iConfig.getParameter<string>("HCALIsolConeSizeFormula");      
00042   HCALIsolConeSize_min_               = iConfig.getParameter<double>("HCALIsolConeSize_min");
00043   HCALIsolConeSize_max_               = iConfig.getParameter<double>("HCALIsolConeSize_max");
00044   
00045   AreaMetric_recoElements_maxabsEta_  = iConfig.getParameter<double>("AreaMetric_recoElements_maxabsEta");
00046   ChargedHadrCand_IsolAnnulus_minNhits_ = iConfig.getParameter<uint32_t>("ChargedHadrCand_IsolAnnulus_minNhits");
00047   Track_IsolAnnulus_minNhits_           = iConfig.getParameter<uint32_t>("Track_IsolAnnulus_minNhits");
00048 
00049   ElecPreIDLeadTkMatch_maxDR_ = iConfig.getParameter<double>("ElecPreIDLeadTkMatch_maxDR");
00050   EcalStripSumE_minClusEnergy_ = iConfig.getParameter<double>("EcalStripSumE_minClusEnergy");
00051   EcalStripSumE_deltaEta_ = iConfig.getParameter<double>("EcalStripSumE_deltaEta");
00052   EcalStripSumE_deltaPhiOverQ_minValue_ = iConfig.getParameter<double>("EcalStripSumE_deltaPhiOverQ_minValue");
00053   EcalStripSumE_deltaPhiOverQ_maxValue_ = iConfig.getParameter<double>("EcalStripSumE_deltaPhiOverQ_maxValue");
00054 
00055   DataType_ = iConfig.getParameter<string>("DataType");
00056 
00057   //TFormula computation
00058 
00059    myMatchingConeSizeTFormula=TauTagTools::computeConeSizeTFormula(MatchingConeSizeFormula_,"Matching cone size");
00060   //Charged particels cones
00061   myTrackerSignalConeSizeTFormula=TauTagTools::computeConeSizeTFormula(TrackerSignalConeSizeFormula_,"Tracker signal cone size");
00062   myTrackerIsolConeSizeTFormula=TauTagTools::computeConeSizeTFormula(TrackerIsolConeSizeFormula_,"Tracker isolation cone size");
00063   //Gamma candidates cones
00064   myECALSignalConeSizeTFormula=TauTagTools::computeConeSizeTFormula(ECALSignalConeSizeFormula_,"ECAL signal cone size");
00065   myECALIsolConeSizeTFormula=TauTagTools::computeConeSizeTFormula(ECALIsolConeSizeFormula_,"ECAL isolation cone size");
00066   //Neutral hadrons cones
00067   myHCALSignalConeSizeTFormula=TauTagTools::computeConeSizeTFormula(HCALSignalConeSizeFormula_,"HCAL signal cone size");
00068   myHCALIsolConeSizeTFormula=TauTagTools::computeConeSizeTFormula(HCALIsolConeSizeFormula_,"HCAL isolation cone size");
00069  
00070 
00071 }

PFRecoTauAlgorithm::~PFRecoTauAlgorithm (  )  [inline]

Definition at line 28 of file PFRecoTauAlgorithm.h.

00028 {}

Member Function Documentation

PFTau PFRecoTauAlgorithm::buildPFTau ( const PFTauTagInfoRef &  myPFTauTagInfoRef,
const Vertex &  myPV 
)

Definition at line 74 of file PFRecoTauAlgorithm.cc.

References funct::abs(), edm::RefVector< C, T, F >::begin(), parseConfig::block, TransientTrackBuilder::build(), ChargedHadrCand_IsolAnnulus_minNhits_, ChargedHadrCand_minPt_, ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_, checkPos(), edm::RefVector< C, T, F >::clear(), TauElementsOperators::computeConeSize(), DataType_, DeltaPhi(), deltaPhi(), deltaR(), reco::PFBlockElement::ECAL, ECALIsolConeMetric_, ECALIsolConeSize_max_, ECALIsolConeSize_min_, ECALSignalConeMetric_, ECALSignalConeSize_max_, ECALSignalConeSize_min_, EcalStripSumE_deltaEta_, EcalStripSumE_deltaPhiOverQ_maxValue_, EcalStripSumE_deltaPhiOverQ_minValue_, EcalStripSumE_minClusEnergy_, element(), bookConverter::elements, reco::PFBlock::elements(), edm::RefVector< C, T, F >::end(), relval_parameters_module::energy, TauTagTools::filteredPFChargedHadrCandsByNumTrkHits(), TauTagTools::filteredTracksByNumTrkHits(), GammaCand_minPt_, reco::PFBlockElement::HCAL, HCALIsolConeMetric_, HCALIsolConeSize_max_, HCALIsolConeSize_min_, HCALSignalConeMetric_, HCALSignalConeSize_max_, HCALSignalConeSize_min_, i, int, edm::Ref< C, T, F >::isNonnull(), it, LeadChargedHadrCand_minPt_, PFTauElementsOperators::leadPFChargedHadrCand(), PFTauElementsOperators::leadPFGammaCand(), TauElementsOperators::leadTk(), LeadTrack_minPt_, MatchingConeMetric_, MatchingConeSize_max_, MatchingConeSize_min_, myECALIsolConeSizeTFormula, myECALSignalConeSizeTFormula, myHCALIsolConeSizeTFormula, myHCALSignalConeSizeTFormula, myMatchingConeSizeTFormula, myTrackerIsolConeSizeTFormula, myTrackerSignalConeSizeTFormula, NeutrHadrCand_minPt_, PFTauElementsOperators::PFCandsInCone(), PFTauElementsOperators::PFChargedHadrCandsInAnnulus(), PFTauElementsOperators::PFChargedHadrCandsInCone(), PFTauElementsOperators::PFGammaCandsInAnnulus(), PFTauElementsOperators::PFGammaCandsInCone(), PFTauElementsOperators::PFNeutrHadrCandsInAnnulus(), PFTauElementsOperators::PFNeutrHadrCandsInCone(), edm::RefVector< C, T, F >::push_back(), reco::PFTau::setpfTauTagInfoRef(), IPTools::signedTransverseImpactParameter(), funct::sin(), edm::OwnVector< T, P >::size(), edm::RefVector< C, T, F >::size(), Track_IsolAnnulus_minNhits_, Track_minPt_, TrackerIsolConeMetric_, TrackerIsolConeSize_max_, TrackerIsolConeSize_min_, TrackerSignalConeMetric_, TrackerSignalConeSize_max_, TrackerSignalConeSize_min_, TrackLeadTrack_maxDZ_, TauElementsOperators::tracksInAnnulus(), TauElementsOperators::tracksInCone(), TransientTrackBuilder_, UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_, and UseTrackLeadTrackDZconstraint_.

Referenced by PFRecoTauProducer::produce().

00074                                                                                                {
00075   PFJetRef myPFJet=(*myPFTauTagInfoRef).pfjetRef();  // catch a ref to the initial PFJet  
00076   PFTau myPFTau(numeric_limits<int>::quiet_NaN(),myPFJet->p4());   // create the PFTau
00077    
00078   myPFTau.setpfTauTagInfoRef(myPFTauTagInfoRef);
00079   
00080   PFCandidateRefVector myPFCands=(*myPFTauTagInfoRef).PFCands();
00081   PFCandidateRefVector myPFChargedHadrCands=(*myPFTauTagInfoRef).PFChargedHadrCands();
00082   PFCandidateRefVector myPFNeutrHadrCands=(*myPFTauTagInfoRef).PFNeutrHadrCands();
00083   PFCandidateRefVector myPFGammaCands=(*myPFTauTagInfoRef).PFGammaCands();
00084   
00085   PFTauElementsOperators myPFTauElementsOperators(myPFTau);
00086   double myMatchingConeSize=myPFTauElementsOperators.computeConeSize(myMatchingConeSizeTFormula,MatchingConeSize_min_,MatchingConeSize_max_);
00087   PFCandidateRef myleadPFChargedCand=myPFTauElementsOperators.leadPFChargedHadrCand(MatchingConeMetric_,myMatchingConeSize,LeadChargedHadrCand_minPt_);
00088   PFCandidateRef myleadPFNeutralCand=myPFTauElementsOperators.leadPFGammaCand(MatchingConeMetric_,myMatchingConeSize,LeadChargedHadrCand_minPt_);
00089   PFCandidateRef myleadPFCand;
00090 
00091   bool myleadPFCand_rectkavailable=false;
00092   double myleadPFCand_rectkDZ=0.;
00093   double myPFTau_refInnerPosition_x=0.;
00094   double myPFTau_refInnerPosition_y=0.;
00095   double myPFTau_refInnerPosition_z=0.;
00096 
00097   if(myleadPFNeutralCand.isNonnull())myPFTau.setleadPFNeutralCand(myleadPFNeutralCand); 
00098 
00099   //Modification to consider leading neutral particle
00100   if(myleadPFChargedCand.isNonnull()) {
00101     myleadPFCand = myleadPFChargedCand;
00102     myPFTau.setleadPFChargedHadrCand(myleadPFChargedCand);
00103     TrackRef myleadPFCand_rectk=(*myleadPFCand).trackRef();
00104     if(myleadPFCand_rectk.isNonnull()){
00105       myleadPFCand_rectkavailable=true;
00106       myleadPFCand_rectkDZ=(*myleadPFCand_rectk).dz();
00107       if(TransientTrackBuilder_!=0){ 
00108         const TransientTrack myleadPFCand_rectransienttk=TransientTrackBuilder_->build(&(*myleadPFCand_rectk));
00109         GlobalVector myPFJetdir((*myPFJet).px(),(*myPFJet).py(),(*myPFJet).pz());
00110         if(IPTools::signedTransverseImpactParameter(myleadPFCand_rectransienttk,myPFJetdir,myPV).first)
00111           myPFTau.setleadPFChargedHadrCandsignedSipt(IPTools::signedTransverseImpactParameter(myleadPFCand_rectransienttk,myPFJetdir,myPV).second.significance());
00112       }
00113     }
00114     if (UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_ && myleadPFCand_rectkavailable){
00115       PFCandidateRefVector myPFChargedHadrCandsbis;
00116       for(PFCandidateRefVector::const_iterator iPFCand=myPFChargedHadrCands.begin();iPFCand!=myPFChargedHadrCands.end();iPFCand++){
00117         TrackRef iPFChargedHadrCand_track=(**iPFCand).trackRef();
00118         if (!iPFChargedHadrCand_track)continue;
00119         if (fabs((*iPFChargedHadrCand_track).dz()-myleadPFCand_rectkDZ)<=ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_) myPFChargedHadrCandsbis.push_back(*iPFCand);
00120       }
00121       myPFChargedHadrCands=myPFChargedHadrCandsbis;
00122     }
00123 
00124   }
00125   if(!(myleadPFChargedCand.isNonnull()) && myleadPFNeutralCand.isNonnull()) {
00126     myleadPFCand = myleadPFNeutralCand; 
00127     myPFTau.setleadPFNeutralCand(myleadPFNeutralCand);
00128   }
00129    
00130   if(myleadPFCand.isNonnull()){
00131     myPFTau.setleadPFCand(myleadPFCand);
00132 
00133     //Compute energy of the PFTau considering only inner constituents (inner == pfcandidates inside a cone which is equal to the maximum value of the signal cone)
00134     PFCandidateRefVector myTmpPFCandsInSignalCone = myPFTauElementsOperators.PFCandsInCone((*myleadPFCand).momentum(),TrackerSignalConeMetric_,TrackerSignalConeSize_max_,0.5);
00135     math::XYZTLorentzVector tmpLorentzVect(0.,0.,0.,0.);
00136     for (PFCandidateRefVector::const_iterator iCand=myTmpPFCandsInSignalCone.begin();iCand!=myTmpPFCandsInSignalCone.end();iCand++) tmpLorentzVect+=(**iCand).p4();
00137     double energy = tmpLorentzVect.energy();
00138     double transverseEnergy = tmpLorentzVect.pt();
00139     //    Taking  signal and isolation cone sizes
00140     double myTrackerSignalConeSize=myPFTauElementsOperators.computeConeSize(myTrackerSignalConeSizeTFormula,TrackerSignalConeSize_min_,TrackerSignalConeSize_max_,transverseEnergy, energy);
00141     double myTrackerIsolConeSize=myPFTauElementsOperators.computeConeSize(myTrackerIsolConeSizeTFormula,TrackerIsolConeSize_min_,TrackerIsolConeSize_max_,transverseEnergy, energy);            
00142     double myECALSignalConeSize=myPFTauElementsOperators.computeConeSize(myECALSignalConeSizeTFormula,ECALSignalConeSize_min_,ECALSignalConeSize_max_,transverseEnergy, energy);
00143     double myECALIsolConeSize=myPFTauElementsOperators.computeConeSize(myECALIsolConeSizeTFormula,ECALIsolConeSize_min_,ECALIsolConeSize_max_,transverseEnergy, energy);        
00144     double myHCALSignalConeSize=myPFTauElementsOperators.computeConeSize(myHCALSignalConeSizeTFormula,HCALSignalConeSize_min_,HCALSignalConeSize_max_,transverseEnergy, energy);
00145     double myHCALIsolConeSize=myPFTauElementsOperators.computeConeSize(myHCALIsolConeSizeTFormula,HCALIsolConeSize_min_,HCALIsolConeSize_max_,transverseEnergy, energy);        
00146     
00147     //Taking signal PFCandidates
00148     PFCandidateRefVector mySignalPFChargedHadrCands,mySignalPFNeutrHadrCands,mySignalPFGammaCands,mySignalPFCands;
00149     if (UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_ && myleadPFCand_rectkavailable) mySignalPFChargedHadrCands=myPFTauElementsOperators.PFChargedHadrCandsInCone((*myleadPFCand).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,ChargedHadrCand_minPt_,ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_,myleadPFCand_rectkDZ);
00150 
00151     else mySignalPFChargedHadrCands=myPFTauElementsOperators.PFChargedHadrCandsInCone((*myleadPFCand).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,ChargedHadrCand_minPt_);
00152 
00153     myPFTau.setsignalPFChargedHadrCands(mySignalPFChargedHadrCands);
00154 
00155     mySignalPFNeutrHadrCands=myPFTauElementsOperators.PFNeutrHadrCandsInCone((*myleadPFCand).momentum(),HCALSignalConeMetric_,myHCALSignalConeSize,NeutrHadrCand_minPt_);
00156     myPFTau.setsignalPFNeutrHadrCands(mySignalPFNeutrHadrCands);
00157 
00158     mySignalPFGammaCands=myPFTauElementsOperators.PFGammaCandsInCone((*myleadPFCand).momentum(),ECALSignalConeMetric_,myECALSignalConeSize,GammaCand_minPt_);
00159     myPFTau.setsignalPFGammaCands(mySignalPFGammaCands);
00160     
00161     if((int)(mySignalPFChargedHadrCands.size())!=0){
00162       int mySignalPFChargedHadrCands_qsum=0;       
00163       for(int i=0;i<(int)mySignalPFChargedHadrCands.size();i++){
00164         mySignalPFChargedHadrCands_qsum+=mySignalPFChargedHadrCands[i]->charge();
00165         mySignalPFCands.push_back(mySignalPFChargedHadrCands[i]);
00166       }
00167       myPFTau.setCharge(mySignalPFChargedHadrCands_qsum);    
00168     }
00169     for(int i=0;i<(int)mySignalPFNeutrHadrCands.size();i++) mySignalPFCands.push_back(mySignalPFNeutrHadrCands[i]);
00170     for(int i=0;i<(int)mySignalPFGammaCands.size();i++) mySignalPFCands.push_back(mySignalPFGammaCands[i]);
00171     myPFTau.setsignalPFCands(mySignalPFCands);
00172     
00173     PFCandidateRefVector myUnfilteredIsolPFChargedHadrCands,myIsolPFNeutrHadrCands,myIsolPFGammaCands,myIsolPFCands;
00174     if (UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_ && myleadPFCand_rectkavailable) myUnfilteredIsolPFChargedHadrCands=myPFTauElementsOperators.PFChargedHadrCandsInAnnulus((*myleadPFCand).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,TrackerIsolConeMetric_,myTrackerIsolConeSize,ChargedHadrCand_minPt_,ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_,myleadPFCand_rectkDZ);
00175     else myUnfilteredIsolPFChargedHadrCands=myPFTauElementsOperators.PFChargedHadrCandsInAnnulus((*myleadPFCand).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,TrackerIsolConeMetric_,myTrackerIsolConeSize,ChargedHadrCand_minPt_);
00176 
00177     // filter isolation annulus with additional nHits quality cut (note that other cuts [pt, chi2, are already cut on])
00178     PFCandidateRefVector myIsolPFChargedHadrCands;
00179     myIsolPFChargedHadrCands = TauTagTools::filteredPFChargedHadrCandsByNumTrkHits(myUnfilteredIsolPFChargedHadrCands, ChargedHadrCand_IsolAnnulus_minNhits_); 
00180 
00181     myPFTau.setisolationPFChargedHadrCands(myIsolPFChargedHadrCands);
00182 
00183     myIsolPFNeutrHadrCands=myPFTauElementsOperators.PFNeutrHadrCandsInAnnulus((*myleadPFCand).momentum(),HCALSignalConeMetric_,myHCALSignalConeSize,HCALIsolConeMetric_,myHCALIsolConeSize,NeutrHadrCand_minPt_);
00184     myPFTau.setisolationPFNeutrHadrCands(myIsolPFNeutrHadrCands);
00185     myIsolPFGammaCands=myPFTauElementsOperators.PFGammaCandsInAnnulus((*myleadPFCand).momentum(),ECALSignalConeMetric_,myECALSignalConeSize,ECALIsolConeMetric_,myECALIsolConeSize,GammaCand_minPt_);  
00186     myPFTau.setisolationPFGammaCands(myIsolPFGammaCands);
00187 
00188     float myIsolPFChargedHadrCands_Ptsum=0.;
00189     float myIsolPFGammaCands_Etsum=0.;
00190     for(int i=0;i<(int)myIsolPFChargedHadrCands.size();i++){
00191       myIsolPFChargedHadrCands_Ptsum+=myIsolPFChargedHadrCands[i]->pt();
00192       myIsolPFCands.push_back(myIsolPFChargedHadrCands[i]);
00193     }
00194     myPFTau.setisolationPFChargedHadrCandsPtSum(myIsolPFChargedHadrCands_Ptsum);
00195     for(int i=0;i<(int)myIsolPFNeutrHadrCands.size();i++)myIsolPFCands.push_back(myIsolPFNeutrHadrCands[i]);
00196     for(int i=0;i<(int)myIsolPFGammaCands.size();i++){
00197       myIsolPFGammaCands_Etsum+=myIsolPFGammaCands[i]->et();
00198       myIsolPFCands.push_back(myIsolPFGammaCands[i]);
00199     } 
00200     myPFTau.setisolationPFGammaCandsEtSum(myIsolPFGammaCands_Etsum);
00201     myPFTau.setisolationPFCands(myIsolPFCands);
00202     
00203 
00204   //Making the alternateLorentzVector, i.e. direction with only signal components
00205   math::XYZTLorentzVector alternatLorentzVect(0.,0.,0.,0.);
00206   for (PFCandidateRefVector::const_iterator iGammaCand=mySignalPFGammaCands.begin();iGammaCand!=mySignalPFGammaCands.end();iGammaCand++) alternatLorentzVect+=(**iGammaCand).p4();
00207   for (PFCandidateRefVector::const_iterator iChargedHadrCand=mySignalPFChargedHadrCands.begin();iChargedHadrCand!=mySignalPFChargedHadrCands.end();iChargedHadrCand++) alternatLorentzVect+=(**iChargedHadrCand).p4();  
00208   myPFTau.setalternatLorentzVect(alternatLorentzVect);
00209   
00210   myPFTau.setVertex(math::XYZPoint(myPFTau_refInnerPosition_x,myPFTau_refInnerPosition_y,myPFTau_refInnerPosition_z));
00211   }  
00212   // set the leading, signal cone and isolation annulus Tracks (the initial list of Tracks was catched through a JetTracksAssociation object, not through the charged hadr. PFCandidates inside the PFJet ; the motivation for considering these objects is the need for checking that a selection by the charged hadr. PFCandidates is equivalent to a selection by the rec. Tracks.)
00213   TrackRef myleadTk=myPFTauElementsOperators.leadTk(MatchingConeMetric_,myMatchingConeSize,LeadTrack_minPt_);
00214   myPFTau.setleadTrack(myleadTk);
00215   if(myleadTk.isNonnull()){
00216     double myleadTkDZ=(*myleadTk).dz();
00217     double myTrackerSignalConeSize=myPFTauElementsOperators.computeConeSize(myTrackerSignalConeSizeTFormula,TrackerSignalConeSize_min_,TrackerSignalConeSize_max_);
00218     double myTrackerIsolConeSize=myPFTauElementsOperators.computeConeSize(myTrackerIsolConeSizeTFormula,TrackerIsolConeSize_min_,TrackerIsolConeSize_max_);     
00219     if (UseTrackLeadTrackDZconstraint_){
00220       myPFTau.setsignalTracks(myPFTauElementsOperators.tracksInCone((*myleadTk).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,Track_minPt_,TrackLeadTrack_maxDZ_,myleadTkDZ));
00221 
00222       TrackRefVector myUnfilteredTracks = myPFTauElementsOperators.tracksInAnnulus((*myleadTk).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,TrackerIsolConeMetric_,myTrackerIsolConeSize,Track_minPt_,TrackLeadTrack_maxDZ_,myleadTkDZ);
00223       TrackRefVector myFilteredTracks = TauTagTools::filteredTracksByNumTrkHits(myUnfilteredTracks, Track_IsolAnnulus_minNhits_);
00224       myPFTau.setisolationTracks(myFilteredTracks);
00225 
00226     }else{
00227       myPFTau.setsignalTracks(myPFTauElementsOperators.tracksInCone((*myleadTk).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,Track_minPt_));
00228       
00229       TrackRefVector myUnfilteredTracks = myPFTauElementsOperators.tracksInAnnulus((*myleadTk).momentum(),TrackerSignalConeMetric_,myTrackerSignalConeSize,TrackerIsolConeMetric_,myTrackerIsolConeSize,Track_minPt_);
00230       TrackRefVector myFilteredTracks = TauTagTools::filteredTracksByNumTrkHits(myUnfilteredTracks, Track_IsolAnnulus_minNhits_);
00231       myPFTau.setisolationTracks(myFilteredTracks);
00232     }
00233   }
00234   
00235   /* For elecron rejection */
00236   double myECALenergy=0.;
00237   double myHCALenergy=0.;
00238   double myHCALenergy3x3=0.;
00239   double myMaximumHCALPFClusterE=0.;
00240   double myMaximumHCALPFClusterEt=0.;
00241   double myStripClusterE=0.;
00242   double myEmfrac = -1.;
00243   bool   myElecPreid = false;
00244   reco::TrackRef myElecTrk;
00245   
00246   typedef std::pair<reco::PFBlockRef, unsigned> ElementInBlock;
00247   typedef std::vector< ElementInBlock > ElementsInBlocks; 
00248 
00249 
00250 
00251 
00252 
00253   //Use the electron rejection only in case there is a charged leading pion
00254   if(myleadPFChargedCand.isNonnull()){
00255     if (myleadPFCand->mva_e_pi()==1) {
00256       myElecPreid = true;
00257     }
00258     math::XYZPointF myElecTrkEcalPos = myleadPFCand->positionAtECALEntrance();
00259     myElecTrk = myleadPFCand->trackRef();//Electron candidate
00260     
00261     if(myElecTrk.isNonnull()) {
00262      
00263 
00264 
00265 
00266 
00267 //FROM AOD
00268       if(DataType_ == "AOD"){
00269         // Corrected Cluster energies
00270         for(int i=0;i<(int)myPFCands.size();i++){
00271           myHCALenergy += myPFCands[i]->hcalEnergy();
00272           myECALenergy += myPFCands[i]->ecalEnergy();
00273           
00274           math::XYZPointF candPos;
00275           if (myPFCands[i]->particleId()==1) // if charged hadron
00276             candPos = myPFCands[i]->positionAtECALEntrance();
00277           else
00278             candPos = math::XYZPointF(myPFCands[i]->px(),myPFCands[i]->py(),myPFCands[i]->pz());
00279 
00280           double deltaR   = ROOT::Math::VectorUtil::DeltaR(myElecTrkEcalPos,candPos);
00281           double deltaPhi = ROOT::Math::VectorUtil::DeltaPhi(myElecTrkEcalPos,candPos);
00282           double deltaEta = abs(myElecTrkEcalPos.eta()-candPos.eta());
00283           double deltaPhiOverQ = deltaPhi/(double)myElecTrk->charge();
00284           
00285         if (myPFCands[i]->ecalEnergy() >= EcalStripSumE_minClusEnergy_ && deltaEta < EcalStripSumE_deltaEta_ &&
00286             deltaPhiOverQ > EcalStripSumE_deltaPhiOverQ_minValue_  && deltaPhiOverQ < EcalStripSumE_deltaPhiOverQ_maxValue_) {
00287           myStripClusterE += myPFCands[i]->ecalEnergy();
00288         }
00289         if (deltaR<0.184) {
00290           myHCALenergy3x3 += myPFCands[i]->hcalEnergy();
00291         }
00292         if (myPFCands[i]->hcalEnergy()>myMaximumHCALPFClusterE) {
00293           myMaximumHCALPFClusterE = myPFCands[i]->hcalEnergy();
00294         }
00295         if ((myPFCands[i]->hcalEnergy()*fabs(sin(candPos.Theta())))>myMaximumHCALPFClusterEt) {
00296           myMaximumHCALPFClusterEt = (myPFCands[i]->hcalEnergy()*fabs(sin(candPos.Theta())));
00297         }
00298         }
00299 
00300         if ((myHCALenergy+myECALenergy)>0.)
00301           myEmfrac = myECALenergy/(myHCALenergy+myECALenergy);
00302         myPFTau.setemFraction((float)myEmfrac);
00303         
00304         myPFTau.setmaximumHCALPFClusterEt(myMaximumHCALPFClusterEt);
00305         myPFTau.sethcalMaxOverPLead((float)myMaximumHCALPFClusterE/(float)myElecTrk->p());
00306         myPFTau.sethcal3x3OverPLead((float)myHCALenergy3x3/(float)myElecTrk->p());
00307         
00308         myPFTau.setecalStripSumEOverPLead((float)myStripClusterE/(float)myElecTrk->p());
00309         myPFTau.sethcalTotOverPLead((float)myHCALenergy/(float)myElecTrk->p());
00310         
00311         myPFTau.setelectronPreIDDecision(myElecPreid);
00312         if (myElecTrk.isNonnull()) myPFTau.setelectronPreIDTrack(myElecTrk);
00313         
00314       // These need to be filled!
00315       //myPFTau.setbremsRecoveryEOverPLead(my...);
00316       //myPFTau.setelectronPreIDOutput(my...);
00317       }
00318 
00319 
00320 //From RECO
00321  if(DataType_ == "RECO"){
00322    
00323    // Against double counting of clusters
00324    std::vector<math::XYZPoint> hcalPosV; hcalPosV.clear();
00325       std::vector<math::XYZPoint> ecalPosV; ecalPosV.clear();
00326       for(int i=0;i<(int)myPFCands.size();i++){
00327         const ElementsInBlocks& elts = myPFCands[i]->elementsInBlocks();
00328         for(ElementsInBlocks::const_iterator it=elts.begin(); it!=elts.end(); ++it) {
00329           const reco::PFBlock& block = *(it->first);
00330           unsigned indexOfElementInBlock = it->second;
00331           const edm::OwnVector< reco::PFBlockElement >& elements = block.elements();
00332           assert(indexOfElementInBlock<elements.size());
00333           
00334           const reco::PFBlockElement& element = elements[indexOfElementInBlock];
00335           
00336           if(element.type()==reco::PFBlockElement::HCAL) {
00337             math::XYZPoint clusPos = element.clusterRef()->position();
00338             double en = (double)element.clusterRef()->energy();
00339             double et = (double)element.clusterRef()->energy()*fabs(sin(clusPos.Theta()));
00340             if (en>myMaximumHCALPFClusterE) {
00341               myMaximumHCALPFClusterE = en;
00342             }
00343             if (et>myMaximumHCALPFClusterEt) {
00344               myMaximumHCALPFClusterEt = et;
00345             }
00346             if (!checkPos(hcalPosV,clusPos)) {
00347               hcalPosV.push_back(clusPos);
00348               myHCALenergy += en;
00349               double deltaR = ROOT::Math::VectorUtil::DeltaR(myElecTrkEcalPos,clusPos);
00350               if (deltaR<0.184) {
00351                 myHCALenergy3x3 += en;
00352               }
00353             }
00354           } else if(element.type()==reco::PFBlockElement::ECAL) {
00355             double en = (double)element.clusterRef()->energy();
00356             math::XYZPoint clusPos = element.clusterRef()->position();
00357             if (!checkPos(ecalPosV,clusPos)) {
00358               ecalPosV.push_back(clusPos);
00359               myECALenergy += en;
00360               double deltaPhi = ROOT::Math::VectorUtil::DeltaPhi(myElecTrkEcalPos,clusPos);
00361               double deltaEta = abs(myElecTrkEcalPos.eta()-clusPos.eta());
00362               double deltaPhiOverQ = deltaPhi/(double)myElecTrk->charge();
00363               if (en >= EcalStripSumE_minClusEnergy_ && deltaEta<EcalStripSumE_deltaEta_ && deltaPhiOverQ > EcalStripSumE_deltaPhiOverQ_minValue_ && deltaPhiOverQ < EcalStripSumE_deltaPhiOverQ_maxValue_) { 
00364                 myStripClusterE += en;
00365               }
00366             }     
00367             
00368           }
00369         }
00370       }
00371       
00372       if ((myHCALenergy+myECALenergy)>0.)
00373         myEmfrac = myECALenergy/(myHCALenergy+myECALenergy);
00374       myPFTau.setemFraction((float)myEmfrac);
00375       myPFTau.sethcalTotOverPLead((float)myHCALenergy/(float)myElecTrk->p());
00376       myPFTau.sethcalMaxOverPLead((float)myMaximumHCALPFClusterE/(float)myElecTrk->p());
00377       myPFTau.sethcal3x3OverPLead((float)myHCALenergy3x3/(float)myElecTrk->p());
00378       myPFTau.setecalStripSumEOverPLead((float)myStripClusterE/(float)myElecTrk->p());
00379       myPFTau.setmaximumHCALPFClusterEt(myMaximumHCALPFClusterEt);
00380       myPFTau.setelectronPreIDDecision(myElecPreid);
00381       if (myElecTrk.isNonnull()) myPFTau.setelectronPreIDTrack(myElecTrk);
00382       
00383       // These need to be filled!
00384       //myPFTau.setbremsRecoveryEOverPLead(my...);
00385       //myPFTau.setelectronPreIDOutput(my...);
00386  }       
00387     }  
00388   }
00389   /* End elecron rejection */
00390   
00391   
00392   return myPFTau;  
00393 }

bool PFRecoTauAlgorithm::checkPos ( std::vector< math::XYZPoint >  CalPos,
math::XYZPoint  CandPos 
) const [private]

Definition at line 396 of file PFRecoTauAlgorithm.cc.

References i.

Referenced by buildPFTau().

00396                                                                                      {
00397   bool flag = false;
00398   for (unsigned int i=0;i<CalPos.size();i++) {
00399     if (CalPos[i] == CandPos) {
00400       flag = true;
00401       break;
00402     }
00403   }
00404   return flag;
00405   //return false;
00406 }

void PFRecoTauAlgorithm::setTransientTrackBuilder ( const TransientTrackBuilder *  x  ) 

Definition at line 72 of file PFRecoTauAlgorithm.cc.

References TransientTrackBuilder_.

Referenced by PFRecoTauProducer::produce().

00072 {TransientTrackBuilder_=x;}

Member Data Documentation

double PFRecoTauAlgorithm::AreaMetric_recoElements_maxabsEta_ [private]

Definition at line 75 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

uint32_t PFRecoTauAlgorithm::ChargedHadrCand_IsolAnnulus_minNhits_ [private]

Definition at line 77 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ChargedHadrCand_minPt_ [private]

Definition at line 38 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ChargedHadrCandLeadChargedHadrCand_tksmaxDZ_ [private]

Definition at line 40 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::DataType_ [private]

Definition at line 80 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::ECALIsolConeMetric_ [private]

Definition at line 63 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ECALIsolConeSize_max_ [private]

Definition at line 66 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ECALIsolConeSize_min_ [private]

Definition at line 65 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::ECALIsolConeSizeFormula_ [private]

Definition at line 64 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::ECALSignalConeMetric_ [private]

Definition at line 59 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ECALSignalConeSize_max_ [private]

Definition at line 62 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ECALSignalConeSize_min_ [private]

Definition at line 61 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::ECALSignalConeSizeFormula_ [private]

Definition at line 60 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::EcalStripSumE_deltaEta_ [private]

Definition at line 84 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::EcalStripSumE_deltaPhiOverQ_maxValue_ [private]

Definition at line 86 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::EcalStripSumE_deltaPhiOverQ_minValue_ [private]

Definition at line 85 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::EcalStripSumE_minClusEnergy_ [private]

Definition at line 83 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::ElecPreIDLeadTkMatch_maxDR_ [private]

Definition at line 82 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::GammaCand_minPt_ [private]

Definition at line 42 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::HCALIsolConeMetric_ [private]

Definition at line 71 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::HCALIsolConeSize_max_ [private]

Definition at line 74 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::HCALIsolConeSize_min_ [private]

Definition at line 73 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::HCALIsolConeSizeFormula_ [private]

Definition at line 72 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::HCALSignalConeMetric_ [private]

Definition at line 67 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::HCALSignalConeSize_max_ [private]

Definition at line 70 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::HCALSignalConeSize_min_ [private]

Definition at line 69 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::HCALSignalConeSizeFormula_ [private]

Definition at line 68 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::LeadChargedHadrCand_minPt_ [private]

Definition at line 37 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::LeadTrack_minPt_ [private]

Definition at line 43 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::MatchingConeMetric_ [private]

Definition at line 47 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::MatchingConeSize_max_ [private]

Definition at line 50 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::MatchingConeSize_min_ [private]

Definition at line 49 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::MatchingConeSizeFormula_ [private]

Definition at line 48 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myECALIsolConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myECALSignalConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myHCALIsolConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myHCALSignalConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myMatchingConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myTrackerIsolConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

TFormula PFRecoTauAlgorithm::myTrackerSignalConeSizeTFormula [private]

Definition at line 87 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::NeutrHadrCand_minPt_ [private]

Definition at line 41 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

uint32_t PFRecoTauAlgorithm::Track_IsolAnnulus_minNhits_ [private]

Definition at line 78 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::Track_minPt_ [private]

Definition at line 44 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::TrackerIsolConeMetric_ [private]

Definition at line 55 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::TrackerIsolConeSize_max_ [private]

Definition at line 58 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::TrackerIsolConeSize_min_ [private]

Definition at line 57 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::TrackerIsolConeSizeFormula_ [private]

Definition at line 56 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::TrackerSignalConeMetric_ [private]

Definition at line 51 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::TrackerSignalConeSize_max_ [private]

Definition at line 54 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::TrackerSignalConeSize_min_ [private]

Definition at line 53 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

string PFRecoTauAlgorithm::TrackerSignalConeSizeFormula_ [private]

Definition at line 52 of file PFRecoTauAlgorithm.h.

Referenced by PFRecoTauAlgorithm().

double PFRecoTauAlgorithm::TrackLeadTrack_maxDZ_ [private]

Definition at line 46 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

const TransientTrackBuilder* PFRecoTauAlgorithm::TransientTrackBuilder_ [private]

Definition at line 34 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and setTransientTrackBuilder().

bool PFRecoTauAlgorithm::UseChargedHadrCandLeadChargedHadrCand_tksDZconstraint_ [private]

Definition at line 39 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

bool PFRecoTauAlgorithm::UseTrackLeadTrackDZconstraint_ [private]

Definition at line 45 of file PFRecoTauAlgorithm.h.

Referenced by buildPFTau(), and PFRecoTauAlgorithm().

The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:29:45 2009 for CMSSW by  doxygen 1.5.4