ElectronSeedGenerator Class Reference

#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 &)
void	run (edm::Event &, const edm::EventSetup &setup, const reco::SuperClusterRefVector &, const std::vector< float > &hoe1s, const std::vector< float > &hoe2s, TrajectorySeedCollection *seeds, reco::ElectronSeedCollection &)
void	setupES (const edm::EventSetup &setup)
	~ElectronSeedGenerator ()

Private Member Functions
void	addSeed (reco::ElectronSeed &seed, const SeedWithInfo *info, bool positron, reco::ElectronSeedCollection &out)
bool	prepareElTrackSeed (ConstRecHitPointer outerhit, ConstRecHitPointer innerhit, const GlobalPoint &vertexPos)
void	seedsFromRecHits (std::vector< std::pair< RecHitWithDist, ConstRecHitPointer > > &elePixelHits, PropagationDirection &dir, const GlobalPoint &vertexPos, const reco::ElectronSeed::CaloClusterRef &cluster, reco::ElectronSeedCollection &out, bool positron)
void	seedsFromThisCluster (edm::Ref< reco::SuperClusterCollection > seedCluster, float hoe1, float hoe2, reco::ElectronSeedCollection &out, const TrackerTopology *tTopo)
void	seedsFromTrajectorySeeds (const std::vector< SeedWithInfo > &elePixelSeeds, const reco::ElectronSeed::CaloClusterRef &cluster, float hoe1, float hoe2, reco::ElectronSeedCollection &out, bool positron)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotTag_
unsigned long long	cacheIDCkfComp_
unsigned long long	cacheIDMagField_
unsigned long long	cacheIDNavSchool_
unsigned long long	cacheIDTrkGeom_
double	deltaPhi1Coef1_
double	deltaPhi1Coef2_
float	deltaPhi1High_
float	deltaPhi1Low_
float	deltaPhi2B_
float	deltaPhi2F_
float	deltaZ1WithVertex_
bool	dynamicphiroad_
bool	fromTrackerSeeds_
float	highPtThreshold_
float	lowPtThreshold_
PixelHitMatcher *	myMatchEle
PixelHitMatcher *	myMatchPos
float	nSigmasDeltaZ1_
float	phiMax2B_
float	phiMax2F_
float	phiMin2B_
float	phiMin2F_
PTrajectoryStateOnDet	pts_
PRecHitContainer	recHits_
float	sizeWindowENeg_
edm::Handle< reco::BeamSpot >	theBeamSpot
TrajectorySeedCollection *	theInitialSeedColl
edm::ESHandle< MagneticField >	theMagField
const MeasurementTracker *	theMeasurementTracker
edm::InputTag	theMeasurementTrackerEventTag
std::string	theMeasurementTrackerName
const NavigationSchool *	theNavigationSchool
PropagatorWithMaterial *	thePropagator
const edm::EventSetup *	theSetup
edm::ESHandle< TrackerGeometry >	theTrackerGeometry
KFUpdator *	theUpdator
edm::Handle< std::vector < reco::Vertex > >	theVertices
bool	useRecoVertex_
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 50 of file ElectronSeedGenerator.h.

Member Typedef Documentation

typedef TransientTrackingRecHit::ConstRecHitPointer ElectronSeedGenerator::ConstRecHitPointer

Definition at line 60 of file ElectronSeedGenerator.h.

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

Definition at line 59 of file ElectronSeedGenerator.h.

typedef TransientTrackingRecHit::RecHitContainer ElectronSeedGenerator::RecHitContainer

Definition at line 62 of file ElectronSeedGenerator.h.

typedef TransientTrackingRecHit::RecHitPointer ElectronSeedGenerator::RecHitPointer

Definition at line 61 of file ElectronSeedGenerator.h.

Constructor & Destructor Documentation

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

Definition at line 48 of file ElectronSeedGenerator.cc.

References deltaPhi1Coef1_, deltaPhi1Coef2_, deltaPhi1High_, deltaPhi1Low_, deltaPhi2B_, deltaPhi2F_, deltaZ1WithVertex_, dynamicphiroad_, edm::ParameterSet::exists(), edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), highPtThreshold_, lowPtThreshold_, myMatchEle, myMatchPos, phiMax2B_, phiMax2F_, phiMin2B_, phiMin2F_, AlCaHLTBitMon_QueryRunRegistry::string, theMeasurementTrackerEventTag, theMeasurementTrackerName, theUpdator, and useRecoVertex_.

 : dynamicphiroad_(pset.getParameter<bool>("dynamicPhiRoad")),
   fromTrackerSeeds_(pset.getParameter<bool>("fromTrackerSeeds")),
   useRecoVertex_(false),
   verticesTag_(ts.token_vtx),
   beamSpotTag_(ts.token_bs),
   lowPtThreshold_(pset.getParameter<double>("LowPtThreshold")),
   highPtThreshold_(pset.getParameter<double>("HighPtThreshold")),
   nSigmasDeltaZ1_(pset.getParameter<double>("nSigmasDeltaZ1")),
   deltaZ1WithVertex_(0.5),
   sizeWindowENeg_(pset.getParameter<double>("SizeWindowENeg")),
   deltaPhi1Low_(pset.getParameter<double>("DeltaPhi1Low")),
   deltaPhi1High_(pset.getParameter<double>("DeltaPhi1High")),
   deltaPhi1Coef1_(0.), deltaPhi1Coef2_(0.),
   myMatchEle(0), myMatchPos(0),
   thePropagator(0),
   theMeasurementTracker(0),
   theSetup(0), 
   cacheIDMagField_(0),/*cacheIDGeom_(0),*/cacheIDNavSchool_(0),cacheIDCkfComp_(0),cacheIDTrkGeom_(0)
 {
  // so that deltaPhi1 = deltaPhi1Coef1_ + deltaPhi1Coef2_/clusterEnergyT
  if (dynamicphiroad_)
   {
    deltaPhi1Coef2_ = (deltaPhi1Low_-deltaPhi1High_)/(1./lowPtThreshold_-1./highPtThreshold_) ;
    deltaPhi1Coef1_ = deltaPhi1Low_ - deltaPhi1Coef2_/lowPtThreshold_ ;
   }

  // use of a theMeasurementTrackerName
  if (pset.exists("measurementTrackerName"))
   { theMeasurementTrackerName = pset.getParameter<std::string>("measurementTrackerName") ; }
  if (pset.existsAs<edm::InputTag>("measurementTrackerEvent")) {
    theMeasurementTrackerEventTag = pset.getParameter<edm::InputTag>("measurementTrackerEvent");
  }

  // use of reco vertex
  if (pset.exists("useRecoVertex"))
   { useRecoVertex_ = pset.getParameter<bool>("useRecoVertex") ; }
  /*
  if (pset.exists("vertices"))
   { verticesTag_ = pset.getParameter<edm::InputTag>("vertices") ; }
  */
  if (pset.exists("deltaZ1WithVertex"))
   { deltaZ1WithVertex_ = pset.getParameter<double>("deltaZ1WithVertex") ; }

  // new beamSpot tag
  /*
  if (pset.exists("beamSpot"))
   { beamSpotTag_ = pset.getParameter<edm::InputTag>("beamSpot") ; }
  */

  // new B/F configurables
  if (pset.exists("DeltaPhi2"))
   { deltaPhi2B_ = deltaPhi2F_ = pset.getParameter<double>("DeltaPhi2") ; }
  else
   {
    deltaPhi2B_ = pset.getParameter<double>("DeltaPhi2B") ;
    deltaPhi2F_ = pset.getParameter<double>("DeltaPhi2F") ;
   }
  if (pset.exists("PhiMin2"))
   { phiMin2B_ = phiMin2F_ = pset.getParameter<double>("PhiMin2") ; }
  else
   {
    phiMin2B_ = pset.getParameter<double>("PhiMin2B") ;
    phiMin2F_ = pset.getParameter<double>("PhiMin2F") ;
   }
  if (pset.exists("PhiMax2"))
   { phiMax2B_ = phiMax2F_ = pset.getParameter<double>("PhiMax2") ; }
  else
   {
    phiMax2B_ = pset.getParameter<double>("PhiMax2B") ;
    phiMax2F_ = pset.getParameter<double>("PhiMax2F") ;
   }

  // Instantiate the pixel hit matchers
  myMatchEle = new PixelHitMatcher
   ( pset.getParameter<double>("ePhiMin1"),
         pset.getParameter<double>("ePhiMax1"),
         phiMin2B_, phiMax2B_, phiMin2F_, phiMax2F_,
     pset.getParameter<double>("z2MinB"),
     pset.getParameter<double>("z2MaxB"),
     pset.getParameter<double>("r2MinF"),
     pset.getParameter<double>("r2MaxF"),
     pset.getParameter<double>("rMinI"),
     pset.getParameter<double>("rMaxI"),
     pset.getParameter<bool>("searchInTIDTEC") ) ;

  myMatchPos = new PixelHitMatcher
   ( pset.getParameter<double>("pPhiMin1"),
         pset.getParameter<double>("pPhiMax1"),
         phiMin2B_, phiMax2B_, phiMin2F_, phiMax2F_,
     pset.getParameter<double>("z2MinB"),
     pset.getParameter<double>("z2MaxB"),
     pset.getParameter<double>("r2MinF"),
     pset.getParameter<double>("r2MaxF"),
     pset.getParameter<double>("rMinI"),
     pset.getParameter<double>("rMaxI"),
     pset.getParameter<bool>("searchInTIDTEC") ) ;

  theUpdator = new KFUpdator() ;
 }

ElectronSeedGenerator::~ElectronSeedGenerator

(

)

Definition at line 150 of file ElectronSeedGenerator.cc.

References myMatchEle, myMatchPos, thePropagator, and theUpdator.

 {
  delete myMatchEle ;
  delete myMatchPos ;
  delete thePropagator ;
  delete theUpdator ;
 }

Member Function Documentation

void ElectronSeedGenerator::addSeed ( reco::ElectronSeed &  seed, const SeedWithInfo *  info, bool  positron, reco::ElectronSeedCollection &  out  )

private

Definition at line 491 of file ElectronSeedGenerator.cc.

References reco::ElectronSeed::caloCluster(), SeedWithInfo::dPhi1(), reco::ElectronSeed::dPhi2(), SeedWithInfo::dPhi2(), reco::ElectronSeed::dPhi2Pos(), SeedWithInfo::dRz1(), reco::ElectronSeed::dRz2(), SeedWithInfo::dRz2(), reco::ElectronSeed::dRz2Pos(), equivalent(), reco::ElectronSeed::hitsMask(), infinity, reco::return(), reco::ElectronSeed::setNegAttributes(), and reco::ElectronSeed::setPosAttributes().

 {
  if (!info)
   { out.push_back(seed) ; return ; }

  if (positron)
   { seed.setPosAttributes(info->dRz2(),info->dPhi2(),info->dRz1(),info->dPhi1()) ; }
  else
   { seed.setNegAttributes(info->dRz2(),info->dPhi2(),info->dRz1(),info->dPhi1()) ; }
  reco::ElectronSeedCollection::iterator resItr ;
  for ( resItr=out.begin() ; resItr!=out.end() ; ++resItr )
   {
    if ( (seed.caloCluster()==resItr->caloCluster()) &&
         (seed.hitsMask()==resItr->hitsMask()) &&
         equivalent(seed,*resItr) )
     {
      if (positron)
       {
        if ( resItr->dRz2Pos()==std::numeric_limits<float>::infinity() &&
             resItr->dRz2()!=std::numeric_limits<float>::infinity() )
         {
          resItr->setPosAttributes(info->dRz2(),info->dPhi2(),info->dRz1(),info->dPhi1()) ;
          seed.setNegAttributes(resItr->dRz2(),resItr->dPhi2(),resItr->dRz1(),resItr->dPhi1()) ;
          break ;
         }
        else
         {
          if ( resItr->dRz2Pos()!=std::numeric_limits<float>::infinity() )
           {
            if ( resItr->dRz2Pos()!=seed.dRz2Pos() )
             {
              edm::LogWarning("ElectronSeedGenerator|BadValue")
               <<"this similar old seed already has another dRz2Pos"
               <<"\nold seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)resItr->hitsMask()<<"/"<<resItr->dRz2()<<"/"<<resItr->dPhi2()<<"/"<<resItr->dRz2Pos()<<"/"<<resItr->dPhi2Pos()
               <<"\nnew seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)seed.hitsMask()<<"/"<<seed.dRz2()<<"/"<<seed.dPhi2()<<"/"<<seed.dRz2Pos()<<"/"<<seed.dPhi2Pos() ;
             }
//            else
//             {
//              edm::LogWarning("ElectronSeedGenerator|UnexpectedValue")
//               <<"this old seed already knows its dRz2Pos, we suspect duplicates in input trajectry seeds"
//               <<"\nold seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)resItr->hitsMask()<<"/"<<resItr->dRz2()<<"/"<<resItr->dPhi2()<<"/"<<resItr->dRz2Pos()<<"/"<<resItr->dPhi2Pos()
//               <<"\nnew seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)seed.hitsMask()<<"/"<<seed.dRz2()<<"/"<<seed.dPhi2()<<"/"<<seed.dRz2Pos()<<"/"<<seed.dPhi2Pos() ;
//             }
            }
//          if (resItr->dRz2()==std::numeric_limits<float>::infinity())
//           {
//            edm::LogWarning("ElectronSeedGenerator|BadValue")
//             <<"this old seed has no dRz2, we suspect duplicates in input trajectry seeds"
//             <<"\nold seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)resItr->hitsMask()<<"/"<<resItr->dRz2()<<"/"<<resItr->dPhi2()<<"/"<<resItr->dRz2Pos()<<"/"<<resItr->dPhi2Pos()
//             <<"\nnew seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)seed.hitsMask()<<"/"<<seed.dRz2()<<"/"<<seed.dPhi2()<<"/"<<seed.dRz2Pos()<<"/"<<seed.dPhi2Pos() ;
//           }
         }
       }
      else
       {
        if ( resItr->dRz2()==std::numeric_limits<float>::infinity()
          && resItr->dRz2Pos()!=std::numeric_limits<float>::infinity() )
         {
          resItr->setNegAttributes(info->dRz2(),info->dPhi2(),info->dRz1(),info->dPhi1()) ;
          seed.setPosAttributes(resItr->dRz2Pos(),resItr->dPhi2Pos(),resItr->dRz1Pos(),resItr->dPhi1Pos()) ;
          break ;
         }
        else
         {
          if ( resItr->dRz2()!=std::numeric_limits<float>::infinity() )
           {
            if (resItr->dRz2()!=seed.dRz2())
             {
              edm::LogWarning("ElectronSeedGenerator|BadValue")
               <<"this old seed already has another dRz2"
               <<"\nold seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)resItr->hitsMask()<<"/"<<resItr->dRz2()<<"/"<<resItr->dPhi2()<<"/"<<resItr->dRz2Pos()<<"/"<<resItr->dPhi2Pos()
               <<"\nnew seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)seed.hitsMask()<<"/"<<seed.dRz2()<<"/"<<seed.dPhi2()<<"/"<<seed.dRz2Pos()<<"/"<<seed.dPhi2Pos() ;
             }
    //        else
    //         {
    //          edm::LogWarning("ElectronSeedGenerator|UnexpectedValue")
    //           <<"this old seed already knows its dRz2, we suspect duplicates in input trajectry seeds"
    //           <<"\nold seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)resItr->hitsMask()<<"/"<<resItr->dRz2()<<"/"<<resItr->dPhi2()<<"/"<<resItr->dRz2Pos()<<"/"<<resItr->dPhi2Pos()
    //           <<"\nnew seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)seed.hitsMask()<<"/"<<seed.dRz2()<<"/"<<seed.dPhi2()<<"/"<<seed.dRz2Pos()<<"/"<<seed.dPhi2Pos() ;
    //          seed.setPosAttributes(resItr->dRz2Pos(),resItr->dPhi2Pos(),resItr->dRz1Pos(),resItr->dPhi1Pos()) ;
    //         }
           }
//          if (resItr->dRz2Pos()==std::numeric_limits<float>::infinity())
//           {
//            edm::LogWarning("ElectronSeedGenerator|BadValue")
//             <<"this old seed has no dRz2Pos"
//             <<"\nold seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)resItr->hitsMask()<<"/"<<resItr->dRz2()<<"/"<<resItr->dPhi2()<<"/"<<resItr->dRz2Pos()<<"/"<<resItr->dPhi2Pos()
//             <<"\nnew seed mask/dRz2/dPhi2/dRz2Pos/dPhi2Pos: "<<(unsigned int)seed.hitsMask()<<"/"<<seed.dRz2()<<"/"<<seed.dPhi2()<<"/"<<seed.dRz2Pos()<<"/"<<seed.dPhi2Pos() ;
//           }
         }
       }
     }
   }

  out.push_back(seed) ;
 }

bool ElectronSeedGenerator::prepareElTrackSeed ( ConstRecHitPointer  outerhit, ConstRecHitPointer  innerhit, const GlobalPoint &  vertexPos  )

private

Definition at line 592 of file ElectronSeedGenerator.cc.

References TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), LogDebug, PV3DBase< T, PVType, FrameType >::perp(), and trajectoryStateTransform::persistentState().

 {

  // debug prints
  LogDebug("") <<"[ElectronSeedGenerator::prepareElTrackSeed] inner PixelHit   x,y,z "<<innerhit->globalPosition();
  LogDebug("") <<"[ElectronSeedGenerator::prepareElTrackSeed] outer PixelHit   x,y,z "<<outerhit->globalPosition();

  recHits_.clear();

  SiPixelRecHit *pixhit=0;
  SiStripMatchedRecHit2D *striphit=0;
  const SiPixelRecHit* constpixhit = dynamic_cast <const SiPixelRecHit*> (innerhit->hit());
  if (constpixhit) {
    pixhit=new SiPixelRecHit(*constpixhit);
    recHits_.push_back(pixhit);
  } else  return false;
  constpixhit =  dynamic_cast <const SiPixelRecHit *> (outerhit->hit());
  if (constpixhit) {
    pixhit=new SiPixelRecHit(*constpixhit);
    recHits_.push_back(pixhit);
  } else {
    const SiStripMatchedRecHit2D * conststriphit=dynamic_cast <const SiStripMatchedRecHit2D *> (outerhit->hit());
    if (conststriphit) {
      striphit = new SiStripMatchedRecHit2D(*conststriphit);
      recHits_.push_back(striphit);
    } else return false;
  }

  typedef TrajectoryStateOnSurface     TSOS;

  // FIXME to be optimized outside the loop
  edm::ESHandle<MagneticField> bfield;
  theSetup->get<IdealMagneticFieldRecord>().get(bfield);
  float nomField = bfield->nominalValue();

  // make a spiral
  FastHelix helix(outerhit->globalPosition(),innerhit->globalPosition(),vertexPos,nomField,&*bfield);
  if ( !helix.isValid()) {
    return false;
  }
  FreeTrajectoryState fts(helix.stateAtVertex());
  TSOS propagatedState = thePropagator->propagate(fts,innerhit->det()->surface()) ;
  if (!propagatedState.isValid())
    return false;
  TSOS updatedState = theUpdator->update(propagatedState, *innerhit);

  TSOS propagatedState_out = thePropagator->propagate(updatedState,outerhit->det()->surface()) ;
  if (!propagatedState_out.isValid())
    return false;
  TSOS updatedState_out = theUpdator->update(propagatedState_out, *outerhit);
  // debug prints
  LogDebug("") <<"[ElectronSeedGenerator::prepareElTrackSeed] final TSOS, position: "<<updatedState_out.globalPosition()<<" momentum: "<<updatedState_out.globalMomentum();
  LogDebug("") <<"[ElectronSeedGenerator::prepareElTrackSeed] final TSOS Pt: "<<updatedState_out.globalMomentum().perp();
  pts_ =  trajectoryStateTransform::persistentState(updatedState_out, outerhit->geographicalId().rawId());

  return true;
 }

void ElectronSeedGenerator::run	(	edm::Event &	e,
		const edm::EventSetup &	setup,
		const reco::SuperClusterRefVector &	sclRefs,
		const std::vector< float > &	hoe1s,
		const std::vector< float > &	hoe2s,
		TrajectorySeedCollection *	seeds,
		reco::ElectronSeedCollection &	out
	)

Definition at line 233 of file ElectronSeedGenerator.cc.

References data, edm::hlt::Exception, edm::EventSetup::get(), edm::Event::getByLabel(), edm::Event::getByToken(), i, edm::EventBase::id(), LogDebug, edm::ESHandle< class >::product(), HcalObjRepresent::setup(), and edm::RefVector< C, T, F >::size().

Referenced by ElectronSeedProducer::produce().

 {
  theInitialSeedColl = seeds ;
//  bool duplicateTrajectorySeeds =false ;
//  unsigned int i,j ;
//  for (i=0;i<seeds->size();++i)
//    for (j=i+1;j<seeds->size();++j)
//     {
//      const TrajectorySeed & s1 =(*seeds)[i] ;
//      const TrajectorySeed & s2 =(*seeds)[j] ;
//      if ( equivalent(s1,s2) )
//       {
//        const PTrajectoryStateOnDet & ss1 = s1.startingState() ;
//        const LocalTrajectoryParameters & p1 = ss1.parameters() ;
//        const PTrajectoryStateOnDet & ss2 = s2.startingState() ;
//        const LocalTrajectoryParameters & p2 = ss2.parameters() ;
//        duplicateTrajectorySeeds = true ;
//        std::cout<<"Same hits for "
//          <<"\n  s["<<i<<"] ("<<s1.direction()<<"/"<<ss1.detId()<<"/"<<ss1.surfaceSide()<<"/"<<p1.charge()<<"/"<<p1.position()<<"/"<<p1.momentum()<<")"
//          <<"\n  s["<<j<<"] ("<<s2.direction()<<"/"<<ss2.detId()<<"/"<<ss2.surfaceSide()<<"/"<<p2.charge()<<"/"<<p2.position()<<"/"<<p2.momentum()<<")"
//          <<std::endl ;
//       }
//     }
//  if (duplicateTrajectorySeeds)
//   { edm::LogWarning("ElectronSeedGenerator|DuplicateTrajectorySeeds")<<"We see several identical trajectory seeds." ; }

  //Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHand;
  setup.get<IdealGeometryRecord>().get(tTopoHand);
  const TrackerTopology *tTopo=tTopoHand.product();

  theSetup= &setup;
  NavigationSetter theSetter(*theNavigationSchool);


  // Step A: set Event for the TrajectoryBuilder
  edm::Handle<MeasurementTrackerEvent> data;
  e.getByLabel(theMeasurementTrackerEventTag, data);
  myMatchEle->setEvent(*data);
  myMatchPos->setEvent(*data);

  // get initial TrajectorySeeds if necessary
  //  if (fromTrackerSeeds_) e.getByToken(initialSeeds_, theInitialSeedColl);

  // get the beamspot from the Event:
  //e.getByType(theBeamSpot);
  e.getByToken(beamSpotTag_,theBeamSpot);

  // if required get the vertices
  if (useRecoVertex_) e.getByToken(verticesTag_,theVertices);

  if (!fromTrackerSeeds_)
   { throw cms::Exception("NotSupported") << "Here in ElectronSeedGenerator " << __FILE__ << ":" << __LINE__ << " I would like to do theMeasurementTracker->update(e); but that no longer makes sense.\n"; 
   }

  for  (unsigned int i=0;i<sclRefs.size();++i) {
    // Find the seeds
    recHits_.clear();

    LogDebug ("run") << "new cluster, calling seedsFromThisCluster";
    seedsFromThisCluster(sclRefs[i],hoe1s[i],hoe2s[i],out,tTopo);
  }

  LogDebug ("run") << ": For event "<<e.id();
  LogDebug ("run") <<"Nr of superclusters after filter: "<<sclRefs.size()
   <<", no. of ElectronSeeds found  = " << out.size();
}

void ElectronSeedGenerator::seedsFromRecHits ( std::vector< std::pair< RecHitWithDist, ConstRecHitPointer > > &  elePixelHits, PropagationDirection &  dir, const GlobalPoint &  vertexPos, const reco::ElectronSeed::CaloClusterRef &  cluster, reco::ElectronSeedCollection &  out, bool  positron  )

private

Definition at line 449 of file ElectronSeedGenerator.cc.

References LogDebug, reco::ElectronSeed::setCaloCluster(), and findQualityFiles::v.

 {
  if (!pixelHits.empty())
   { LogDebug("ElectronSeedGenerator") << "Compatible "<<(positron?"positron":"electron")<<" hits found." ; }

  std::vector<std::pair<RecHitWithDist,ConstRecHitPointer> >::iterator v ;
  for ( v = pixelHits.begin() ; v != pixelHits.end() ; v++ )
   {
    if (!positron)
     { (*v).first.invert() ; }
    if (!prepareElTrackSeed((*v).first.recHit(),(*v).second,vertexPos))
     { continue ; }
    reco::ElectronSeed seed(pts_,recHits_,dir) ;
    seed.setCaloCluster(cluster) ;
    addSeed(seed,0,positron,out) ;
   }
 }

void ElectronSeedGenerator::seedsFromThisCluster ( edm::Ref< reco::SuperClusterCollection >  seedCluster, float  hoe1, float  hoe2, reco::ElectronSeedCollection &  out, const TrackerTopology *  tTopo  )

private

Definition at line 304 of file ElectronSeedGenerator.cc.

References alongMomentum, dir, ele_convert(), eta(), reco::return(), and mathSSE::sqrt().

{
  float clusterEnergy = seedCluster->energy() ;
  GlobalPoint clusterPos
    ( seedCluster->position().x(),
      seedCluster->position().y(),
      seedCluster->position().z() ) ;
  reco::ElectronSeed::CaloClusterRef caloCluster(seedCluster) ;

  //LogDebug("") << "[ElectronSeedGenerator::seedsFromThisCluster] new supercluster with energy: " << clusterEnergy ;
  //LogDebug("") << "[ElectronSeedGenerator::seedsFromThisCluster] and position: " << clusterPos ;

  if (dynamicphiroad_)
   {
    float clusterEnergyT = clusterEnergy / cosh( EleRelPoint(clusterPos,theBeamSpot->position()).eta() ) ;

    float deltaPhi1 ;
    if (clusterEnergyT < lowPtThreshold_)
     { deltaPhi1= deltaPhi1Low_ ; }
    else if (clusterEnergyT > highPtThreshold_)
     { deltaPhi1= deltaPhi1High_ ; }
    else
     { deltaPhi1 = deltaPhi1Coef1_ + deltaPhi1Coef2_/clusterEnergyT ; }

    float ephimin1 = -deltaPhi1*sizeWindowENeg_ ;
    float ephimax1 =  deltaPhi1*(1.-sizeWindowENeg_);
    float pphimin1 = -deltaPhi1*(1.-sizeWindowENeg_);
    float pphimax1 =  deltaPhi1*sizeWindowENeg_;

    float phimin2B  = -deltaPhi2B_/2. ;
    float phimax2B  =  deltaPhi2B_/2. ;
    float phimin2F  = -deltaPhi2F_/2. ;
    float phimax2F  =  deltaPhi2F_/2. ;


    myMatchEle->set1stLayer(ephimin1,ephimax1);
    myMatchPos->set1stLayer(pphimin1,pphimax1);
    myMatchEle->set2ndLayer(phimin2B,phimax2B, phimin2F,phimax2F);
    myMatchPos->set2ndLayer(phimin2B,phimax2B, phimin2F,phimax2F);
   }

  PropagationDirection dir = alongMomentum ;

  if (!useRecoVertex_) // here use the beam spot position
   {
    double sigmaZ=theBeamSpot->sigmaZ();
    double sigmaZ0Error=theBeamSpot->sigmaZ0Error();
    double sq=sqrt(sigmaZ*sigmaZ+sigmaZ0Error*sigmaZ0Error);
    double myZmin1=theBeamSpot->position().z()-nSigmasDeltaZ1_*sq;
    double myZmax1=theBeamSpot->position().z()+nSigmasDeltaZ1_*sq;

    GlobalPoint vertexPos ;
    ele_convert(theBeamSpot->position(),vertexPos) ;

    myMatchEle->set1stLayerZRange(myZmin1,myZmax1);
    myMatchPos->set1stLayerZRange(myZmin1,myZmax1);

    if (!fromTrackerSeeds_)
     {
      // try electron
      std::vector<std::pair<RecHitWithDist,ConstRecHitPointer> > elePixelHits
       = myMatchEle->compatibleHits(clusterPos,vertexPos,
                    clusterEnergy,-1., tTopo) ;
      GlobalPoint eleVertex(theBeamSpot->position().x(),theBeamSpot->position().y(),myMatchEle->getVertex()) ;
      seedsFromRecHits(elePixelHits,dir,eleVertex,caloCluster,out,false) ;
      // try positron
      std::vector<std::pair<RecHitWithDist,ConstRecHitPointer> > posPixelHits
    = myMatchPos->compatibleHits(clusterPos,vertexPos,clusterEnergy,1.,tTopo) ;
      GlobalPoint posVertex(theBeamSpot->position().x(),theBeamSpot->position().y(),myMatchPos->getVertex()) ;
      seedsFromRecHits(posPixelHits,dir,posVertex,caloCluster,out,true) ;
     }
    else
     {
      // try electron
      std::vector<SeedWithInfo> elePixelSeeds
       = myMatchEle->compatibleSeeds(theInitialSeedColl,clusterPos,vertexPos,clusterEnergy,-1.) ;
      seedsFromTrajectorySeeds(elePixelSeeds,caloCluster,hoe1,hoe2,out,false) ;
      // try positron
      std::vector<SeedWithInfo> posPixelSeeds
       = myMatchPos->compatibleSeeds(theInitialSeedColl,clusterPos,vertexPos,clusterEnergy,1.) ;
      seedsFromTrajectorySeeds(posPixelSeeds,caloCluster,hoe1,hoe2,out,true) ;
     }

   }
  else // here we use the reco vertices
   {

    myMatchEle->setUseRecoVertex(true) ; //Hit matchers need to know that the vertex is known
    myMatchPos->setUseRecoVertex(true) ;

    const  std::vector<reco::Vertex> * vtxCollection = theVertices.product() ;
    std::vector<reco::Vertex>::const_iterator vtxIter ;
    for (vtxIter = vtxCollection->begin(); vtxIter != vtxCollection->end() ; vtxIter++)
     {

      GlobalPoint vertexPos(vtxIter->position().x(),vtxIter->position().y(),vtxIter->position().z());
      double myZmin1, myZmax1 ;
      if (vertexPos.z()==theBeamSpot->position().z())
       { // in case vetex not found
        double sigmaZ=theBeamSpot->sigmaZ();
        double sigmaZ0Error=theBeamSpot->sigmaZ0Error();
        double sq=sqrt(sigmaZ*sigmaZ+sigmaZ0Error*sigmaZ0Error);
        myZmin1=theBeamSpot->position().z()-nSigmasDeltaZ1_*sq;
        myZmax1=theBeamSpot->position().z()+nSigmasDeltaZ1_*sq;
       }
      else
       { // a vertex has been recoed
        myZmin1=vtxIter->position().z()-deltaZ1WithVertex_;
        myZmax1=vtxIter->position().z()+deltaZ1WithVertex_;
       }

      myMatchEle->set1stLayerZRange(myZmin1,myZmax1);
      myMatchPos->set1stLayerZRange(myZmin1,myZmax1);

      if (!fromTrackerSeeds_)
       {
        // try electron
        std::vector<std::pair<RecHitWithDist,ConstRecHitPointer> > elePixelHits
      = myMatchEle->compatibleHits(clusterPos,vertexPos,clusterEnergy,-1.,tTopo) ;
        seedsFromRecHits(elePixelHits,dir,vertexPos,caloCluster,out,false) ;
        // try positron
          std::vector<std::pair<RecHitWithDist,ConstRecHitPointer> > posPixelHits
        = myMatchPos->compatibleHits(clusterPos,vertexPos,clusterEnergy,1.,tTopo) ;
        seedsFromRecHits(posPixelHits,dir,vertexPos,caloCluster,out,true) ;
       }
      else
       {
        // try electron
        std::vector<SeedWithInfo> elePixelSeeds
         = myMatchEle->compatibleSeeds(theInitialSeedColl,clusterPos,vertexPos,clusterEnergy,-1.) ;
        seedsFromTrajectorySeeds(elePixelSeeds,caloCluster,hoe1,hoe2,out,false) ;
        // try positron
        std::vector<SeedWithInfo> posPixelSeeds
         = myMatchPos->compatibleSeeds(theInitialSeedColl,clusterPos,vertexPos,clusterEnergy,1.) ;
        seedsFromTrajectorySeeds(posPixelSeeds,caloCluster,hoe1,hoe2,out,true) ;
       }
     }
   }

  return ;
 }

void ElectronSeedGenerator::seedsFromTrajectorySeeds ( const std::vector< SeedWithInfo > &  elePixelSeeds, const reco::ElectronSeed::CaloClusterRef &  cluster, float  hoe1, float  hoe2, reco::ElectronSeedCollection &  out, bool  positron  )

private

Definition at line 472 of file ElectronSeedGenerator.cc.

References LogDebug, alignCSCRings::s, and reco::ElectronSeed::setCaloCluster().

 {
  if (!pixelSeeds.empty())
   { LogDebug("ElectronSeedGenerator") << "Compatible "<<(positron?"positron":"electron")<<" seeds found." ; }

  std::vector<SeedWithInfo>::const_iterator s;
  for ( s = pixelSeeds.begin() ; s != pixelSeeds.end() ; s++ )
   {
    reco::ElectronSeed seed(s->seed()) ;
    seed.setCaloCluster(cluster,s->hitsMask(),s->subDet2(),s->subDet1(),hoe1,hoe2) ;
    addSeed(seed,&*s,positron,out) ;
   }
 }

void ElectronSeedGenerator::setupES

(

const edm::EventSetup &

setup

)

Definition at line 158 of file ElectronSeedGenerator.cc.

References alongMomentum, cacheIDCkfComp_, edm::eventsetup::EventSetupRecord::cacheIdentifier(), cacheIDMagField_, cacheIDNavSchool_, cacheIDTrkGeom_, fromTrackerSeeds_, edm::EventSetup::get(), myMatchEle, myMatchPos, edm::ESHandle< class >::product(), PixelHitMatcher::setES(), theMagField, theMeasurementTracker, theMeasurementTrackerName, theNavigationSchool, thePropagator, and theTrackerGeometry.

Referenced by ElectronSeedProducer::produce().

                                                              {

  // get records if necessary (called once per event)
  bool tochange=false;

  if (cacheIDMagField_!=setup.get<IdealMagneticFieldRecord>().cacheIdentifier()) {
    setup.get<IdealMagneticFieldRecord>().get(theMagField);
    cacheIDMagField_=setup.get<IdealMagneticFieldRecord>().cacheIdentifier();
    if (thePropagator) delete thePropagator;
    thePropagator = new PropagatorWithMaterial(alongMomentum,.000511,&(*theMagField));
    tochange=true;
  }

  if (!fromTrackerSeeds_ && cacheIDCkfComp_!=setup.get<CkfComponentsRecord>().cacheIdentifier()) {
    edm::ESHandle<MeasurementTracker> measurementTrackerHandle;
    setup.get<CkfComponentsRecord>().get(theMeasurementTrackerName,measurementTrackerHandle);
    cacheIDCkfComp_=setup.get<CkfComponentsRecord>().cacheIdentifier();
    theMeasurementTracker = measurementTrackerHandle.product();
    tochange=true;
  }

  //edm::ESHandle<TrackerGeometry> trackerGeometryHandle;
  if (cacheIDTrkGeom_!=setup.get<TrackerDigiGeometryRecord>().cacheIdentifier()) {
    cacheIDTrkGeom_=setup.get<TrackerDigiGeometryRecord>().cacheIdentifier();
    setup.get<TrackerDigiGeometryRecord>().get(theTrackerGeometry);
    tochange=true; //FIXME
  }

  if (tochange) {
    myMatchEle->setES(&(*theMagField),theMeasurementTracker,theTrackerGeometry.product());
    myMatchPos->setES(&(*theMagField),theMeasurementTracker,theTrackerGeometry.product());
  }

  if (cacheIDNavSchool_!=setup.get<NavigationSchoolRecord>().cacheIdentifier()) {
    edm::ESHandle<NavigationSchool> nav;
    setup.get<NavigationSchoolRecord>().get("SimpleNavigationSchool", nav);
    cacheIDNavSchool_=setup.get<NavigationSchoolRecord>().cacheIdentifier();
    theNavigationSchool = nav.product();
  }

//  if (cacheIDGeom_!=setup.get<TrackerRecoGeometryRecord>().cacheIdentifier()) {
//    setup.get<TrackerRecoGeometryRecord>().get( theGeomSearchTracker );
//    cacheIDGeom_=setup.get<TrackerRecoGeometryRecord>().cacheIdentifier();
//  }

}

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> ElectronSeedGenerator::beamSpotTag_

private

Definition at line 90 of file ElectronSeedGenerator.h.

unsigned long long ElectronSeedGenerator::cacheIDCkfComp_

private

Definition at line 137 of file ElectronSeedGenerator.h.

Referenced by setupES().

unsigned long long ElectronSeedGenerator::cacheIDMagField_

private

Definition at line 134 of file ElectronSeedGenerator.h.

Referenced by setupES().

unsigned long long ElectronSeedGenerator::cacheIDNavSchool_

private

Definition at line 136 of file ElectronSeedGenerator.h.

Referenced by setupES().

unsigned long long ElectronSeedGenerator::cacheIDTrkGeom_

private

Definition at line 138 of file ElectronSeedGenerator.h.

Referenced by setupES().

double ElectronSeedGenerator::deltaPhi1Coef1_

private

Definition at line 106 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

double ElectronSeedGenerator::deltaPhi1Coef2_

private

Definition at line 107 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::deltaPhi1High_

private

Definition at line 101 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::deltaPhi1Low_

private

Definition at line 101 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::deltaPhi2B_

private

Definition at line 102 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::deltaPhi2F_

private

Definition at line 103 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::deltaZ1WithVertex_

private

Definition at line 95 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

bool ElectronSeedGenerator::dynamicphiroad_

private

Definition at line 82 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

bool ElectronSeedGenerator::fromTrackerSeeds_

private

Definition at line 83 of file ElectronSeedGenerator.h.

Referenced by setupES().

float ElectronSeedGenerator::highPtThreshold_

private

Definition at line 93 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::lowPtThreshold_

private

Definition at line 92 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

PixelHitMatcher* ElectronSeedGenerator::myMatchEle

private

Definition at line 109 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator(), setupES(), and ~ElectronSeedGenerator().

PixelHitMatcher* ElectronSeedGenerator::myMatchPos

private

Definition at line 110 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator(), setupES(), and ~ElectronSeedGenerator().

float ElectronSeedGenerator::nSigmasDeltaZ1_

private

Definition at line 94 of file ElectronSeedGenerator.h.

float ElectronSeedGenerator::phiMax2B_

private

Definition at line 98 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::phiMax2F_

private

Definition at line 100 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::phiMin2B_

private

Definition at line 97 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

float ElectronSeedGenerator::phiMin2F_

private

Definition at line 99 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

PTrajectoryStateOnDet ElectronSeedGenerator::pts_

private

Definition at line 131 of file ElectronSeedGenerator.h.

PRecHitContainer ElectronSeedGenerator::recHits_

private

Definition at line 130 of file ElectronSeedGenerator.h.

float ElectronSeedGenerator::sizeWindowENeg_

private

Definition at line 96 of file ElectronSeedGenerator.h.

edm::Handle<reco::BeamSpot> ElectronSeedGenerator::theBeamSpot

private

Definition at line 89 of file ElectronSeedGenerator.h.

TrajectorySeedCollection* ElectronSeedGenerator::theInitialSeedColl

private

Definition at line 113 of file ElectronSeedGenerator.h.

edm::ESHandle<MagneticField> ElectronSeedGenerator::theMagField

private

Definition at line 115 of file ElectronSeedGenerator.h.

Referenced by setupES().

const MeasurementTracker* ElectronSeedGenerator::theMeasurementTracker

private

Definition at line 122 of file ElectronSeedGenerator.h.

Referenced by setupES().

edm::InputTag ElectronSeedGenerator::theMeasurementTrackerEventTag

private

Definition at line 123 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

std::string ElectronSeedGenerator::theMeasurementTrackerName

private

Definition at line 121 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator(), and setupES().

const NavigationSchool* ElectronSeedGenerator::theNavigationSchool

private

Definition at line 125 of file ElectronSeedGenerator.h.

Referenced by setupES().

PropagatorWithMaterial* ElectronSeedGenerator::thePropagator

private

Definition at line 119 of file ElectronSeedGenerator.h.

Referenced by setupES(), and ~ElectronSeedGenerator().

const edm::EventSetup* ElectronSeedGenerator::theSetup

private

Definition at line 127 of file ElectronSeedGenerator.h.

edm::ESHandle<TrackerGeometry> ElectronSeedGenerator::theTrackerGeometry

private

Definition at line 116 of file ElectronSeedGenerator.h.

Referenced by setupES().

KFUpdator* ElectronSeedGenerator::theUpdator

private

Definition at line 118 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator(), and ~ElectronSeedGenerator().

edm::Handle<std::vector<reco::Vertex> > ElectronSeedGenerator::theVertices

private

Definition at line 86 of file ElectronSeedGenerator.h.

bool ElectronSeedGenerator::useRecoVertex_

private

Definition at line 85 of file ElectronSeedGenerator.h.

Referenced by ElectronSeedGenerator().

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

private

Definition at line 87 of file ElectronSeedGenerator.h.