#include <CaloRecoTauTagInfoAlgorithm.h>

Public Member Functions
reco::CaloTauTagInfo	buildCaloTauTagInfo (edm::Event &, const edm::EventSetup &, const reco::CaloJetRef &, const reco::TrackRefVector &, const reco::Vertex &)

reco::CaloTauTagInfo	buildCaloTauTagInfo (edm::Event &, const edm::EventSetup &, const reco::JetBaseRef &, const reco::TrackRefVector &, const reco::Vertex &)

	CaloRecoTauTagInfoAlgorithm ()

	CaloRecoTauTagInfoAlgorithm (const edm::ParameterSet &parameters)

std::vector< DetId >	getVectorDetId (const reco::CaloJetRef &)

	~CaloRecoTauTagInfoAlgorithm ()

Private Member Functions
reco::TrackRefVector	filterTracksByQualityBit (const reco::TrackRefVector &tracks, reco::TrackBase::TrackQuality quality) const

std::vector < reco::BasicClusterRef >	getNeutralEcalBasicClusters (edm::Event &, const edm::EventSetup &theEventSetup, const reco::CaloJetRef &, const reco::TrackRefVector &, float theECALBasicClustersAroundCaloJet_DRConeSize, float theECALBasicClusterminE, float theECALBasicClusterpropagTrack_matchingDRConeSize)

Private Attributes
edm::InputTag	BarrelBasicClusters_

edm::InputTag	EBRecHitsLabel_

double	ECALBasicClusterminE_

double	ECALBasicClusterpropagTrack_matchingDRConeSize_

double	ECALBasicClustersAroundCaloJet_DRConeSize_

edm::InputTag	EERecHitsLabel_

edm::InputTag	EndcapBasicClusters_

edm::InputTag	ESRecHitsLabel_

double	tkmaxChi2_

double	tkmaxipt_

int	tkminPixelHitsn_

double	tkminPt_

int	tkminTrackerHitsn_

double	tkPVmaxDZ_

reco::TrackBase::TrackQuality	tkQuality_

bool	UsePVconstraint_

bool	UseTrackQuality_

Detailed Description

Definition at line 33 of file CaloRecoTauTagInfoAlgorithm.h.

Constructor & Destructor Documentation

CaloRecoTauTagInfoAlgorithm::CaloRecoTauTagInfoAlgorithm ( )

inline

Definition at line 35 of file CaloRecoTauTagInfoAlgorithm.h.

35 {}

CaloRecoTauTagInfoAlgorithm::CaloRecoTauTagInfoAlgorithm ( const edm::ParameterSet & parameters )

Definition at line 6 of file CaloRecoTauTagInfoAlgorithm.cc.

References edm::ParameterSet::getParameter(), reco::TrackBase::qualityByName(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
   // parameters of the considered rec. Tracks (catched through a JetTracksAssociation object) :
   tkminPt_                            = parameters.getParameter<double>("tkminPt");
   tkminPixelHitsn_                    = parameters.getParameter<int>("tkminPixelHitsn");
   tkminTrackerHitsn_                  = parameters.getParameter<int>("tkminTrackerHitsn");
   tkmaxipt_                           = parameters.getParameter<double>("tkmaxipt");
   tkmaxChi2_                          = parameters.getParameter<double>("tkmaxChi2");
   // 
   UsePVconstraint_                    = parameters.getParameter<bool>("UsePVconstraint");
   tkPVmaxDZ_                          = parameters.getParameter<double>("tkPVmaxDZ");
   //
   UseTrackQuality_                    = parameters.getParameter<bool>("UseTrackQuality");
   if (UseTrackQuality_) {
     tkQuality_ = reco::TrackBase::qualityByName(parameters.getParameter<std::string>("tkQuality"));
   }
   // parameters of the considered EcalRecHits 
   BarrelBasicClusters_                = parameters.getParameter<edm::InputTag>("BarrelBasicClustersSource"); 
   EndcapBasicClusters_                = parameters.getParameter<edm::InputTag>("EndcapBasicClustersSource"); 
   // parameters of the considered neutral ECAL BasicClusters
   ECALBasicClustersAroundCaloJet_DRConeSize_      = parameters.getParameter<double>("ECALBasicClustersAroundCaloJet_DRConeSize");
   ECALBasicClusterminE_                           = parameters.getParameter<double>("ECALBasicClusterminE");
   ECALBasicClusterpropagTrack_matchingDRConeSize_ = parameters.getParameter<double>("ECALBasicClusterpropagTrack_matchingDRConeSize");
 }

CaloRecoTauTagInfoAlgorithm::~CaloRecoTauTagInfoAlgorithm ( )

inline

Definition at line 37 of file CaloRecoTauTagInfoAlgorithm.h.

37 {}

Member Function Documentation

CaloTauTagInfo CaloRecoTauTagInfoAlgorithm::buildCaloTauTagInfo	(	edm::Event &	theEvent,
		const edm::EventSetup &	theEventSetup,
		const reco::CaloJetRef &	theCaloJet,
		const reco::TrackRefVector &	theTracks,
		const reco::Vertex &	thePV
	)

Definition at line 30 of file CaloRecoTauTagInfoAlgorithm.cc.

References TauTagTools::filteredTracks(), reco::CaloTauTagInfo::setcalojetRef(), reco::CaloTauTagInfo::setneutralECALBasicClusters(), reco::BaseTauTagInfo::setTracks(), and reco::Vertex::z().

                                                                                                                                                                                                      {
   CaloTauTagInfo resultExtended;
   resultExtended.setcalojetRef(theCaloJet);
 
   TrackRefVector theFilteredTracks;
   if (UsePVconstraint_) theFilteredTracks=TauTagTools::filteredTracks(theTracks,tkminPt_,tkminPixelHitsn_,tkminTrackerHitsn_,tkmaxipt_,tkmaxChi2_,tkPVmaxDZ_,thePV, thePV.z());
   else theFilteredTracks=TauTagTools::filteredTracks(theTracks,tkminPt_,tkminPixelHitsn_,tkminTrackerHitsn_,tkmaxipt_,tkmaxChi2_,thePV);
   if (UseTrackQuality_) theFilteredTracks = filterTracksByQualityBit(theFilteredTracks,tkQuality_);
   resultExtended.setTracks(theFilteredTracks);
   
   //resultExtended.setpositionAndEnergyECALRecHits(getPositionAndEnergyEcalRecHits(theEvent,theEventSetup,theCaloJet));
 
   std::vector<BasicClusterRef> theNeutralEcalBasicClusters=getNeutralEcalBasicClusters(theEvent,theEventSetup,theCaloJet,theFilteredTracks,ECALBasicClustersAroundCaloJet_DRConeSize_,ECALBasicClusterminE_,ECALBasicClusterpropagTrack_matchingDRConeSize_);
   resultExtended.setneutralECALBasicClusters(theNeutralEcalBasicClusters);
   
   return resultExtended; 
 }

CaloTauTagInfo CaloRecoTauTagInfoAlgorithm::buildCaloTauTagInfo	(	edm::Event &	theEvent,
		const edm::EventSetup &	theEventSetup,
		const reco::JetBaseRef &	theJet,
		const reco::TrackRefVector &	theTracks,
		const reco::Vertex &	thePV
	)

Definition at line 47 of file CaloRecoTauTagInfoAlgorithm.cc.

References reco::CaloTauTagInfo::calojetRef(), TauTagTools::filteredTracks(), reco::CaloTauTagInfo::setJetRef(), reco::CaloTauTagInfo::setneutralECALBasicClusters(), reco::BaseTauTagInfo::setTracks(), and reco::Vertex::z().

                                                                                                                                                                                                  {
   CaloTauTagInfo resultExtended;
   resultExtended.setJetRef(theJet);
 
   TrackRefVector theFilteredTracks;
   if (UsePVconstraint_) theFilteredTracks=TauTagTools::filteredTracks(theTracks,tkminPt_,tkminPixelHitsn_,tkminTrackerHitsn_,tkmaxipt_,tkmaxChi2_,tkPVmaxDZ_,thePV, thePV.z());
   else theFilteredTracks=TauTagTools::filteredTracks(theTracks,tkminPt_,tkminPixelHitsn_,tkminTrackerHitsn_,tkmaxipt_,tkmaxChi2_,thePV);
   if (UseTrackQuality_) theFilteredTracks = filterTracksByQualityBit(theFilteredTracks,tkQuality_);
   resultExtended.setTracks(theFilteredTracks);
 
   //resultExtended.setpositionAndEnergyECALRecHits(getPositionAndEnergyEcalRecHits(theEvent,theEventSetup,theCaloJet));
 
   //reco::JPTJetRef const theJPTJetRef = theJet.castTo<reco::JPTJetRef>();
   //reco::CaloJetRef const theCaloJet = (theJPTJetRef->getCaloJetRef()).castTo<reco::CaloJetRef>();
   reco::CaloJetRef const theCaloJet = resultExtended.calojetRef();
   std::vector<BasicClusterRef> theNeutralEcalBasicClusters=getNeutralEcalBasicClusters(theEvent,theEventSetup,theCaloJet,theFilteredTracks,ECALBasicClustersAroundCaloJet_DRConeSize_,ECALBasicClusterminE_,ECALBasicClusterpropagTrack_matchingDRConeSize_);
   resultExtended.setneutralECALBasicClusters(theNeutralEcalBasicClusters);
 
   return resultExtended;
 }

TrackRefVector CaloRecoTauTagInfoAlgorithm::filterTracksByQualityBit	(	const reco::TrackRefVector &	tracks,
		reco::TrackBase::TrackQuality	quality
	)		const

private

Definition at line 185 of file CaloRecoTauTagInfoAlgorithm.cc.

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

 {
   TrackRefVector filteredTracks;
   for (TrackRefVector::const_iterator iTrack = tracks.begin(); iTrack != tracks.end(); iTrack++) {
     if ((*iTrack)->quality(quality)) filteredTracks.push_back(*iTrack);
   }
   return filteredTracks;
 }

std::vector< BasicClusterRef > CaloRecoTauTagInfoAlgorithm::getNeutralEcalBasicClusters	(	edm::Event &	theEvent,
		const edm::EventSetup &	theEventSetup,
		const reco::CaloJetRef &	theCaloJet,
		const reco::TrackRefVector &	theTracks,
		float	theECALBasicClustersAroundCaloJet_DRConeSize,
		float	theECALBasicClusterminE,
		float	theECALBasicClusterpropagTrack_matchingDRConeSize
	)

private

Definition at line 137 of file CaloRecoTauTagInfoAlgorithm.cc.

References edm::RefVector< C, T, F >::begin(), HLT_25ns14e33_v1_cff::DeltaR, edm::RefVector< C, T, F >::end(), edm::EventSetup::get(), edm::Event::getByLabel(), edm::Ref< C, T, F >::isNull(), edm::ESHandle< class >::product(), and TauTagTools::propagTrackECALSurfContactPoint().

                                                                                                                                                                                                                                                                                                                                               {
   std::vector<math::XYZPoint> thepropagTracksECALSurfContactPoints;
   edm::ESHandle<MagneticField> theMF;
   theEventSetup.get<IdealMagneticFieldRecord>().get(theMF);
   const MagneticField* theMagField=theMF.product();
   for(TrackRefVector::const_iterator i_Track=theTracks.begin();i_Track!=theTracks.end();i_Track++){
     math::XYZPoint thepropagTrackECALSurfContactPoint=TauTagTools::propagTrackECALSurfContactPoint(theMagField,*i_Track);
     if(thepropagTrackECALSurfContactPoint.R()!=0.) thepropagTracksECALSurfContactPoints.push_back(thepropagTrackECALSurfContactPoint);
   }
   
   math::XYZPoint aCaloJetFakePosition((*theCaloJet).px(),(*theCaloJet).py(),(*theCaloJet).pz());
     
   std::vector<BasicClusterRef> theBasicClusters; 
   
   edm::Handle<BasicClusterCollection> theBarrelBCCollection;
   //  theEvent.getByLabel("islandBasicClusters","islandBarrelBasicClusters",theBarrelBCCollection);
   theEvent.getByLabel(BarrelBasicClusters_,theBarrelBCCollection);
   for(unsigned int i_BC=0;i_BC!=theBarrelBCCollection->size();i_BC++) { 
     BasicClusterRef theBasicClusterRef(theBarrelBCCollection,i_BC);    
     if (theBasicClusterRef.isNull()) continue;  
     if (ROOT::Math::VectorUtil::DeltaR(aCaloJetFakePosition,(*theBasicClusterRef).position())<=theECALBasicClustersAroundCaloJet_DRConeSize && (*theBasicClusterRef).energy()>=theECALBasicClusterminE) theBasicClusters.push_back(theBasicClusterRef);
   }
   edm::Handle<BasicClusterCollection> theEndcapBCCollection;
   //  theEvent.getByLabel("islandBasicClusters","islandEndcapBasicClusters",theEndcapBCCollection);
   theEvent.getByLabel(EndcapBasicClusters_,theEndcapBCCollection);
   for(unsigned int j_BC=0;j_BC!=theEndcapBCCollection->size();j_BC++) { 
     BasicClusterRef theBasicClusterRef(theEndcapBCCollection,j_BC); 
     if (theBasicClusterRef.isNull()) continue;  
     if (ROOT::Math::VectorUtil::DeltaR(aCaloJetFakePosition,(*theBasicClusterRef).position())<=theECALBasicClustersAroundCaloJet_DRConeSize && (*theBasicClusterRef).energy()>=theECALBasicClusterminE) theBasicClusters.push_back(theBasicClusterRef);
   }  
   
   std::vector<BasicClusterRef> theNeutralBasicClusters=theBasicClusters;  
   std::vector<BasicClusterRef>::iterator kmatchedBasicCluster;
   for (std::vector<math::XYZPoint>::iterator ipropagTrackECALSurfContactPoint=thepropagTracksECALSurfContactPoints.begin();ipropagTrackECALSurfContactPoint!=thepropagTracksECALSurfContactPoints.end();ipropagTrackECALSurfContactPoint++) {
     double theMatchedEcalBasicClusterpropagTrack_minDR=theECALBasicClusterpropagTrack_matchingDRConeSize;
     bool Track_matchedwithEcalBasicCluster=false;
     for (std::vector<BasicClusterRef>::iterator jBasicCluster=theNeutralBasicClusters.begin();jBasicCluster!=theNeutralBasicClusters.end();jBasicCluster++) {
       if(ROOT::Math::VectorUtil::DeltaR((*ipropagTrackECALSurfContactPoint),(**jBasicCluster).position())<theMatchedEcalBasicClusterpropagTrack_minDR){
         Track_matchedwithEcalBasicCluster=true;
     theMatchedEcalBasicClusterpropagTrack_minDR=ROOT::Math::VectorUtil::DeltaR((*ipropagTrackECALSurfContactPoint),(**jBasicCluster).position());
     kmatchedBasicCluster=jBasicCluster;
       }
     }
     if(Track_matchedwithEcalBasicCluster) kmatchedBasicCluster=theNeutralBasicClusters.erase(kmatchedBasicCluster);
   }
   return theNeutralBasicClusters;
 }

std::vector< DetId > CaloRecoTauTagInfoAlgorithm::getVectorDetId ( const reco::CaloJetRef & theCaloJet )

Definition at line 120 of file CaloRecoTauTagInfoAlgorithm.cc.

References j.

                                                                                         {
   std::vector<CaloTowerPtr> theCaloTowers=theCaloJet->getCaloConstituents();
   std::vector<DetId> myDetIds;
   myDetIds.clear();
 
   for(std::vector<CaloTowerPtr>::const_iterator i_Tower=theCaloTowers.begin();i_Tower!=theCaloTowers.end();i_Tower++){
     size_t numRecHits = (**i_Tower).constituentsSize();
     for(size_t j=0;j<numRecHits;j++) {
       DetId RecHitDetID=(**i_Tower).constituent(j);      
 
       myDetIds.push_back(RecHitDetID);
     }
   }
   return myDetIds;
 }