#include <ElectronSeedGenerator.h>

Classes
struct	Tokens

Public Types
typedef TransientTrackingRecHit::ConstRecHitPointer	ConstRecHitPointer

typedef edm::OwnVector < TrackingRecHit >	PRecHitContainer

typedef TransientTrackingRecHit::RecHitContainer	RecHitContainer

typedef TransientTrackingRecHit::RecHitPointer	RecHitPointer

Public Member Functions
	ElectronSeedGenerator (const edm::ParameterSet &, const Tokens &, edm::ConsumesCollector &&)

void	run (edm::Event &, const reco::SuperClusterRefVector &, const std::vector< const TrajectorySeedCollection * > &seedsV, reco::ElectronSeedCollection &)

void	setupES (const edm::EventSetup &setup)

Private Member Functions
void	seedsFromThisCluster (edm::Ref< reco::SuperClusterCollection > seedCluster, reco::BeamSpot const &beamSpot, std::vector< reco::Vertex > const *vertices, reco::ElectronSeedCollection &out)

Private Attributes
const edm::EDGetTokenT < reco::BeamSpot >	beamSpotTag_

const float	deltaPhi1High_

const float	deltaPhi1Low_

const float	deltaPhi2B_

const float	deltaPhi2F_

const float	deltaZ1WithVertex_

const double	dPhi1Coef1_

const double	dPhi1Coef2_

const bool	dynamicPhiRoad_

const float	highPtThresh_

const std::vector< const TrajectorySeedCollection * > *	initialSeedCollectionVector_ = nullptr

const float	lowPtThresh_

const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	magFieldToken_

edm::ESWatcher < IdealMagneticFieldRecord >	magneticFieldWatcher_

PixelHitMatcher	matcher_

const float	nSigmasDeltaZ1_

const float	phiMax2B_

const float	phiMax2F_

const float	phiMin2B_

const float	phiMin2F_

const float	sizeWindowENeg_

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryToken_

edm::ESWatcher < TrackerDigiGeometryRecord >	trackerGeometryWatcher_

const bool	useRecoVertex_

const edm::EDGetTokenT < std::vector< reco::Vertex > >	verticesTag_

Detailed Description

Class to generate the trajectory seed from two hits in the pixel detector which have been found compatible with an ECAL cluster.

Author: U.Berthon, C.Charlot, LLR Palaiseau

Version: 1st Version May 30, 2006

Description: Top algorithm producing ElectronSeeds, ported from ORCA

Implementation: future redesign...

Definition at line 46 of file ElectronSeedGenerator.h.

Member Typedef Documentation

typedef TransientTrackingRecHit::ConstRecHitPointer ElectronSeedGenerator::ConstRecHitPointer

Definition at line 54 of file ElectronSeedGenerator.h.

typedef edm::OwnVector<TrackingRecHit> ElectronSeedGenerator::PRecHitContainer

Definition at line 53 of file ElectronSeedGenerator.h.

typedef TransientTrackingRecHit::RecHitContainer ElectronSeedGenerator::RecHitContainer

Definition at line 56 of file ElectronSeedGenerator.h.

typedef TransientTrackingRecHit::RecHitPointer ElectronSeedGenerator::RecHitPointer

Definition at line 55 of file ElectronSeedGenerator.h.

Constructor & Destructor Documentation

ElectronSeedGenerator::ElectronSeedGenerator	(	const edm::ParameterSet &	pset,
		const Tokens &	ts,
		edm::ConsumesCollector &&	cc
	)

Definition at line 128 of file ElectronSeedGenerator.cc.

     : dynamicPhiRoad_(pset.getParameter<bool>("dynamicPhiRoad")),
       verticesTag_(ts.token_vtx),
       beamSpotTag_(ts.token_bs),
       magFieldToken_{cc.esConsumes()},
       trackerGeometryToken_{cc.esConsumes()},
       lowPtThresh_(pset.getParameter<double>("LowPtThreshold")),
       highPtThresh_(pset.getParameter<double>("HighPtThreshold")),
       nSigmasDeltaZ1_(pset.getParameter<double>("nSigmasDeltaZ1")),
       deltaZ1WithVertex_(pset.getParameter<double>("deltaZ1WithVertex")),
       sizeWindowENeg_(pset.getParameter<double>("SizeWindowENeg")),
       deltaPhi1Low_(pset.getParameter<double>("DeltaPhi1Low")),
       deltaPhi1High_(pset.getParameter<double>("DeltaPhi1High")),
       // so that deltaPhi1 = dPhi1Coef1_ + dPhi1Coef2_/clusterEnergyT
       dPhi1Coef2_(dynamicPhiRoad_ ? (deltaPhi1Low_ - deltaPhi1High_) / (1. / lowPtThresh_ - 1. / highPtThresh_) : 0.),
       dPhi1Coef1_(dynamicPhiRoad_ ? deltaPhi1Low_ - dPhi1Coef2_ / lowPtThresh_ : 0.),
       // use of reco vertex
       useRecoVertex_(pset.getParameter<bool>("useRecoVertex")),
       // new B/F configurables
       deltaPhi2B_(pset.getParameter<double>("DeltaPhi2B")),
       deltaPhi2F_(pset.getParameter<double>("DeltaPhi2F")),
       phiMin2B_(-pset.getParameter<double>("PhiMax2B")),
       phiMin2F_(-pset.getParameter<double>("PhiMax2F")),
       phiMax2B_(pset.getParameter<double>("PhiMax2B")),
       phiMax2F_(pset.getParameter<double>("PhiMax2F")),
       matcher_(pset.getParameter<double>("ePhiMin1"),
                pset.getParameter<double>("ePhiMax1"),
                phiMin2B_,
                phiMax2B_,
                phiMin2F_,
                phiMax2F_,
                pset.getParameter<double>("z2MaxB"),
                pset.getParameter<double>("r2MaxF"),
                pset.getParameter<double>("rMaxI"),
                useRecoVertex_) {}

Member Function Documentation

void ElectronSeedGenerator::run	(	edm::Event &	e,
		const reco::SuperClusterRefVector &	sclRefs,
		const std::vector< const TrajectorySeedCollection * > &	seedsV,
		reco::ElectronSeedCollection &	out
	)

Definition at line 172 of file ElectronSeedGenerator.cc.

References beam_dqm_sourceclient-live_cfg::beamSpot, beamSpotTag_, edm::Event::get(), mps_fire::i, edm::EventBase::id(), initialSeedCollectionVector_, LogDebug, seedsFromThisCluster(), edm::RefVector< C, T, F >::size(), useRecoVertex_, beam_dqm_sourceclient-live_cfg::vertices, and verticesTag_.

                                                                  {
   initialSeedCollectionVector_ = &seedsV;
 
   // get the beamspot from the Event:
   auto const &beamSpot = e.get(beamSpotTag_);
 
   // if required get the vertices
   std::vector<reco::Vertex> const *vertices = nullptr;
   if (useRecoVertex_)
     vertices = &e.get(verticesTag_);
 
   for (unsigned int i = 0; i < sclRefs.size(); ++i) {
     // Find the seeds
     LogDebug("ElectronSeedGenerator") << "new cluster, calling seedsFromThisCluster";
     seedsFromThisCluster(sclRefs[i], beamSpot, vertices, out);
   }
 
   LogDebug("ElectronSeedGenerator") << ": For event " << e.id();
   LogDebug("ElectronSeedGenerator") << "Nr of superclusters after filter: " << sclRefs.size()
                                     << ", no. of ElectronSeeds found  = " << out.size();
 }

void ElectronSeedGenerator::seedsFromThisCluster	(	edm::Ref< reco::SuperClusterCollection >	seedCluster,
		reco::BeamSpot const &	beamSpot,
		std::vector< reco::Vertex > const *	vertices,
		reco::ElectronSeedCollection &	out
	)

private

Definition at line 197 of file ElectronSeedGenerator.cc.

References deltaPhi1High_, deltaPhi1Low_, deltaPhi2B_, deltaPhi2F_, deltaZ1WithVertex_, dPhi1Coef1_, dPhi1Coef2_, dynamicPhiRoad_, ele_convert(), PVValHelper::eta, highPtThresh_, initialSeedCollectionVector_, lowPtThresh_, matcher_, nSigmasDeltaZ1_, reco::BeamSpot::position(), PixelHitMatcher::set1stLayer(), PixelHitMatcher::set1stLayerZRange(), PixelHitMatcher::set2ndLayer(), BeamSpotPI::sigmaZ, reco::BeamSpot::sigmaZ(), reco::BeamSpot::sigmaZ0Error(), sizeWindowENeg_, mathSSE::sqrt(), and useRecoVertex_.

Referenced by run().

                                                                                   {
   float clusterEnergy = seedCluster->energy();
   GlobalPoint clusterPos(seedCluster->position().x(), seedCluster->position().y(), seedCluster->position().z());
   reco::ElectronSeed::CaloClusterRef caloCluster(seedCluster);
 
   if (dynamicPhiRoad_) {
     float clusterEnergyT = clusterEnergy / cosh(EleRelPoint(clusterPos, beamSpot.position()).eta());
 
     float deltaPhi1;
     if (clusterEnergyT < lowPtThresh_) {
       deltaPhi1 = deltaPhi1Low_;
     } else if (clusterEnergyT > highPtThresh_) {
       deltaPhi1 = deltaPhi1High_;
     } else {
       deltaPhi1 = dPhi1Coef1_ + dPhi1Coef2_ / clusterEnergyT;
     }
 
     matcher_.set1stLayer(-deltaPhi1 * sizeWindowENeg_, deltaPhi1 * (1. - sizeWindowENeg_));
     matcher_.set2ndLayer(-deltaPhi2B_ / 2., deltaPhi2B_ / 2., -deltaPhi2F_ / 2., deltaPhi2F_ / 2.);
   }
 
   if (!useRecoVertex_)  // here use the beam spot position
   {
     double sigmaZ = beamSpot.sigmaZ();
     double sigmaZ0Error = beamSpot.sigmaZ0Error();
     double sq = sqrt(sigmaZ * sigmaZ + sigmaZ0Error * sigmaZ0Error);
     double myZmin1 = beamSpot.position().z() - nSigmasDeltaZ1_ * sq;
     double myZmax1 = beamSpot.position().z() + nSigmasDeltaZ1_ * sq;
 
     GlobalPoint vertexPos;
     ele_convert(beamSpot.position(), vertexPos);
 
     matcher_.set1stLayerZRange(myZmin1, myZmax1);
 
     // try electron
     auto elePixelSeeds = matcher_(*initialSeedCollectionVector_, clusterPos, vertexPos, clusterEnergy, -1.);
     seedsFromTrajectorySeeds(elePixelSeeds, caloCluster, out, false);
     // try positron
     auto posPixelSeeds = matcher_(*initialSeedCollectionVector_, clusterPos, vertexPos, clusterEnergy, 1.);
     seedsFromTrajectorySeeds(posPixelSeeds, caloCluster, out, true);
 
   } else if (vertices)  // here we use the reco vertices
   {
     for (auto const &vertex : *vertices) {
       GlobalPoint vertexPos(vertex.position().x(), vertex.position().y(), vertex.position().z());
       double myZmin1, myZmax1;
       if (vertexPos.z() == beamSpot.position().z()) {  // in case vetex not found
         double sigmaZ = beamSpot.sigmaZ();
         double sigmaZ0Error = beamSpot.sigmaZ0Error();
         double sq = sqrt(sigmaZ * sigmaZ + sigmaZ0Error * sigmaZ0Error);
         myZmin1 = beamSpot.position().z() - nSigmasDeltaZ1_ * sq;
         myZmax1 = beamSpot.position().z() + nSigmasDeltaZ1_ * sq;
       } else {  // a vertex has been recoed
         myZmin1 = vertex.position().z() - deltaZ1WithVertex_;
         myZmax1 = vertex.position().z() + deltaZ1WithVertex_;
       }
 
       matcher_.set1stLayerZRange(myZmin1, myZmax1);
 
       // try electron
       auto elePixelSeeds = matcher_(*initialSeedCollectionVector_, clusterPos, vertexPos, clusterEnergy, -1.);
       seedsFromTrajectorySeeds(elePixelSeeds, caloCluster, out, false);
       // try positron
       auto posPixelSeeds = matcher_(*initialSeedCollectionVector_, clusterPos, vertexPos, clusterEnergy, 1.);
       seedsFromTrajectorySeeds(posPixelSeeds, caloCluster, out, true);
     }
   }
 }

void ElectronSeedGenerator::setupES ( const edm::EventSetup & setup )

Definition at line 166 of file ElectronSeedGenerator.cc.

References edm::ESWatcher< T >::check(), edm::EventSetup::getData(), magFieldToken_, magneticFieldWatcher_, matcher_, PixelHitMatcher::setES(), trackerGeometryToken_, and trackerGeometryWatcher_.

                                                               {
   if (magneticFieldWatcher_.check(setup) || trackerGeometryWatcher_.check(setup)) {
     matcher_.setES(setup.getData(magFieldToken_), setup.getData(trackerGeometryToken_));
   }
 }