#include <TauRegionalPixelSeedGenerator.h>

Inheritance diagram for TauRegionalPixelSeedGenerator:

Public Member Functions
virtual std::vector < TrackingRegion * >	regions (const edm::Event &e, const edm::EventSetup &es) const
	TauRegionalPixelSeedGenerator (const edm::ParameterSet &conf_)
virtual	~TauRegionalPixelSeedGenerator ()
Private Attributes
edm::ParameterSet	conf_
float	m_deltaEta
float	m_deltaPhi
float	m_halfLength
double	m_howToUseMeasurementTracker
edm::InputTag	m_jetSrc
std::string	m_measurementTracker
float	m_originRadius
float	m_ptMin
bool	m_searchOpt
edm::InputTag	m_vertexSrc

Detailed Description

Definition at line 31 of file TauRegionalPixelSeedGenerator.h.

Constructor & Destructor Documentation

TauRegionalPixelSeedGenerator::TauRegionalPixelSeedGenerator ( const edm::ParameterSet & conf_ ) [inline, explicit]

Definition at line 34 of file TauRegionalPixelSeedGenerator.h.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_jetSrc, m_measurementTracker, m_originRadius, m_ptMin, m_searchOpt, and m_vertexSrc.

                                                                        {
      edm::LogInfo ("TauRegionalPixelSeedGenerator") << "Enter the TauRegionalPixelSeedGenerator";

      edm::ParameterSet regionPSet = conf_.getParameter<edm::ParameterSet>("RegionPSet");

      m_ptMin        = regionPSet.getParameter<double>("ptMin");
      m_originRadius = regionPSet.getParameter<double>("originRadius");
      m_halfLength   = regionPSet.getParameter<double>("originHalfLength");
      m_deltaEta     = regionPSet.getParameter<double>("deltaEtaRegion");
      m_deltaPhi     = regionPSet.getParameter<double>("deltaPhiRegion");
      m_jetSrc       = regionPSet.getParameter<edm::InputTag>("JetSrc");
      m_vertexSrc    = regionPSet.getParameter<edm::InputTag>("vertexSrc");
      if (regionPSet.exists("searchOpt")){
        m_searchOpt    = regionPSet.getParameter<bool>("searchOpt");
      }
      else{
        m_searchOpt = false;
      }
      m_measurementTracker ="";
      m_howToUseMeasurementTracker=0;
      if (regionPSet.exists("measurementTrackerName")){
        m_measurementTracker = regionPSet.getParameter<std::string>("measurementTrackerName");
        if (regionPSet.exists("howToUseMeasurementTracker")){
          m_howToUseMeasurementTracker = regionPSet.getParameter<double>("howToUseMeasurementTracker");
        }
      }
    }

virtual TauRegionalPixelSeedGenerator::~TauRegionalPixelSeedGenerator ( ) [inline, virtual]

Definition at line 62 of file TauRegionalPixelSeedGenerator.h.

{}

Member Function Documentation

virtual std::vector<TrackingRegion* > TauRegionalPixelSeedGenerator::regions	(	const edm::Event &	e,
		const edm::EventSetup &	es
	)		const `[inline, virtual]`

Implements TrackingRegionProducer.

Definition at line 65 of file TauRegionalPixelSeedGenerator.h.

References edm::Event::getByLabel(), m_deltaEta, m_deltaPhi, m_halfLength, m_howToUseMeasurementTracker, m_jetSrc, m_measurementTracker, m_originRadius, m_ptMin, m_searchOpt, m_vertexSrc, reco::Candidate::momentum(), and query::result.

                                                                                                  {
      std::vector<TrackingRegion* > result;

      //      double originZ;
      double deltaZVertex, deltaRho;
        GlobalPoint vertex;
      // get the primary vertex
      edm::Handle<reco::VertexCollection> h_vertices;
      e.getByLabel(m_vertexSrc, h_vertices);
      const reco::VertexCollection & vertices = * h_vertices;
      if (not vertices.empty()) {
//        originZ      = vertices.front().z();
        GlobalPoint myTmp(vertices.at(0).position().x(),vertices.at(0).position().y(), vertices.at(0).position().z());
          vertex = myTmp;
          deltaZVertex = m_halfLength;
          deltaRho = m_originRadius;
      } else {
  //      originZ      =  0.;
          GlobalPoint myTmp(0.,0.,0.);
          vertex = myTmp;
          deltaRho = 1.;
         deltaZVertex = 15.;
      }
      
      // get the jet direction
      edm::Handle<edm::View<reco::Candidate> > h_jets;
      e.getByLabel(m_jetSrc, h_jets);
      
      for (unsigned int iJet =0; iJet < h_jets->size(); ++iJet)
        {
          const reco::Candidate & myJet = (*h_jets)[iJet];
          GlobalVector jetVector(myJet.momentum().x(),myJet.momentum().y(),myJet.momentum().z());
//          GlobalPoint  vertex(0, 0, originZ);
          RectangularEtaPhiTrackingRegion* etaphiRegion = new RectangularEtaPhiTrackingRegion( jetVector,
                                                                                               vertex,
                                                                                               m_ptMin,
                                                                                               deltaRho,
                                                                                               deltaZVertex,
                                                                                               m_deltaEta,
                                                                                               m_deltaPhi,
                                                                                               m_howToUseMeasurementTracker,
                                                                                               true,
                                                                                               m_measurementTracker,
                                                                                               m_searchOpt);
          result.push_back(etaphiRegion);
      }

      return result;
    }