LowPtGsfElectronSeedProducer Class Reference

#include <LowPtGsfElectronSeedProducer.h>

Inheritance diagram for LowPtGsfElectronSeedProducer:

Public Types
using	TrackIndxMap = std::unordered_map< reco::TrackRef::key_type, size_t >
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Member Functions
void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
	LowPtGsfElectronSeedProducer (const edm::ParameterSet &, const lowptgsfeleseed::HeavyObjectCache *)
void	produce (edm::Event &, const edm::EventSetup &) override
	~LowPtGsfElectronSeedProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)
static void	globalEndJob (lowptgsfeleseed::HeavyObjectCache const *)
static std::unique_ptr< lowptgsfeleseed::HeavyObjectCache >	initializeGlobalCache (const edm::ParameterSet &conf)

Private Member Functions
bool	decision (const reco::PFRecTrackRef &pfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
bool	decision (const reco::TrackRef &kfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
template<typename CollType >
void	fillPreIdRefValueMap (edm::Handle< CollType > tracksHandle, const TrackIndxMap &trksToPreIdIndx, const edm::OrphanHandle< reco::PreIdCollection > &preIdHandle, edm::ValueMap< reco::PreIdRef >::Filler &filler)
reco::TrackRef	getBaseRef (edm::Handle< std::vector< reco::Track > > handle, int idx) const
reco::TrackRef	getBaseRef (edm::Handle< std::vector< reco::PFRecTrack > > handle, int idx) const
bool	lightGsfTracking (reco::PreId &, const reco::TrackRef &, const reco::ElectronSeed &, const edm::EventSetup &)
template<typename T >
void	loop (const edm::Handle< std::vector< T > > &handle, edm::Handle< reco::PFClusterCollection > &hcalClusters, reco::ElectronSeedCollection &seeds, reco::PreIdCollection &ecalPreIds, reco::PreIdCollection &hcalPreIds, TrackIndxMap &trksToPreIdIndx, edm::Event &, const edm::EventSetup &)
void	propagateTrackToCalo (const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)
void	propagateTrackToCalo (const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &clusters, std::vector< int > &matchedClusters, reco::PreId &preId, bool ecal)
void	propagateTrackToCalo (const reco::TrackRef &pfTrack, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)

Private Attributes
const edm::EDGetTokenT< reco::BeamSpot >	beamSpot_
const std::string	builder_
const edm::EDGetTokenT< EcalRecHitCollection >	ebRecHits_
const edm::EDGetTokenT< reco::PFClusterCollection >	ecalClusters_
const edm::EDGetTokenT< EcalRecHitCollection >	eeRecHits_
edm::ESHandle< MagneticField >	field_
const std::string	fitter_
std::unique_ptr< TrajectoryFitter >	fitterPtr_
edm::EDGetTokenT< reco::PFClusterCollection >	hcalClusters_
edm::EDGetTokenT< reco::TrackCollection >	kfTracks_
const double	maxPtThreshold_
const double	minPtThreshold_
const bool	passThrough_
edm::EDGetTokenT< reco::PFRecTrackCollection >	pfTracks_
const edm::EDGetTokenT< double >	rho_
const std::string	smoother_
std::unique_ptr< TrajectorySmoother >	smootherPtr_
const bool	usePfTracks_

Static Private Attributes
static double	boundary_ = 2.50746495928*2.50746495928
static double	mass_ = 0.000511*0.000511

Detailed Description

Description: EDProducer of ElectronSeed objects Implementation: <Notes on="" implementation>="">

Definition at line 27 of file LowPtGsfElectronSeedProducer.h.

Member Typedef Documentation

using LowPtGsfElectronSeedProducer::TrackIndxMap = std::unordered_map<reco::TrackRef::key_type,size_t>

Definition at line 31 of file LowPtGsfElectronSeedProducer.h.

Constructor & Destructor Documentation

LowPtGsfElectronSeedProducer::LowPtGsfElectronSeedProducer ( const edm::ParameterSet &  conf, const lowptgsfeleseed::HeavyObjectCache *    )

explicit

Definition at line 38 of file LowPtGsfElectronSeedProducer.cc.

References beamSpot_, builder_, ebRecHits_, eeRecHits_, fitter_, edm::ParameterSet::getParameter(), hcalClusters_, kfTracks_, maxPtThreshold_, minPtThreshold_, passThrough_, pfTracks_, rho_, smoother_, AlCaHLTBitMon_QueryRunRegistry::string, and usePfTracks_.

                                                                         :
  field_(),
  fitterPtr_(),
  smootherPtr_(),
  kfTracks_(),
  pfTracks_(),
  ecalClusters_{consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("ecalClusters"))},
  hcalClusters_(),
  ebRecHits_{consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("EBRecHits"))},
  eeRecHits_{consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("EERecHits"))},
  rho_(consumes<double>(conf.getParameter<edm::InputTag>("rho"))),
  beamSpot_(consumes<reco::BeamSpot>(conf.getParameter<edm::InputTag>("BeamSpot"))),
  fitter_(conf.getParameter<std::string>("Fitter")),
  smoother_(conf.getParameter<std::string>("Smoother")),
  builder_(conf.getParameter<std::string>("TTRHBuilder")),
  passThrough_(conf.getParameter<bool>("PassThrough")),
  usePfTracks_(conf.getParameter<bool>("UsePfTracks")),
  minPtThreshold_(conf.getParameter<double>("MinPtThreshold")),
  maxPtThreshold_(conf.getParameter<double>("MaxPtThreshold"))
{
  if ( usePfTracks_ ) {
    pfTracks_ = consumes<reco::PFRecTrackCollection>(conf.getParameter<edm::InputTag>("pfTracks")); 
    hcalClusters_ = consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("hcalClusters"));
  }
  kfTracks_ = consumes<reco::TrackCollection>(conf.getParameter<edm::InputTag>("tracks"));

  produces<reco::ElectronSeedCollection>();
  produces<reco::PreIdCollection>();
  produces<reco::PreIdCollection>("HCAL");
  produces< edm::ValueMap<reco::PreIdRef> >(); // indexed by edm::Ref<ElectronSeed>.index()
}

LowPtGsfElectronSeedProducer::~LowPtGsfElectronSeedProducer ( )

override

Definition at line 73 of file LowPtGsfElectronSeedProducer.cc.

{}

Member Function Documentation

void LowPtGsfElectronSeedProducer::beginLuminosityBlock ( edm::LuminosityBlock const &  , edm::EventSetup const &  setup  )

override

Definition at line 77 of file LowPtGsfElectronSeedProducer.cc.

References field_, and edm::EventSetup::get().

Referenced by globalEndJob().

{
  setup.get<IdealMagneticFieldRecord>().get(field_);
}

bool LowPtGsfElectronSeedProducer::decision ( const reco::PFRecTrackRef &  pfTrackRef, reco::PreId &  ecal, reco::PreId &  hcal, double  rho, const reco::BeamSpot &  spot, noZS::EcalClusterLazyTools &  ecalTools  )

private

Definition at line 517 of file LowPtGsfElectronSeedProducer.cc.

References maxPtThreshold_, dataset::name, passThrough_, and mps_fire::result.

Referenced by globalEndJob(), and loop().

{
  bool result = false;
  for ( auto& name: globalCache()->modelNames() ) {
    result |= globalCache()->eval(name,
                  ecalPreId,
                  hcalPreId,
                  rho,
                  spot,
                  ecalTools);
  }
  return passThrough_ || ( pfTrackRef->trackRef()->pt() > maxPtThreshold_ ) || result;
}

bool LowPtGsfElectronSeedProducer::decision ( const reco::TrackRef &  kfTrackRef, reco::PreId &  ecal, reco::PreId &  hcal, double  rho, const reco::BeamSpot &  spot, noZS::EcalClusterLazyTools &  ecalTools  )

private

Definition at line 538 of file LowPtGsfElectronSeedProducer.cc.

References passThrough_.

{
  // No implementation currently
  return passThrough_;
}

void LowPtGsfElectronSeedProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 573 of file LowPtGsfElectronSeedProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by globalEndJob().

{
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("tracks",edm::InputTag("generalTracks"));
  desc.add<edm::InputTag>("pfTracks",edm::InputTag("lowPtGsfElePfTracks"));
  desc.add<edm::InputTag>("ecalClusters",edm::InputTag("particleFlowClusterECAL"));
  desc.add<edm::InputTag>("hcalClusters",edm::InputTag("particleFlowClusterHCAL"));
  desc.add<edm::InputTag>("EBRecHits",edm::InputTag("ecalRecHit","EcalRecHitsEB"));
  desc.add<edm::InputTag>("EERecHits",edm::InputTag("ecalRecHit","EcalRecHitsEE"));
  desc.add<edm::InputTag>("rho",edm::InputTag("fixedGridRhoFastjetAllTmp"));
  desc.add<edm::InputTag>("BeamSpot",edm::InputTag("offlineBeamSpot"));
  desc.add<std::string>("Fitter","GsfTrajectoryFitter_forPreId");
  desc.add<std::string>("Smoother","GsfTrajectorySmoother_forPreId");
  desc.add<std::string>("TTRHBuilder","WithAngleAndTemplate");
  desc.add< std::vector<std::string> >("ModelNames",std::vector<std::string>());
  desc.add< std::vector<std::string> >("ModelWeights",std::vector<std::string>());
  desc.add< std::vector<double> >("ModelThresholds",std::vector<double>());
  desc.add<bool>("PassThrough",false);
  desc.add<bool>("UsePfTracks",true);
  desc.add<double>("MinPtThreshold",1.0);
  desc.add<double>("MaxPtThreshold",15.);
  descriptions.add("lowPtGsfElectronSeeds",desc);
}

template<typename CollType >

void LowPtGsfElectronSeedProducer::fillPreIdRefValueMap ( edm::Handle< CollType >  tracksHandle, const TrackIndxMap &  trksToPreIdIndx, const edm::OrphanHandle< reco::PreIdCollection > &  preIdHandle, edm::ValueMap< reco::PreIdRef >::Filler &  filler  )

private

Definition at line 550 of file LowPtGsfElectronSeedProducer.cc.

References edm::Ref< C, T, F >::index(), edm::helper::Filler< Map >::insert(), vertices_cff::ntracks, and MuonErrorMatrixValues_cff::values.

Referenced by globalEndJob(), and produce().

{
  std::vector<reco::PreIdRef> values;

  unsigned ntracks=tracksHandle->size();
  for(unsigned itrack=0;itrack<ntracks;++itrack){
    edm::Ref<CollType> trackRef(tracksHandle,itrack);
    auto preIdRefIt = trksToPreIdIndx.find(trackRef.index());
    if(preIdRefIt==trksToPreIdIndx.end()){
      values.push_back(reco::PreIdRef());
    }else{
      edm::Ref<reco::PreIdCollection> preIdRef(preIdHandle,preIdRefIt->second);
      values.push_back(preIdRef);
    }
  }
  filler.insert(tracksHandle,values.begin(),values.end());
}

reco::TrackRef LowPtGsfElectronSeedProducer::getBaseRef ( edm::Handle< std::vector< reco::Track > >  handle, int  idx  ) const

private

Definition at line 158 of file LowPtGsfElectronSeedProducer.cc.

References cmsBatch::handle.

Referenced by globalEndJob(), and loop().

{
  return reco::TrackRef(handle,idx);
}

reco::TrackRef LowPtGsfElectronSeedProducer::getBaseRef ( edm::Handle< std::vector< reco::PFRecTrack > >  handle, int  idx  ) const

private

Definition at line 163 of file LowPtGsfElectronSeedProducer.cc.

References cmsBatch::handle.

{
  return reco::PFRecTrackRef(handle,idx)->trackRef();
}

static void LowPtGsfElectronSeedProducer::globalEndJob ( lowptgsfeleseed::HeavyObjectCache const *  )

inlinestatic

Definition at line 42 of file LowPtGsfElectronSeedProducer.h.

References beginLuminosityBlock(), fastPrimaryVertexProducer_cfi::clusters, decision(), digitizers_cfi::ecal, RecoEcal_cff::ecalClusters, fillDescriptions(), objects.autophobj::filler, fillPreIdRefValueMap(), getBaseRef(), cmsBatch::handle, lowPtGsfElectronSeeds_cfi::hcalClusters, training_settings::idx, lightGsfTracking(), loop(), pfTrack_cfi::pfTrack, produce(), propagateTrackToCalo(), and rho.

{}

static std::unique_ptr<lowptgsfeleseed::HeavyObjectCache> LowPtGsfElectronSeedProducer::initializeGlobalCache ( const edm::ParameterSet &  conf )

inlinestatic

Definition at line 38 of file LowPtGsfElectronSeedProducer.h.

                                                         {
    return std::make_unique<lowptgsfeleseed::HeavyObjectCache>(lowptgsfeleseed::HeavyObjectCache(conf));
  }

bool LowPtGsfElectronSeedProducer::lightGsfTracking ( reco::PreId &  preId, const reco::TrackRef &  trackRef, const reco::ElectronSeed &  seed, const edm::EventSetup &  setup  )

private

Definition at line 470 of file LowPtGsfElectronSeedProducer.cc.

References Trajectory::chiSquared(), field_, Trajectory::firstMeasurement(), fitterPtr_, TrajectoryStateOnSurface::globalMomentum(), runTauDisplay::gp, hfClusterShapes_cfi::hits, Trajectory::isValid(), Trajectory::lastMeasurement(), PV3DBase< T, PVType, FrameType >::perp(), reco::PreId::setTrackProperties(), smootherPtr_, and TrajectoryMeasurement::updatedState().

Referenced by globalEndJob(), and loop().

{

  Trajectory::ConstRecHitContainer hits;
  for ( unsigned int ihit = 0; ihit < trackRef->recHitsSize(); ++ihit ) {
    hits.push_back( trackRef->recHit(ihit)->cloneSH() );
  }
  
  GlobalVector gv( trackRef->innerMomentum().x(),
           trackRef->innerMomentum().y(),
           trackRef->innerMomentum().z() );
  GlobalPoint gp( trackRef->innerPosition().x(),
          trackRef->innerPosition().y(),
          trackRef->innerPosition().z() );

  GlobalTrajectoryParameters gtps( gp,
                   gv,
                   trackRef->charge(),
                   &*field_ );

  TrajectoryStateOnSurface tsos( gtps,
                 trackRef->innerStateCovariance(),
                 *hits[0]->surface() );

  // Track fitted and smoothed under electron hypothesis
  Trajectory traj1 = fitterPtr_->fitOne( seed, hits, tsos );
  if ( !traj1.isValid() ) { return false; }
  Trajectory traj2 = smootherPtr_->trajectory(traj1);
  if ( !traj2.isValid() ) {  return false; }

  // Set PreId content
  float chi2Ratio = trackRef->chi2() > 0. ? traj2.chiSquared() / trackRef->chi2() : -1.;
  float gsfReducedChi2 = chi2Ratio > -1. ? chi2Ratio * trackRef->normalizedChi2() : -1.;
  float ptOut = traj2.firstMeasurement().updatedState().globalMomentum().perp();
  float ptIn = traj2.lastMeasurement().updatedState().globalMomentum().perp();
  float gsfDpt = ( ptIn > 0 ) ? fabs( ptOut - ptIn ) / ptIn : 0.;
  preId.setTrackProperties(gsfReducedChi2,chi2Ratio,gsfDpt);

  return true;

}

template<typename T >

void LowPtGsfElectronSeedProducer::loop ( const edm::Handle< std::vector< T > > &  handle, edm::Handle< reco::PFClusterCollection > &  hcalClusters, reco::ElectronSeedCollection &  seeds, reco::PreIdCollection &  ecalPreIds, reco::PreIdCollection &  hcalPreIds, TrackIndxMap &  trksToPreIdIndx, edm::Event &  event, const edm::EventSetup &  setup  )

private

Definition at line 171 of file LowPtGsfElectronSeedProducer.cc.

References beamSpot_, builder_, TrajectorySmoother::clone(), TrajectoryFitter::clone(), decision(), ebRecHits_, RecoEcal_cff::ecalClusters, ecalClusters_, eeRecHits_, fitter_, fitterPtr_, edm::EventSetup::get(), getBaseRef(), cmsBatch::handle, lowPtGsfElectronSeeds_cfi::hcalClusters, edm::Ref< C, T, F >::index(), lightGsfTracking(), minPtThreshold_, passThrough_, edm::ESHandle< T >::product(), propagateTrackToCalo(), reco::TrackBase::qualityByName(), mps_fire::result, rho, rho_, SurveyInfoScenario_cff::seed, reco::ElectronSeed::setCtfTrack(), reco::PreId::setTrack(), smoother_, and smootherPtr_.

Referenced by globalEndJob(), and produce().

{
  
  // Pileup
  edm::Handle<double> rho;
  event.getByToken(rho_,rho);
  
  // Beam spot
  edm::Handle<reco::BeamSpot> spot;
  event.getByToken(beamSpot_,spot);

  // Track fitter
  edm::ESHandle<TrajectoryFitter> fitter;
  setup.get<TrajectoryFitter::Record>().get(fitter_,fitter);
  fitterPtr_ = fitter->clone();

  // Track smoother
  edm::ESHandle<TrajectorySmoother> smoother;
  setup.get<TrajectoryFitter::Record>().get(smoother_,smoother);
  smootherPtr_.reset(smoother->clone());

  // RecHit cloner
  edm::ESHandle<TransientTrackingRecHitBuilder> builder;
  setup.get<TransientRecHitRecord>().get(builder_,builder);
  TkClonerImpl hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(builder.product())->cloner();
  fitterPtr_->setHitCloner(&hitCloner);
  smootherPtr_->setHitCloner(&hitCloner);

  // ECAL clusters
  edm::Handle<reco::PFClusterCollection> ecalClusters;
  event.getByToken(ecalClusters_,ecalClusters);

  // Utility to access to shower shape vars
  noZS::EcalClusterLazyTools ecalTools(event,setup,ebRecHits_,eeRecHits_);
  
  // Ensure each cluster is only matched once to a track
  std::vector<int> matchedEcalClusters;
  std::vector<int> matchedHcalClusters;

  // Reserve
  seeds.reserve(handle->size());
  ecalPreIds.reserve(handle->size());
  hcalPreIds.reserve(handle->size());
  
  // Iterate through (PF or KF) tracks
  for ( unsigned int itrk = 0; itrk < handle.product()->size(); itrk++ ) {

    edm::Ref< std::vector<T> > templatedRef(handle,itrk); // TrackRef or PFRecTrackRef
    reco::TrackRef trackRef = getBaseRef(handle,itrk);

    if ( !(trackRef->quality(reco::TrackBase::qualityByName("highPurity"))) ) { continue; }
    if ( !passThrough_ && ( trackRef->pt() < minPtThreshold_ ) ) { continue; }

    // Create ElectronSeed 
    reco::ElectronSeed seed( *(trackRef->seedRef()) );
    seed.setCtfTrack(trackRef);
    
    // Create PreIds
    unsigned int nModels = globalCache()->modelNames().size();
    reco::PreId ecalPreId(nModels);
    reco::PreId hcalPreId(nModels);

    // Add track ref to PreId
    ecalPreId.setTrack(trackRef);
    hcalPreId.setTrack(trackRef);

    // Add Track-Calo matching variables to PreIds
    propagateTrackToCalo(templatedRef,
             ecalClusters,
             hcalClusters,
             matchedEcalClusters,
             matchedHcalClusters,
             ecalPreId,
             hcalPreId );
    
    // Add variables related to GSF tracks to PreId
    lightGsfTracking(ecalPreId,trackRef,seed,setup); 

    // Decision based on BDT 
    bool result = decision(templatedRef,ecalPreId,hcalPreId,*rho,*spot,ecalTools);

    // If fails BDT, do not store seed
    if ( !result ) { continue; }
    
    // Store PreId
    ecalPreIds.push_back(ecalPreId);
    hcalPreIds.push_back(hcalPreId);
    trksToPreIdIndx[trackRef.index()] = ecalPreIds.size()-1;

    // Store ElectronSeed and corresponding edm::Ref<PreId>.index()
    seeds.push_back(seed);

  }

}

void LowPtGsfElectronSeedProducer::produce ( edm::Event &  event, const edm::EventSetup &  setup  )

override

Definition at line 85 of file LowPtGsfElectronSeedProducer.cc.

References Exception, fillPreIdRefValueMap(), lowPtGsfElectronSeeds_cfi::hcalClusters, hcalClusters_, edm::HandleBase::id(), kfTracks_, loop(), eostools::move(), lowPtGsfElectronSeeds_cfi::pfTracks, pfTracks_, and usePfTracks_.

Referenced by globalEndJob().

{
  
  // Products
  auto seeds = std::make_unique<reco::ElectronSeedCollection>();
  auto ecalPreIds = std::make_unique<reco::PreIdCollection>();
  auto hcalPreIds = std::make_unique<reco::PreIdCollection>();

  const edm::RefProd<reco::PreIdCollection> preIdsRefProd =
    event.getRefBeforePut<reco::PreIdCollection>();
  
  // HCAL clusters (only used with PF tracks)
  edm::Handle<reco::PFClusterCollection> hcalClusters;

  //we always need kftracks as we link the preids to them
  edm::Handle<reco::TrackCollection> kfTracks;
  event.getByToken(kfTracks_, kfTracks);

  TrackIndxMap trksToPreIdIndx;
  if ( usePfTracks_ ) { 

    edm::Handle<reco::PFRecTrackCollection> pfTracks;
    event.getByToken(pfTracks_, pfTracks);
    event.getByToken(hcalClusters_,hcalClusters);

    //check consistency between kfTracks and pfTracks collection
    for(auto& trk : *pfTracks){ 
      if(trk.trackRef().isNonnull()){
    if(trk.trackRef().id() != kfTracks.id()){
      throw cms::Exception("ConfigError") << "kfTracks is not the collection that pfTracks was built from, please fix this";
    }
    break; //we only need one valid track ref to check this so end the loop
      }
    }

    loop(pfTracks, // PF tracks
     hcalClusters,
     *seeds,
     *ecalPreIds,
     *hcalPreIds,
     trksToPreIdIndx,
     event,
     setup);

  } else { 

    loop(kfTracks, // KF tracks
     hcalClusters,
     *seeds,
     *ecalPreIds,
     *hcalPreIds,
     trksToPreIdIndx,
     event,
     setup);

  }

  auto ecalPreIdsHandle = event.put(std::move(ecalPreIds));
  event.put(std::move(hcalPreIds),"HCAL");
  event.put(std::move(seeds));

  auto preIdVMOut = std::make_unique< edm::ValueMap<reco::PreIdRef> >();
  edm::ValueMap<reco::PreIdRef>::Filler mapFiller(*preIdVMOut);
  fillPreIdRefValueMap(kfTracks,trksToPreIdIndx,ecalPreIdsHandle,mapFiller);
  mapFiller.fill();
  event.put(std::move(preIdVMOut));
  
}

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::PFRecTrackRef &  pfTrackRef, const edm::Handle< reco::PFClusterCollection > &  ecalClusters, const edm::Handle< reco::PFClusterCollection > &  hcalClusters, std::vector< int > &  matchedEcalClusters, std::vector< int > &  matchedHcalClusters, reco::PreId &  ecalPreId, reco::PreId &  hcalPreId  )

private

Definition at line 300 of file LowPtGsfElectronSeedProducer.cc.

Referenced by globalEndJob(), and loop().

{
  propagateTrackToCalo( pfTrackRef, ecalClusters, matchedEcalClusters, ecalPreId, true );
  propagateTrackToCalo( pfTrackRef, hcalClusters, matchedHcalClusters, hcalPreId, false );
}

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::PFRecTrackRef &  pfTrackRef, const edm::Handle< reco::PFClusterCollection > &  clusters, std::vector< int > &  matchedClusters, reco::PreId &  preId, bool  ecal  )

private

Definition at line 314 of file LowPtGsfElectronSeedProducer.cc.

References reco::deltaPhi(), reco::deltaR2(), spr::find(), info(), reco::PFTrajectoryPoint::isValid(), point, reco::PFTrajectoryPoint::position(), reco::PFTrajectoryPoint::positionREP(), edm::Handle< T >::product(), reco::PreId::setECALMatchingProperties(), and mathSSE::sqrt().

{

  // Store info for PreId
  struct Info {
    reco::PFClusterRef cluRef = reco::PFClusterRef();
    float dr2min = 1.e6;
    float deta = 1.e6;
    float dphi = 1.e6;
    math::XYZPoint showerPos = math::XYZPoint(0.,0.,0.);
  } info;
  
  // Find closest "seed cluster" to KF track extrapolated to ECAL (or HCAL)
  reco::PFTrajectoryPoint point;
  if ( ecal ) { point = pfTrackRef->extrapolatedPoint(reco::PFTrajectoryPoint::LayerType::ECALShowerMax); }
  else        { point = pfTrackRef->extrapolatedPoint(reco::PFTrajectoryPoint::LayerType::HCALEntrance); }

  if ( point.isValid() ) {

    Info info;
    for ( unsigned int iclu = 0; iclu < clusters.product()->size(); iclu++ ) {

      if ( std::find( matched.begin(), matched.end(), iclu ) == matched.end() ) {

    reco::PFClusterRef cluRef(clusters,iclu);

    // Determine dR squared
    float dr2 = reco::deltaR2( cluRef->positionREP(), point.positionREP() );

    if ( dr2 < info.dr2min ) {
      info.dr2min = dr2;
      info.cluRef = cluRef;
      info.deta = cluRef->positionREP().eta() - point.positionREP().eta();
      info.dphi = 
        reco::deltaPhi( cluRef->positionREP().phi(), point.positionREP().phi() ) *
        pfTrackRef->trackRef()->charge();
      info.showerPos = point.position();
    }

      }
    }

    // Set PreId content if match found
    if ( info.dr2min < 1.e5 ) { 
      float ep = info.cluRef->correctedEnergy() / std::sqrt( pfTrackRef->trackRef()->innerMomentum().mag2() );
      preId.setECALMatchingProperties( info.cluRef,
                       point.position(), // ECAL or HCAL surface
                       info.showerPos, // 
                       info.deta,
                       info.dphi,
                       0.f, // chieta
                       0.f, // chiphi
                       pfTrackRef->trackRef()->normalizedChi2(), // chi2
                       ep );
    }

  } // clusters

}

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::TrackRef &  pfTrack, const edm::Handle< reco::PFClusterCollection > &  ecalClusters, const edm::Handle< reco::PFClusterCollection > &  hcalClusters, std::vector< int > &  matchedEcalClusters, std::vector< int > &  matchedHcalClusters, reco::PreId &  ecalPreId, reco::PreId &  hcalPreId  )

private

Definition at line 380 of file LowPtGsfElectronSeedProducer.cc.

References funct::abs(), boundary_, reco::deltaPhi(), reco::deltaR2(), field_, reco::PFCluster::getDepthCorrection(), info(), MagneticField::inTesla(), mass_, point, funct::pow(), edm::Handle< T >::product(), BaseParticlePropagator::propagateToEcalEntrance(), reco::PreId::setECALMatchingProperties(), mathSSE::sqrt(), csvLumiCalc::unit, and RawParticle::z().

{

  // Store info for PreId
  struct Info {
    reco::PFClusterRef cluRef = reco::PFClusterRef();
    float dr2min = 1.e6;
    float deta = 1.e6;
    float dphi = 1.e6;
    math::XYZPoint showerPos = math::XYZPoint(0.,0.,0.);
  } info;

  // Propagate 'electron' to ECAL surface
  float energy = sqrt( mass_ + kfTrackRef->outerMomentum().Mag2() );
  XYZTLorentzVector mom = XYZTLorentzVector( kfTrackRef->outerMomentum().x(),
                         kfTrackRef->outerMomentum().y(),
                         kfTrackRef->outerMomentum().z(),
                         energy );
  XYZTLorentzVector pos = XYZTLorentzVector( kfTrackRef->outerPosition().x(),
                         kfTrackRef->outerPosition().y(),
                         kfTrackRef->outerPosition().z(),
                         0. );
  math::XYZVector field(field_->inTesla(GlobalPoint(0,0,0)));
  BaseParticlePropagator particle( RawParticle(mom,pos,kfTrackRef->charge()), 0, 0, field.z() );
  particle.propagateToEcalEntrance(false);
  if ( particle.getSuccess() == 0 ) { return; }
  
  // ECAL entry point for track
  GlobalPoint ecal_pos(particle.particle().vertex().x(),
               particle.particle().vertex().y(),
               particle.particle().vertex().z());

  // Preshower limit
  bool below_ps = pow(ecal_pos.z(),2.) > boundary_*ecal_pos.perp2();
  
  // Iterate through ECAL clusters 
  for ( unsigned int iclu = 0; iclu < ecalClusters.product()->size(); iclu++ ) {
    reco::PFClusterRef cluRef(ecalClusters,iclu);

    // Correct ecal_pos for shower depth 
    double shower_depth = reco::PFCluster::getDepthCorrection(cluRef->correctedEnergy(),
                                  below_ps,
                                  false);
    GlobalPoint showerPos = ecal_pos + 
      GlobalVector(particle.particle().momentum().x(),
           particle.particle().momentum().y(),
           particle.particle().momentum().z()).unit() * shower_depth;

    // Determine dR squared
    float dr2 = reco::deltaR2( cluRef->positionREP(), showerPos );

    // Find nearest ECAL cluster
    if ( dr2 < info.dr2min ) {
      info.dr2min = dr2;
      info.cluRef = cluRef;
      info.deta = std::abs( cluRef->positionREP().eta() - showerPos.eta() );
      info.dphi = 
    std::abs( reco::deltaPhi( cluRef->positionREP().phi(), showerPos.phi() )) * 
    kfTrackRef->charge();
      info.showerPos = showerPos;
    }
  
  }

  // Populate PreId object
  math::XYZPoint point( ecal_pos.x(),
            ecal_pos.y(),
            ecal_pos.z() );

  // Set PreId content
  ecalPreId.setECALMatchingProperties( info.cluRef,
                       point,
                       info.showerPos,
                       info.deta,
                       info.dphi,
                       0.f, // chieta
                       0.f, // chiphi
                       kfTrackRef->normalizedChi2(), // chi2
                       info.cluRef->correctedEnergy() / std::sqrt( kfTrackRef->innerMomentum().mag2() ) ); // E/p

}

Member Data Documentation

const edm::EDGetTokenT<reco::BeamSpot> LowPtGsfElectronSeedProducer::beamSpot_

private

Definition at line 130 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

double LowPtGsfElectronSeedProducer::boundary_ = 2.50746495928*2.50746495928

staticprivate

Definition at line 140 of file LowPtGsfElectronSeedProducer.h.

Referenced by propagateTrackToCalo().

const std::string LowPtGsfElectronSeedProducer::builder_

private

Definition at line 133 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const edm::EDGetTokenT<EcalRecHitCollection> LowPtGsfElectronSeedProducer::ebRecHits_

private

Definition at line 127 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const edm::EDGetTokenT<reco::PFClusterCollection> LowPtGsfElectronSeedProducer::ecalClusters_

private

Definition at line 125 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop().

const edm::EDGetTokenT<EcalRecHitCollection> LowPtGsfElectronSeedProducer::eeRecHits_

private

Definition at line 128 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

edm::ESHandle<MagneticField> LowPtGsfElectronSeedProducer::field_

private

Definition at line 120 of file LowPtGsfElectronSeedProducer.h.

Referenced by beginLuminosityBlock(), lightGsfTracking(), and propagateTrackToCalo().

const std::string LowPtGsfElectronSeedProducer::fitter_

private

Definition at line 131 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

std::unique_ptr<TrajectoryFitter> LowPtGsfElectronSeedProducer::fitterPtr_

private

Definition at line 121 of file LowPtGsfElectronSeedProducer.h.

Referenced by lightGsfTracking(), and loop().

edm::EDGetTokenT<reco::PFClusterCollection> LowPtGsfElectronSeedProducer::hcalClusters_

private

Definition at line 126 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().

edm::EDGetTokenT<reco::TrackCollection> LowPtGsfElectronSeedProducer::kfTracks_

private

Definition at line 123 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().

double LowPtGsfElectronSeedProducer::mass_ = 0.000511*0.000511

staticprivate

Definition at line 142 of file LowPtGsfElectronSeedProducer.h.

Referenced by propagateTrackToCalo().

const double LowPtGsfElectronSeedProducer::maxPtThreshold_

private

Definition at line 137 of file LowPtGsfElectronSeedProducer.h.

Referenced by decision(), and LowPtGsfElectronSeedProducer().

const double LowPtGsfElectronSeedProducer::minPtThreshold_

private

Definition at line 136 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const bool LowPtGsfElectronSeedProducer::passThrough_

private

Definition at line 134 of file LowPtGsfElectronSeedProducer.h.

Referenced by decision(), loop(), and LowPtGsfElectronSeedProducer().

edm::EDGetTokenT<reco::PFRecTrackCollection> LowPtGsfElectronSeedProducer::pfTracks_

private

Definition at line 124 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().

const edm::EDGetTokenT<double> LowPtGsfElectronSeedProducer::rho_

private

Definition at line 129 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const std::string LowPtGsfElectronSeedProducer::smoother_

private

Definition at line 132 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

std::unique_ptr<TrajectorySmoother> LowPtGsfElectronSeedProducer::smootherPtr_

private

Definition at line 122 of file LowPtGsfElectronSeedProducer.h.

Referenced by lightGsfTracking(), and loop().

const bool LowPtGsfElectronSeedProducer::usePfTracks_

private

Definition at line 135 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().