CMS 3D CMS Logo

List of all members | Classes | Public Types | Public Member Functions | Private Member Functions | Private Attributes
GsfElectronAlgo Class Reference

#include <GsfElectronAlgo.h>

Classes

struct  CutsConfiguration
 
struct  EcalRecHitsConfiguration
 
struct  ElectronData
 
struct  EventData
 
struct  EventSetupData
 
struct  GeneralData
 
struct  InputTagsConfiguration
 
struct  IsolationConfiguration
 
struct  StrategyConfiguration
 

Public Types

typedef std::list< reco::GsfElectron * > GsfElectronPtrCollection
 

Public Member Functions

void addPflowInfo ()
 
void beginEvent (edm::Event &)
 
void checkSetup (const edm::EventSetup &)
 
void clonePreviousElectrons ()
 
void completeElectrons (const gsfAlgoHelpers::HeavyObjectCache *)
 
void copyElectrons (reco::GsfElectronCollection &)
 
void displayInternalElectrons (const std::string &title) const
 
void endEvent ()
 
 GsfElectronAlgo (const InputTagsConfiguration &, const StrategyConfiguration &, const CutsConfiguration &cutsCfg, const CutsConfiguration &cutsCfgPflow, const ElectronHcalHelper::Configuration &hcalCfg, const ElectronHcalHelper::Configuration &hcalCfgPflow, const IsolationConfiguration &, const EcalRecHitsConfiguration &, EcalClusterFunctionBaseClass *superClusterErrorFunction, EcalClusterFunctionBaseClass *crackCorrectionFunction, const SoftElectronMVAEstimator::Configuration &mva_NIso_Cfg, const ElectronMVAEstimator::Configuration &mva_Iso_Cfg, const RegressionHelper::Configuration &regCfg)
 
void removeAmbiguousElectrons ()
 
void removeNotPreselectedElectrons ()
 
void setAmbiguityData (bool ignoreNotPreselected=true)
 
void setMVAInputs (const std::map< reco::GsfTrackRef, reco::GsfElectron::MvaInput > &mvaInputs)
 
void setMVAOutputs (const gsfAlgoHelpers::HeavyObjectCache *, const std::map< reco::GsfTrackRef, reco::GsfElectron::MvaOutput > &mvaOutputs)
 
 ~GsfElectronAlgo ()
 

Private Member Functions

void calculateSaturationInfo (const reco::SuperClusterRef &, reco::GsfElectron::SaturationInfo &)
 
void calculateShowerShape (const reco::SuperClusterRef &, bool pflow, reco::GsfElectron::ShowerShape &)
 
void calculateShowerShape_full5x5 (const reco::SuperClusterRef &, bool pflow, reco::GsfElectron::ShowerShape &)
 
void createElectron (const gsfAlgoHelpers::HeavyObjectCache *)
 
const reco::SuperClusterRef getTrSuperCluster (const reco::GsfTrackRef &trackRef)
 
bool isPreselected (reco::GsfElectron *ele)
 
void setCutBasedPreselectionFlag (reco::GsfElectron *ele, const reco::BeamSpot &)
 
void setMVAepiBasedPreselectionFlag (reco::GsfElectron *ele)
 
void setPflowPreselectionFlag (reco::GsfElectron *ele)
 
void setPixelMatchInfomation (reco::GsfElectron *)
 

Private Attributes

ElectronDataelectronData_
 
EventDataeventData_
 
EventSetupDataeventSetupData_
 
GeneralDatageneralData_
 

Detailed Description

Definition at line 58 of file GsfElectronAlgo.h.

Member Typedef Documentation

Definition at line 216 of file GsfElectronAlgo.h.

Constructor & Destructor Documentation

GsfElectronAlgo::GsfElectronAlgo ( const InputTagsConfiguration inputCfg,
const StrategyConfiguration strategyCfg,
const CutsConfiguration cutsCfg,
const CutsConfiguration cutsCfgPflow,
const ElectronHcalHelper::Configuration hcalCfg,
const ElectronHcalHelper::Configuration hcalCfgPflow,
const IsolationConfiguration isoCfg,
const EcalRecHitsConfiguration recHitsCfg,
EcalClusterFunctionBaseClass superClusterErrorFunction,
EcalClusterFunctionBaseClass crackCorrectionFunction,
const SoftElectronMVAEstimator::Configuration mva_NIso_Cfg,
const ElectronMVAEstimator::Configuration mva_Iso_Cfg,
const RegressionHelper::Configuration regCfg 
)

Definition at line 729 of file GsfElectronAlgo.cc.

Referenced by calculateShowerShape_full5x5().

743  : generalData_(new GeneralData(inputCfg,strategyCfg,cutsCfg,cutsCfgPflow,hcalCfg,hcalCfgPflow,isoCfg,recHitsCfg,superClusterErrorFunction,crackCorrectionFunction,mva_NIso_Cfg,mva_Iso_Cfg,regCfg)),
744  eventSetupData_(new EventSetupData),
746  {}
GeneralData * generalData_
EventSetupData * eventSetupData_
EventData * eventData_
ElectronData * electronData_
GsfElectronAlgo::~GsfElectronAlgo ( )

Definition at line 748 of file GsfElectronAlgo.cc.

References electronData_, eventData_, eventSetupData_, and generalData_.

749  {
750  delete generalData_ ;
751  delete eventSetupData_ ;
752  delete eventData_ ;
753  delete electronData_ ;
754  }
GeneralData * generalData_
EventSetupData * eventSetupData_
EventData * eventData_
ElectronData * electronData_

Member Function Documentation

void GsfElectronAlgo::addPflowInfo ( )

Definition at line 1017 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::edIsolationValues, GsfElectronAlgo::EventData::electrons, eventData_, Exception, funct::false, runEdmFileComparison::found, GsfElectronAlgo::EventData::pfIsolationValues, GsfElectronAlgo::EventData::pflowElectrons, GsfElectronAlgo::EventData::previousElectrons, edm::Handle< T >::product(), setPflowPreselectionFlag(), reco::GsfElectron::PflowIsolationVariables::sumChargedHadronPt, reco::GsfElectron::PflowIsolationVariables::sumNeutralHadronEt, reco::GsfElectron::PflowIsolationVariables::sumPhotonEt, and funct::true.

Referenced by GsfElectronProducer::produce().

1018  {
1019  bool found ;
1020  const GsfElectronCollection * edElectrons = eventData_->previousElectrons.product() ;
1021  const GsfElectronCollection * pfElectrons = eventData_->pflowElectrons.product() ;
1022  GsfElectronCollection::const_iterator pfElectron, edElectron ;
1023  unsigned int edIndex, pfIndex ;
1024 
1025  GsfElectronPtrCollection::iterator el ;
1026  for
1027  ( el = eventData_->electrons->begin() ;
1028  el != eventData_->electrons->end() ;
1029  el++ )
1030  {
1031 
1032  // Retreive info from pflow electrons
1033  found = false ;
1034  for
1035  ( pfIndex = 0, pfElectron = pfElectrons->begin() ; pfElectron != pfElectrons->end() ; pfIndex++, pfElectron++ )
1036  {
1037  if (pfElectron->gsfTrack()==(*el)->gsfTrack())
1038  {
1039  if (found)
1040  {
1041  edm::LogWarning("GsfElectronProducer")<<"associated pfGsfElectron already found" ;
1042  }
1043  else
1044  {
1045  found = true ;
1046 
1047  // Isolation Values
1048  if( (eventData_->pfIsolationValues).size() != 0 )
1049  {
1051  pfElectronRef(eventData_->pflowElectrons, pfIndex);
1053  isoVariables.sumChargedHadronPt =(*(eventData_->pfIsolationValues)[0])[pfElectronRef];
1054  isoVariables.sumPhotonEt =(*(eventData_->pfIsolationValues)[1])[pfElectronRef];
1055  isoVariables.sumNeutralHadronEt =(*(eventData_->pfIsolationValues)[2])[pfElectronRef];
1056  (*el)->setPfIsolationVariables(isoVariables);
1057  }
1058 
1059 // (*el)->setPfIsolationVariables(pfElectron->pfIsolationVariables()) ;
1060  (*el)->setMvaInput(pfElectron->mvaInput()) ;
1061  (*el)->setMvaOutput(pfElectron->mvaOutput()) ;
1062  if ((*el)->ecalDrivenSeed())
1063  { (*el)->setP4(GsfElectron::P4_PFLOW_COMBINATION,pfElectron->p4(GsfElectron::P4_PFLOW_COMBINATION),pfElectron->p4Error(GsfElectron::P4_PFLOW_COMBINATION),false) ; }
1064  else
1065  { (*el)->setP4(GsfElectron::P4_PFLOW_COMBINATION,pfElectron->p4(GsfElectron::P4_PFLOW_COMBINATION),pfElectron->p4Error(GsfElectron::P4_PFLOW_COMBINATION),true) ; }
1066  double noCutMin = -999999999. ;
1067  if ((*el)->mva_e_pi()<noCutMin) { throw cms::Exception("GsfElectronAlgo|UnexpectedMvaValue")<<"unexpected MVA value: "<<(*el)->mva_e_pi() ; }
1068  }
1069  }
1070  }
1071 
1072  // Isolation Values
1073  // Retreive not found info from ed electrons
1074  if( (eventData_->edIsolationValues).size() != 0 )
1075  {
1076  edIndex = 0, edElectron = edElectrons->begin() ;
1077  while ((found == false)&&(edElectron != edElectrons->end()))
1078  {
1079  if (edElectron->gsfTrack()==(*el)->gsfTrack())
1080  {
1081  found = true ;
1082 
1083  // CONSTRUCTION D UNE REF dans le handle eventData_->previousElectrons avec l'indice edIndex,
1084  // puis recuperation dans la ValueMap ED
1085 
1087  edElectronRef(eventData_->previousElectrons, edIndex);
1089  isoVariables.sumChargedHadronPt =(*(eventData_->edIsolationValues)[0])[edElectronRef];
1090  isoVariables.sumPhotonEt =(*(eventData_->edIsolationValues)[1])[edElectronRef];
1091  isoVariables.sumNeutralHadronEt =(*(eventData_->edIsolationValues)[2])[edElectronRef];
1092  (*el)->setPfIsolationVariables(isoVariables);
1093  }
1094 
1095  edIndex++ ;
1096  edElectron++ ;
1097  }
1098  }
1099 
1100  // Preselection
1102 
1103  }
1104  }
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
float sumPhotonEt
sum pt of PF photons // old float photonIso ;
Definition: GsfElectron.h:627
IsolationValueMaps pfIsolationValues
float sumNeutralHadronEt
sum pt of neutral hadrons // old float neutralHadronIso ;
Definition: GsfElectron.h:626
GsfElectronPtrCollection * electrons
edm::Handle< reco::GsfElectronCollection > previousElectrons
edm::Handle< reco::GsfElectronCollection > pflowElectrons
T const * product() const
Definition: Handle.h:81
void setPflowPreselectionFlag(reco::GsfElectron *ele)
EventData * eventData_
IsolationValueMaps edIsolationValues
float sumChargedHadronPt
sum-pt of charged Hadron // old float chargedHadronIso ;
Definition: GsfElectron.h:625
void GsfElectronAlgo::beginEvent ( edm::Event event)

Definition at line 823 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::InputTagsConfiguration::barrelRecHitCollection, GsfElectronAlgo::EventData::barrelRecHits, GsfElectronAlgo::EventData::beamspot, GsfElectronAlgo::InputTagsConfiguration::beamSpotTag, GsfElectronAlgo::EventSetupData::caloGeom, GsfElectronAlgo::EventData::coreElectrons, GsfElectronAlgo::InputTagsConfiguration::ctfTracks, GsfElectronAlgo::EventData::currentCtfTracks, EgammaRecHitIsolation::doFlagChecks(), EgammaRecHitIsolation::doSeverityChecks(), DetId::Ecal, GsfElectronAlgo::EventData::ecalBarrelIsol03, GsfElectronAlgo::EventData::ecalBarrelIsol04, GsfElectronAlgo::EventData::ecalEndcapIsol03, GsfElectronAlgo::EventData::ecalEndcapIsol04, GsfElectronAlgo::EventData::edIsolationValues, GsfElectronAlgo::InputTagsConfiguration::edIsoVals, GsfElectronAlgo::IsolationConfiguration::eMinBarrel, GsfElectronAlgo::IsolationConfiguration::eMinEndcaps, edm::ParameterSet::empty(), GsfElectronAlgo::InputTagsConfiguration::endcapRecHitCollection, GsfElectronAlgo::EventData::endcapRecHits, GsfElectronAlgo::IsolationConfiguration::etMinBarrel, GsfElectronAlgo::IsolationConfiguration::etMinEndcaps, GsfElectronAlgo::IsolationConfiguration::etMinHcal, GsfElectronAlgo::EventData::event, GsfElectronAlgo::EventData::EventData(), eventData_, eventSetupData_, Exception, generalData_, edm::Event::getByToken(), edm::ParameterSet::getParameter(), GsfElectronAlgo::InputTagsConfiguration::gsfElectronCores, GsfElectronAlgo::EventData::gsfPfRecTracks, GsfElectronAlgo::InputTagsConfiguration::gsfPfRecTracksTag, GsfElectronAlgo::EventData::hadDepth1Isolation03, GsfElectronAlgo::EventData::hadDepth1Isolation03Bc, GsfElectronAlgo::EventData::hadDepth1Isolation04, GsfElectronAlgo::EventData::hadDepth1Isolation04Bc, GsfElectronAlgo::EventData::hadDepth2Isolation03, GsfElectronAlgo::EventData::hadDepth2Isolation03Bc, GsfElectronAlgo::EventData::hadDepth2Isolation04, GsfElectronAlgo::EventData::hadDepth2Isolation04Bc, GsfElectronAlgo::GeneralData::hcalHelper, GsfElectronAlgo::GeneralData::hcalHelperPflow, GsfElectronAlgo::InputTagsConfiguration::hcalTowersTag, GsfElectronAlgo::GeneralData::inputCfg, electronEcalRecHitIsolationLcone_cfi::intRadiusBarrel, GsfElectronAlgo::IsolationConfiguration::intRadiusBarrelTk, GsfElectronAlgo::IsolationConfiguration::intRadiusEcalBarrel, GsfElectronAlgo::IsolationConfiguration::intRadiusEcalEndcaps, electronEcalRecHitIsolationLcone_cfi::intRadiusEndcap, GsfElectronAlgo::IsolationConfiguration::intRadiusEndcapTk, GsfElectronAlgo::IsolationConfiguration::intRadiusHcal, GsfElectronAlgo::GeneralData::isoCfg, GsfElectronAlgo::IsolationConfiguration::jurassicWidth, GsfElectronAlgo::IsolationConfiguration::maxDrbTk, electronTrackIsolationLcone_cfi::maxVtxDist, GsfElectronAlgo::IsolationConfiguration::maxVtxDistTk, GsfElectronAlgo::EventData::pfIsolationValues, GsfElectronAlgo::InputTagsConfiguration::pfIsoVals, GsfElectronAlgo::EventData::pflowElectrons, GsfElectronAlgo::InputTagsConfiguration::pflowGsfElectronsTag, GsfElectronAlgo::InputTagsConfiguration::pfMVA, GsfElectronAlgo::EventData::pfMva, reco::BeamSpot::position(), GsfElectronAlgo::EventData::previousElectrons, GsfElectronAlgo::InputTagsConfiguration::previousGsfElectrons, edm::Handle< T >::product(), edm::ESHandle< T >::product(), ALCARECOTkAlBeamHalo_cff::ptMin, GsfElectronAlgo::IsolationConfiguration::ptMinTk, ElectronHcalHelper::readEvent(), GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps, GsfElectronAlgo::GeneralData::recHitsCfg, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps, GsfElectronAlgo::EventData::seeds, GsfElectronAlgo::InputTagsConfiguration::seedsTag, EgammaRecHitIsolation::setUseNumCrystals(), EgammaRecHitIsolation::setVetoClustered(), GsfElectronAlgo::EventSetupData::sevLevel, GsfElectronAlgo::GeneralData::strategyCfg, electronTrackIsolationLcone_cfi::stripBarrel, GsfElectronAlgo::IsolationConfiguration::stripBarrelTk, electronTrackIsolationLcone_cfi::stripEndcap, GsfElectronAlgo::IsolationConfiguration::stripEndcapTk, GsfElectronAlgo::EventData::tkIsolation03, GsfElectronAlgo::EventData::tkIsolation04, GsfElectronAlgo::EventData::towers, GsfElectronAlgo::StrategyConfiguration::useGsfPfRecTracks, GsfElectronAlgo::IsolationConfiguration::useNumCrystals, GsfElectronAlgo::EventData::vertices, GsfElectronAlgo::IsolationConfiguration::vetoClustered, and GsfElectronAlgo::InputTagsConfiguration::vtxCollectionTag.

Referenced by GsfElectronBaseProducer::beginEvent().

824  {
825  if (eventData_!=0)
826  { throw cms::Exception("GsfElectronAlgo|InternalError")<<"unexpected event data" ; }
827  eventData_ = new EventData ;
828 
829  // init the handles linked to the current event
830  eventData_->event = &event ;
837  event.getByToken(generalData_->inputCfg.hcalTowersTag,eventData_->towers) ;
838  event.getByToken(generalData_->inputCfg.pfMVA,eventData_->pfMva) ;
839  event.getByToken(generalData_->inputCfg.seedsTag,eventData_->seeds) ;
843 
844  // get the beamspot from the Event:
845  edm::Handle<reco::BeamSpot> recoBeamSpotHandle ;
846  event.getByToken(generalData_->inputCfg.beamSpotTag,recoBeamSpotHandle) ;
847  eventData_->beamspot = recoBeamSpotHandle.product() ;
848 
849  // prepare access to hcal data
852 
853  // Isolation algos
854  float extRadiusSmall=0.3, extRadiusLarge=0.4 ;
859 
860  float egHcalIsoConeSizeOutSmall=0.3, egHcalIsoConeSizeOutLarge=0.4;
861  float egHcalIsoConeSizeIn=generalData_->isoCfg.intRadiusHcal,egHcalIsoPtMin=generalData_->isoCfg.etMinHcal;
862  int egHcalDepth1=1, egHcalDepth2=2;
863  eventData_->hadDepth1Isolation03 = new EgammaTowerIsolation(egHcalIsoConeSizeOutSmall,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth1,eventData_->towers.product()) ;
864  eventData_->hadDepth2Isolation03 = new EgammaTowerIsolation(egHcalIsoConeSizeOutSmall,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth2,eventData_->towers.product()) ;
865  eventData_->hadDepth1Isolation04 = new EgammaTowerIsolation(egHcalIsoConeSizeOutLarge,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth1,eventData_->towers.product()) ;
866  eventData_->hadDepth2Isolation04 = new EgammaTowerIsolation(egHcalIsoConeSizeOutLarge,egHcalIsoConeSizeIn,egHcalIsoPtMin,egHcalDepth2,eventData_->towers.product()) ;
867  eventData_->hadDepth1Isolation03Bc = new EgammaTowerIsolation(egHcalIsoConeSizeOutSmall,0.,egHcalIsoPtMin,egHcalDepth1,eventData_->towers.product()) ;
868  eventData_->hadDepth2Isolation03Bc = new EgammaTowerIsolation(egHcalIsoConeSizeOutSmall,0.,egHcalIsoPtMin,egHcalDepth2,eventData_->towers.product()) ;
869  eventData_->hadDepth1Isolation04Bc = new EgammaTowerIsolation(egHcalIsoConeSizeOutLarge,0.,egHcalIsoPtMin,egHcalDepth1,eventData_->towers.product()) ;
870  eventData_->hadDepth2Isolation04Bc = new EgammaTowerIsolation(egHcalIsoConeSizeOutLarge,0.,egHcalIsoPtMin,egHcalDepth2,eventData_->towers.product()) ;
871 
872  float egIsoConeSizeOutSmall=0.3, egIsoConeSizeOutLarge=0.4, egIsoJurassicWidth=generalData_->isoCfg.jurassicWidth;
873  float egIsoPtMinBarrel=generalData_->isoCfg.etMinBarrel,egIsoEMinBarrel=generalData_->isoCfg.eMinBarrel, egIsoConeSizeInBarrel=generalData_->isoCfg.intRadiusEcalBarrel;
874  float egIsoPtMinEndcap=generalData_->isoCfg.etMinEndcaps,egIsoEMinEndcap=generalData_->isoCfg.eMinEndcaps, egIsoConeSizeInEndcap=generalData_->isoCfg.intRadiusEcalEndcaps;
875  eventData_->ecalBarrelIsol03 = new EgammaRecHitIsolation(egIsoConeSizeOutSmall,egIsoConeSizeInBarrel,egIsoJurassicWidth,egIsoPtMinBarrel,egIsoEMinBarrel,eventSetupData_->caloGeom,*(eventData_->barrelRecHits),eventSetupData_->sevLevel.product(),DetId::Ecal);
876  eventData_->ecalBarrelIsol04 = new EgammaRecHitIsolation(egIsoConeSizeOutLarge,egIsoConeSizeInBarrel,egIsoJurassicWidth,egIsoPtMinBarrel,egIsoEMinBarrel,eventSetupData_->caloGeom,*(eventData_->barrelRecHits),eventSetupData_->sevLevel.product(),DetId::Ecal);
877  eventData_->ecalEndcapIsol03 = new EgammaRecHitIsolation(egIsoConeSizeOutSmall,egIsoConeSizeInEndcap,egIsoJurassicWidth,egIsoPtMinEndcap,egIsoEMinEndcap,eventSetupData_->caloGeom,*(eventData_->endcapRecHits),eventSetupData_->sevLevel.product(),DetId::Ecal);
878  eventData_->ecalEndcapIsol04 = new EgammaRecHitIsolation(egIsoConeSizeOutLarge,egIsoConeSizeInEndcap,egIsoJurassicWidth,egIsoPtMinEndcap,egIsoEMinEndcap,eventSetupData_->caloGeom,*(eventData_->endcapRecHits),eventSetupData_->sevLevel.product(),DetId::Ecal);
895 
896  //Fill in the Isolation Value Maps for PF and EcalDriven electrons
897  std::vector<edm::InputTag> inputTagIsoVals;
899  inputTagIsoVals.push_back(generalData_->inputCfg.pfIsoVals.getParameter<edm::InputTag>("pfSumChargedHadronPt"));
900  inputTagIsoVals.push_back(generalData_->inputCfg.pfIsoVals.getParameter<edm::InputTag>("pfSumPhotonEt"));
901  inputTagIsoVals.push_back(generalData_->inputCfg.pfIsoVals.getParameter<edm::InputTag>("pfSumNeutralHadronEt"));
902 
903  eventData_->pfIsolationValues.resize(inputTagIsoVals.size());
904 
905  for (size_t j = 0; j<inputTagIsoVals.size(); ++j) {
906  event.getByLabel(inputTagIsoVals[j], eventData_->pfIsolationValues[j]);
907  }
908 
909  }
910 
912  inputTagIsoVals.clear();
913  inputTagIsoVals.push_back(generalData_->inputCfg.edIsoVals.getParameter<edm::InputTag>("edSumChargedHadronPt"));
914  inputTagIsoVals.push_back(generalData_->inputCfg.edIsoVals.getParameter<edm::InputTag>("edSumPhotonEt"));
915  inputTagIsoVals.push_back(generalData_->inputCfg.edIsoVals.getParameter<edm::InputTag>("edSumNeutralHadronEt"));
916 
917  eventData_->edIsolationValues.resize(inputTagIsoVals.size());
918 
919  for (size_t j = 0; j<inputTagIsoVals.size(); ++j) {
920  event.getByLabel(inputTagIsoVals[j], eventData_->edIsolationValues[j]);
921  }
922  }
923  }
ElectronHcalHelper * hcalHelperPflow
T getParameter(std::string const &) const
edm::Handle< reco::ElectronSeedCollection > seeds
bool empty() const
Definition: ParameterSet.h:218
edm::Handle< edm::ValueMap< float > > pfMva
GeneralData * generalData_
EgammaTowerIsolation * hadDepth1Isolation04Bc
edm::EDGetTokenT< reco::GsfElectronCoreCollection > gsfElectronCores
void readEvent(const edm::Event &)
EgammaTowerIsolation * hadDepth1Isolation03Bc
edm::EDGetTokenT< reco::GsfElectronCollection > previousGsfElectrons
const IsolationConfiguration isoCfg
edm::EDGetTokenT< reco::VertexCollection > vtxCollectionTag
const EcalRecHitsConfiguration recHitsCfg
EventSetupData * eventSetupData_
edm::Handle< EcalRecHitCollection > endcapRecHits
edm::EDGetTokenT< EcalRecHitCollection > endcapRecHitCollection
const InputTagsConfiguration inputCfg
edm::ESHandle< EcalSeverityLevelAlgo > sevLevel
EgammaTowerIsolation * hadDepth1Isolation03
edm::EDGetTokenT< reco::GsfElectronCollection > pflowGsfElectronsTag
const StrategyConfiguration strategyCfg
edm::EDGetTokenT< EcalRecHitCollection > barrelRecHitCollection
void doFlagChecks(const std::vector< int > &v)
edm::EDGetTokenT< reco::GsfPFRecTrackCollection > gsfPfRecTracksTag
EgammaRecHitIsolation * ecalBarrelIsol04
EgammaTowerIsolation * hadDepth2Isolation03
EgammaTowerIsolation * hadDepth1Isolation04
edm::EDGetTokenT< reco::BeamSpot > beamSpotTag
ElectronTkIsolation * tkIsolation03
void setUseNumCrystals(bool b=true)
EgammaRecHitIsolation * ecalEndcapIsol03
EgammaTowerIsolation * hadDepth2Isolation03Bc
edm::Handle< EcalRecHitCollection > barrelRecHits
IsolationValueMaps pfIsolationValues
ElectronHcalHelper * hcalHelper
edm::EDGetTokenT< reco::ElectronSeedCollection > seedsTag
const reco::BeamSpot * beamspot
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of"!*"before the partial wildcard feature was incorporated).The per-event"cost"of each negative criterion with multiple relevant triggers is about the same as!*was in the past
edm::EDGetTokenT< edm::ValueMap< float > > pfMVA
void doSeverityChecks(const EcalRecHitCollection *const recHits, const std::vector< int > &v)
edm::EDGetTokenT< CaloTowerCollection > hcalTowersTag
EgammaTowerIsolation * hadDepth2Isolation04Bc
edm::EDGetTokenT< reco::TrackCollection > ctfTracks
edm::Handle< reco::GsfElectronCollection > previousElectrons
edm::Handle< reco::VertexCollection > vertices
EgammaRecHitIsolation * ecalBarrelIsol03
edm::Handle< reco::GsfElectronCollection > pflowElectrons
T const * product() const
Definition: Handle.h:81
EgammaTowerIsolation * hadDepth2Isolation04
void setVetoClustered(bool b=true)
edm::Handle< reco::TrackCollection > currentCtfTracks
edm::ESHandle< CaloGeometry > caloGeom
EgammaRecHitIsolation * ecalEndcapIsol04
const Point & position() const
position
Definition: BeamSpot.h:62
EventData * eventData_
ElectronTkIsolation * tkIsolation04
IsolationValueMaps edIsolationValues
edm::Handle< reco::GsfElectronCoreCollection > coreElectrons
T const * product() const
Definition: ESHandle.h:86
edm::Handle< CaloTowerCollection > towers
edm::Handle< reco::GsfPFRecTrackCollection > gsfPfRecTracks
void GsfElectronAlgo::calculateSaturationInfo ( const reco::SuperClusterRef theClus,
reco::GsfElectron::SaturationInfo si 
)
private

Definition at line 543 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::barrelRecHits, gamEcalExtractorBlocks_cff::detector, EcalBarrel, ecalRecalibRecHit_cfi::ecalRecHit, edm::SortedCollection< T, SORT >::end(), GsfElectronAlgo::EventData::endcapRecHits, eventData_, edm::SortedCollection< T, SORT >::find(), reco::GsfElectron::SaturationInfo::isSeedSaturated, reco::GsfElectron::SaturationInfo::nSaturatedXtals, reco::CaloCluster::seed(), and DetId::subdetId().

Referenced by createElectron().

544  {
545 
546  const reco::CaloCluster & seedCluster = *(theClus->seed()) ;
547  DetId seedXtalId = seedCluster.seed();
548  int detector = seedXtalId.subdetId();
549  const EcalRecHitCollection* ecalRecHits = 0 ;
550  if (detector==EcalBarrel)
551  ecalRecHits = eventData_->barrelRecHits.product() ;
552  else
553  ecalRecHits = eventData_->endcapRecHits.product() ;
554 
555  int nSaturatedXtals = 0;
556  bool isSeedSaturated = false;
557  const auto hitsAndFractions = theClus->hitsAndFractions();
558  for (auto&& hitFractionPair : hitsAndFractions) {
559  auto&& ecalRecHit = ecalRecHits->find(hitFractionPair.first);
560  if (ecalRecHit == ecalRecHits->end()) continue;
561  if (ecalRecHit->checkFlag(EcalRecHit::Flags::kSaturated)) {
562  nSaturatedXtals++;
563  if (seedXtalId == ecalRecHit->detid())
564  isSeedSaturated = true;
565  }
566  }
567  si.nSaturatedXtals = nSaturatedXtals;
568  si.isSeedSaturated = isSeedSaturated;
569 
570 }
edm::Handle< EcalRecHitCollection > endcapRecHits
edm::Handle< EcalRecHitCollection > barrelRecHits
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
const_iterator end() const
Definition: DetId.h:18
DetId seed() const
return DetId of seed
Definition: CaloCluster.h:205
iterator find(key_type k)
EventData * eventData_
void GsfElectronAlgo::calculateShowerShape ( const reco::SuperClusterRef theClus,
bool  pflow,
reco::GsfElectron::ShowerShape showerShape 
)
private

Definition at line 572 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::barrelRecHits, GsfElectronAlgo::EventSetupData::caloGeom, GsfElectronAlgo::EventSetupData::caloTopo, gamEcalExtractorBlocks_cff::detector, heepElectronID_HEEPV50_CSA14_25ns_cff::e1x5, reco::GsfElectron::ShowerShape::e1x5, reco::GsfElectron::ShowerShape::e2nd, reco::GsfElectron::ShowerShape::e2x5Bottom, reco::GsfElectron::ShowerShape::e2x5Left, reco::GsfElectron::ShowerShape::e2x5Max, reco::GsfElectron::ShowerShape::e2x5Right, reco::GsfElectron::ShowerShape::e2x5Top, heepElectronID_HEEPV50_CSA14_25ns_cff::e5x5, reco::GsfElectron::ShowerShape::e5x5, reco::GsfElectron::ShowerShape::eBottom, EcalBarrel, reco::GsfElectron::ShowerShape::eLeft, photonPostprocessing_cfi::eMax, reco::GsfElectron::ShowerShape::eMax, GsfElectronAlgo::EventData::endcapRecHits, reco::GsfElectron::ShowerShape::eRight, reco::GsfElectron::ShowerShape::eTop, eventData_, eventSetupData_, generalData_, reco::GsfElectron::ShowerShape::hcalDepth1OverEcal, reco::GsfElectron::ShowerShape::hcalDepth1OverEcalBc, reco::GsfElectron::ShowerShape::hcalDepth2OverEcal, reco::GsfElectron::ShowerShape::hcalDepth2OverEcalBc, ElectronHcalHelper::hcalESumDepth1(), ElectronHcalHelper::hcalESumDepth1BehindClusters(), ElectronHcalHelper::hcalESumDepth2(), ElectronHcalHelper::hcalESumDepth2BehindClusters(), GsfElectronAlgo::GeneralData::hcalHelper, GsfElectronAlgo::GeneralData::hcalHelperPflow, ElectronHcalHelper::hcalTowersBehindClusters(), reco::GsfElectron::ShowerShape::hcalTowersBehindClusters, reco::CaloCluster::hitsAndFractions(), edm::isNotFinite(), edm::ESHandle< T >::product(), reco::GsfElectron::ShowerShape::r9, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps, GsfElectronAlgo::GeneralData::recHitsCfg, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps, reco::GsfElectron::ShowerShape::sigmaEtaEta, reco::GsfElectron::ShowerShape::sigmaIetaIeta, reco::GsfElectron::ShowerShape::sigmaIetaIphi, reco::GsfElectron::ShowerShape::sigmaIphiIphi, mathSSE::sqrt(), DetId::subdetId(), and ecaldqm::topology().

Referenced by createElectron().

574  {
575  const reco::CaloCluster & seedCluster = *(theClus->seed()) ;
576  // temporary, till CaloCluster->seed() is made available
577  DetId seedXtalId = seedCluster.hitsAndFractions()[0].first ;
578  int detector = seedXtalId.subdetId() ;
579 
582  const EcalRecHitCollection * recHits = 0 ;
583  std::vector<int> recHitFlagsToBeExcluded ;
584  std::vector<int> recHitSeverityToBeExcluded ;
585  if (detector==EcalBarrel)
586  {
587  recHits = eventData_->barrelRecHits.product() ;
588  recHitFlagsToBeExcluded = generalData_->recHitsCfg.recHitFlagsToBeExcludedBarrel ;
589  recHitSeverityToBeExcluded = generalData_->recHitsCfg.recHitSeverityToBeExcludedBarrel ;
590  }
591  else
592  {
593  recHits = eventData_->endcapRecHits.product() ;
594  recHitFlagsToBeExcluded = generalData_->recHitsCfg.recHitFlagsToBeExcludedEndcaps ;
595  recHitSeverityToBeExcluded = generalData_->recHitsCfg.recHitSeverityToBeExcludedEndcaps ;
596  }
597 
598  std::vector<float> covariances = EcalClusterTools::covariances(seedCluster,recHits,topology,geometry) ;
599  std::vector<float> localCovariances = EcalClusterTools::localCovariances(seedCluster,recHits,topology) ;
600  showerShape.sigmaEtaEta = sqrt(covariances[0]) ;
601  showerShape.sigmaIetaIeta = sqrt(localCovariances[0]) ;
602  if (!edm::isNotFinite(localCovariances[2])) showerShape.sigmaIphiIphi = sqrt(localCovariances[2]) ;
603  showerShape.e1x5 = EcalClusterTools::e1x5(seedCluster,recHits,topology) ;
604  showerShape.e2x5Max = EcalClusterTools::e2x5Max(seedCluster,recHits,topology) ;
605  showerShape.e5x5 = EcalClusterTools::e5x5(seedCluster,recHits,topology) ;
606  showerShape.r9 = EcalClusterTools::e3x3(seedCluster,recHits,topology)/theClus->rawEnergy() ;
607 
608  if (pflow)
609  {
610  showerShape.hcalDepth1OverEcal = generalData_->hcalHelperPflow->hcalESumDepth1(*theClus)/theClus->energy() ;
611  showerShape.hcalDepth2OverEcal = generalData_->hcalHelperPflow->hcalESumDepth2(*theClus)/theClus->energy() ;
615  }
616  else
617  {
618  showerShape.hcalDepth1OverEcal = generalData_->hcalHelper->hcalESumDepth1(*theClus)/theClus->energy() ;
619  showerShape.hcalDepth2OverEcal = generalData_->hcalHelper->hcalESumDepth2(*theClus)/theClus->energy() ;
623  }
624 
625  // extra shower shapes
626  const float see_by_spp = showerShape.sigmaIetaIeta*showerShape.sigmaIphiIphi;
627  if( see_by_spp > 0 ) {
628  showerShape.sigmaIetaIphi = localCovariances[1] / see_by_spp;
629  } else if ( localCovariances[1] > 0 ) {
630  showerShape.sigmaIetaIphi = 1.f;
631  } else {
632  showerShape.sigmaIetaIphi = -1.f;
633  }
634  showerShape.eMax = EcalClusterTools::eMax(seedCluster,recHits);
635  showerShape.e2nd = EcalClusterTools::e2nd(seedCluster,recHits);
636  showerShape.eTop = EcalClusterTools::eTop(seedCluster,recHits,topology);
637  showerShape.eLeft = EcalClusterTools::eLeft(seedCluster,recHits,topology);
638  showerShape.eRight = EcalClusterTools::eRight(seedCluster,recHits,topology);
639  showerShape.eBottom = EcalClusterTools::eBottom(seedCluster,recHits,topology);
640 
641  showerShape.e2x5Left = EcalClusterTools::e2x5Left(seedCluster,recHits,topology);
642  showerShape.e2x5Right = EcalClusterTools::e2x5Right(seedCluster,recHits,topology);
643  showerShape.e2x5Top = EcalClusterTools::e2x5Top(seedCluster,recHits,topology);
644  showerShape.e2x5Bottom = EcalClusterTools::e2x5Bottom(seedCluster,recHits,topology);
645  }
ElectronHcalHelper * hcalHelperPflow
GeneralData * generalData_
CaloTopology const * topology(0)
const EcalRecHitsConfiguration recHitsCfg
EventSetupData * eventSetupData_
edm::Handle< EcalRecHitCollection > endcapRecHits
double hcalESumDepth2BehindClusters(const std::vector< CaloTowerDetId > &towers)
std::vector< CaloTowerDetId > hcalTowersBehindClusters(const reco::SuperCluster &sc)
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:195
double hcalESumDepth1BehindClusters(const std::vector< CaloTowerDetId > &towers)
edm::ESHandle< CaloTopology > caloTopo
bool isNotFinite(T x)
Definition: isFinite.h:10
T sqrt(T t)
Definition: SSEVec.h:18
edm::Handle< EcalRecHitCollection > barrelRecHits
std::vector< CaloTowerDetId > hcalTowersBehindClusters
Definition: GsfElectron.h:396
double hcalESumDepth2(const reco::SuperCluster &, const std::vector< CaloTowerDetId > *excludeTowers=0)
ElectronHcalHelper * hcalHelper
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
Definition: DetId.h:18
edm::ESHandle< CaloGeometry > caloGeom
double hcalESumDepth1(const reco::SuperCluster &, const std::vector< CaloTowerDetId > *excludeTowers=0)
EventData * eventData_
T const * product() const
Definition: ESHandle.h:86
void GsfElectronAlgo::calculateShowerShape_full5x5 ( const reco::SuperClusterRef theClus,
bool  pflow,
reco::GsfElectron::ShowerShape showerShape 
)
private

Definition at line 647 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::barrelRecHits, GsfElectronAlgo::EventSetupData::caloGeom, GsfElectronAlgo::EventSetupData::caloTopo, EcalClusterToolsT< noZS >::covariances(), gamEcalExtractorBlocks_cff::detector, EcalClusterToolsT< noZS >::e1x5(), reco::GsfElectron::ShowerShape::e1x5, EcalClusterToolsT< noZS >::e2nd(), reco::GsfElectron::ShowerShape::e2nd, EcalClusterToolsT< noZS >::e2x5Bottom(), reco::GsfElectron::ShowerShape::e2x5Bottom, EcalClusterToolsT< noZS >::e2x5Left(), reco::GsfElectron::ShowerShape::e2x5Left, EcalClusterToolsT< noZS >::e2x5Max(), reco::GsfElectron::ShowerShape::e2x5Max, EcalClusterToolsT< noZS >::e2x5Right(), reco::GsfElectron::ShowerShape::e2x5Right, EcalClusterToolsT< noZS >::e2x5Top(), reco::GsfElectron::ShowerShape::e2x5Top, EcalClusterToolsT< noZS >::e3x3(), EcalClusterToolsT< noZS >::e5x5(), reco::GsfElectron::ShowerShape::e5x5, EcalClusterToolsT< noZS >::eBottom(), reco::GsfElectron::ShowerShape::eBottom, EcalBarrel, EcalClusterToolsT< noZS >::eLeft(), reco::GsfElectron::ShowerShape::eLeft, EcalClusterToolsT< noZS >::eMax(), reco::GsfElectron::ShowerShape::eMax, GsfElectronAlgo::EventData::endcapRecHits, EcalClusterToolsT< noZS >::eRight(), reco::GsfElectron::ShowerShape::eRight, EcalClusterToolsT< noZS >::eTop(), reco::GsfElectron::ShowerShape::eTop, eventData_, eventSetupData_, generalData_, GsfElectronAlgo(), reco::GsfElectron::ShowerShape::hcalDepth1OverEcal, reco::GsfElectron::ShowerShape::hcalDepth1OverEcalBc, reco::GsfElectron::ShowerShape::hcalDepth2OverEcal, reco::GsfElectron::ShowerShape::hcalDepth2OverEcalBc, ElectronHcalHelper::hcalESumDepth1(), ElectronHcalHelper::hcalESumDepth1BehindClusters(), ElectronHcalHelper::hcalESumDepth2(), ElectronHcalHelper::hcalESumDepth2BehindClusters(), GsfElectronAlgo::GeneralData::hcalHelper, GsfElectronAlgo::GeneralData::hcalHelperPflow, ElectronHcalHelper::hcalTowersBehindClusters(), reco::GsfElectron::ShowerShape::hcalTowersBehindClusters, reco::CaloCluster::hitsAndFractions(), edm::isNotFinite(), EcalClusterToolsT< noZS >::localCovariances(), edm::ESHandle< T >::product(), reco::GsfElectron::ShowerShape::r9, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps, GsfElectronAlgo::GeneralData::recHitsCfg, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps, reco::GsfElectron::ShowerShape::sigmaEtaEta, reco::GsfElectron::ShowerShape::sigmaIetaIeta, reco::GsfElectron::ShowerShape::sigmaIetaIphi, reco::GsfElectron::ShowerShape::sigmaIphiIphi, mathSSE::sqrt(), DetId::subdetId(), and ecaldqm::topology().

Referenced by createElectron().

649  {
650  const reco::CaloCluster & seedCluster = *(theClus->seed()) ;
651  // temporary, till CaloCluster->seed() is made available
652  DetId seedXtalId = seedCluster.hitsAndFractions()[0].first ;
653  int detector = seedXtalId.subdetId() ;
654 
657  const EcalRecHitCollection * recHits = 0 ;
658  std::vector<int> recHitFlagsToBeExcluded ;
659  std::vector<int> recHitSeverityToBeExcluded ;
660  if (detector==EcalBarrel)
661  {
662  recHits = eventData_->barrelRecHits.product() ;
663  recHitFlagsToBeExcluded = generalData_->recHitsCfg.recHitFlagsToBeExcludedBarrel ;
664  recHitSeverityToBeExcluded = generalData_->recHitsCfg.recHitSeverityToBeExcludedBarrel ;
665  }
666  else
667  {
668  recHits = eventData_->endcapRecHits.product() ;
669  recHitFlagsToBeExcluded = generalData_->recHitsCfg.recHitFlagsToBeExcludedEndcaps ;
670  recHitSeverityToBeExcluded = generalData_->recHitsCfg.recHitSeverityToBeExcludedEndcaps ;
671  }
672 
673  std::vector<float> covariances = noZS::EcalClusterTools::covariances(seedCluster,recHits,topology,geometry) ;
674  std::vector<float> localCovariances = noZS::EcalClusterTools::localCovariances(seedCluster,recHits,topology) ;
675  showerShape.sigmaEtaEta = sqrt(covariances[0]) ;
676  showerShape.sigmaIetaIeta = sqrt(localCovariances[0]) ;
677  if (!edm::isNotFinite(localCovariances[2])) showerShape.sigmaIphiIphi = sqrt(localCovariances[2]) ;
678  showerShape.e1x5 = noZS::EcalClusterTools::e1x5(seedCluster,recHits,topology) ;
679  showerShape.e2x5Max = noZS::EcalClusterTools::e2x5Max(seedCluster,recHits,topology) ;
680  showerShape.e5x5 = noZS::EcalClusterTools::e5x5(seedCluster,recHits,topology) ;
681  showerShape.r9 = noZS::EcalClusterTools::e3x3(seedCluster,recHits,topology)/theClus->rawEnergy() ;
682 
683  if (pflow)
684  {
685  showerShape.hcalDepth1OverEcal = generalData_->hcalHelperPflow->hcalESumDepth1(*theClus)/theClus->energy() ;
686  showerShape.hcalDepth2OverEcal = generalData_->hcalHelperPflow->hcalESumDepth2(*theClus)/theClus->energy() ;
690  }
691  else
692  {
693  showerShape.hcalDepth1OverEcal = generalData_->hcalHelper->hcalESumDepth1(*theClus)/theClus->energy() ;
694  showerShape.hcalDepth2OverEcal = generalData_->hcalHelper->hcalESumDepth2(*theClus)/theClus->energy() ;
698  }
699 
700  // extra shower shapes
701  const float see_by_spp = showerShape.sigmaIetaIeta*showerShape.sigmaIphiIphi;
702  if( see_by_spp > 0 ) {
703  showerShape.sigmaIetaIphi = localCovariances[1] / see_by_spp;
704  } else if ( localCovariances[1] > 0 ) {
705  showerShape.sigmaIetaIphi = 1.f;
706  } else {
707  showerShape.sigmaIetaIphi = -1.f;
708  }
709  showerShape.eMax = noZS::EcalClusterTools::eMax(seedCluster,recHits);
710  showerShape.e2nd = noZS::EcalClusterTools::e2nd(seedCluster,recHits);
711  showerShape.eTop = noZS::EcalClusterTools::eTop(seedCluster,recHits,topology);
712  showerShape.eLeft = noZS::EcalClusterTools::eLeft(seedCluster,recHits,topology);
713  showerShape.eRight = noZS::EcalClusterTools::eRight(seedCluster,recHits,topology);
714  showerShape.eBottom = noZS::EcalClusterTools::eBottom(seedCluster,recHits,topology);
715 
716  showerShape.e2x5Left = noZS::EcalClusterTools::e2x5Left(seedCluster,recHits,topology);
717  showerShape.e2x5Right = noZS::EcalClusterTools::e2x5Right(seedCluster,recHits,topology);
718  showerShape.e2x5Top = noZS::EcalClusterTools::e2x5Top(seedCluster,recHits,topology);
719  showerShape.e2x5Bottom = noZS::EcalClusterTools::e2x5Bottom(seedCluster,recHits,topology);
720 
721  }
ElectronHcalHelper * hcalHelperPflow
GeneralData * generalData_
static float e2x5Bottom(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static std::vector< float > covariances(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, const CaloGeometry *geometry, float w0=4.7)
CaloTopology const * topology(0)
static float eMax(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)
const EcalRecHitsConfiguration recHitsCfg
EventSetupData * eventSetupData_
edm::Handle< EcalRecHitCollection > endcapRecHits
double hcalESumDepth2BehindClusters(const std::vector< CaloTowerDetId > &towers)
std::vector< CaloTowerDetId > hcalTowersBehindClusters(const reco::SuperCluster &sc)
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:195
double hcalESumDepth1BehindClusters(const std::vector< CaloTowerDetId > &towers)
edm::ESHandle< CaloTopology > caloTopo
static float e2x5Top(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
bool isNotFinite(T x)
Definition: isFinite.h:10
T sqrt(T t)
Definition: SSEVec.h:18
edm::Handle< EcalRecHitCollection > barrelRecHits
static float e2nd(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits)
std::vector< CaloTowerDetId > hcalTowersBehindClusters
Definition: GsfElectron.h:396
static float e2x5Max(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
double hcalESumDepth2(const reco::SuperCluster &, const std::vector< CaloTowerDetId > *excludeTowers=0)
static float eBottom(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float e2x5Right(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
ElectronHcalHelper * hcalHelper
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
static float eTop(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
Definition: DetId.h:18
static float e2x5Left(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
edm::ESHandle< CaloGeometry > caloGeom
double hcalESumDepth1(const reco::SuperCluster &, const std::vector< CaloTowerDetId > *excludeTowers=0)
static float eRight(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
EventData * eventData_
static float e3x3(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
T const * product() const
Definition: ESHandle.h:86
static float eLeft(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static std::vector< float > localCovariances(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology, float w0=4.7)
static float e1x5(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
static float e5x5(const reco::BasicCluster &cluster, const EcalRecHitCollection *recHits, const CaloTopology *topology)
void GsfElectronAlgo::checkSetup ( const edm::EventSetup es)

Definition at line 756 of file GsfElectronAlgo.cc.

References edm::eventsetup::EventSetupRecord::cacheIdentifier(), GsfElectronAlgo::EventSetupData::cacheIDGeom, GsfElectronAlgo::EventSetupData::cacheIDMagField, GsfElectronAlgo::EventSetupData::cacheIDTDGeom, GsfElectronAlgo::EventSetupData::cacheIDTopo, GsfElectronAlgo::EventSetupData::cacheSevLevel, GsfElectronAlgo::EventSetupData::caloGeom, GsfElectronAlgo::EventSetupData::caloTopo, ElectronHcalHelper::checkSetup(), RegressionHelper::checkSetup(), GsfElectronAlgo::EventSetupData::constraintAtVtx, GsfElectronAlgo::GeneralData::crackCorrectionFunction, eventSetupData_, generalData_, edm::EventSetup::get(), GsfElectronAlgo::GeneralData::hcalHelper, GsfElectronAlgo::GeneralData::hcalHelperPflow, EcalClusterFunctionBaseClass::init(), GsfElectronAlgo::EventSetupData::magField, GsfElectronAlgo::EventSetupData::mtsTransform, edm::ESHandle< T >::product(), GsfElectronAlgo::GeneralData::regHelper, GsfElectronAlgo::EventSetupData::sevLevel, GsfElectronAlgo::GeneralData::strategyCfg, GsfElectronAlgo::GeneralData::superClusterErrorFunction, GsfElectronAlgo::EventSetupData::trackerHandle, GsfElectronAlgo::StrategyConfiguration::useCombinationRegression, and GsfElectronAlgo::StrategyConfiguration::useEcalRegression.

Referenced by GsfElectronBaseProducer::beginEvent().

757  {
758  // get EventSetupRecords if needed
759  bool updateField(false);
761  updateField = true;
764  }
765 
766  bool updateGeometry(false);
768  updateGeometry = true;
771  }
772 
773  if ( updateField || updateGeometry ) {
774  delete eventSetupData_->mtsTransform ;
778  }
779 
781  eventSetupData_->cacheIDGeom=es.get<CaloGeometryRecord>().cacheIdentifier();
783  }
784 
786  eventSetupData_->cacheIDTopo=es.get<CaloTopologyRecord>().cacheIdentifier();
788  }
789 
794 
795 
800 
801  //if(eventSetupData_->cacheChStatus!=es.get<EcalChannelStatusRcd>().cacheIdentifier()){
802  // eventSetupData_->cacheChStatus=es.get<EcalChannelStatusRcd>().cacheIdentifier();
803  // es.get<EcalChannelStatusRcd>().get(eventSetupData_->chStatus);
804  //}
805 
807  eventSetupData_->cacheSevLevel = es.get<EcalSeverityLevelAlgoRcd>().cacheIdentifier();
809  }
810  }
ElectronHcalHelper * hcalHelperPflow
unsigned long long cacheIdentifier() const
GeneralData * generalData_
EventSetupData * eventSetupData_
void checkSetup(const edm::EventSetup &)
edm::ESHandle< EcalSeverityLevelAlgo > sevLevel
const StrategyConfiguration strategyCfg
edm::ESHandle< CaloTopology > caloTopo
GsfConstraintAtVertex * constraintAtVtx
const MultiTrajectoryStateTransform * mtsTransform
ElectronHcalHelper * hcalHelper
edm::ESHandle< MagneticField > magField
EcalClusterFunctionBaseClass * superClusterErrorFunction
const T & get() const
Definition: EventSetup.h:56
edm::ESHandle< CaloGeometry > caloGeom
EcalClusterFunctionBaseClass * crackCorrectionFunction
RegressionHelper * regHelper
edm::ESHandle< TrackerGeometry > trackerHandle
virtual void init(const edm::EventSetup &es)=0
T const * product() const
Definition: ESHandle.h:86
void checkSetup(const edm::EventSetup &)
void GsfElectronAlgo::clonePreviousElectrons ( )

Definition at line 990 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::coreElectrons, GsfElectronAlgo::EventData::electrons, eventData_, GsfElectronAlgo::EventData::previousElectrons, and edm::Handle< T >::product().

Referenced by GsfElectronProducer::produce().

991  {
992  const GsfElectronCollection * oldElectrons = eventData_->previousElectrons.product() ;
994  GsfElectronCollection::const_iterator oldElectron ;
995  for
996  ( oldElectron = oldElectrons->begin() ;
997  oldElectron != oldElectrons->end() ;
998  ++oldElectron )
999  {
1000  const GsfElectronCoreRef oldCoreRef = oldElectron->core() ;
1001  const GsfTrackRef oldElectronGsfTrackRef = oldCoreRef->gsfTrack() ;
1002  unsigned int icore ;
1003  for ( icore=0 ; icore<newCores->size() ; ++icore )
1004  {
1005  if (oldElectronGsfTrackRef==(*newCores)[icore].gsfTrack())
1006  {
1008  eventData_->electrons->push_back(new GsfElectron(*oldElectron,coreRef)) ;
1009  break ;
1010  }
1011  }
1012  }
1013  }
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
std::vector< GsfElectronCore > GsfElectronCoreCollection
GsfElectronPtrCollection * electrons
edm::Handle< reco::GsfElectronCollection > previousElectrons
T const * product() const
Definition: Handle.h:81
EventData * eventData_
edm::Handle< reco::GsfElectronCoreCollection > coreElectrons
void GsfElectronAlgo::completeElectrons ( const gsfAlgoHelpers::HeavyObjectCache hoc)

Definition at line 947 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::beamspot, GsfElectronAlgo::ElectronData::calculateTSOS(), GsfElectronAlgo::EventSetupData::constraintAtVtx, GsfElectronAlgo::EventData::coreElectrons, createElectron(), electronData_, GsfElectronAlgo::EventData::electrons, eventData_, eventSetupData_, Exception, funct::false, mps_fire::i, edm::Ref< C, T, F >::isNull(), GsfElectronAlgo::EventSetupData::mtsTransform, edm::Handle< T >::product(), and funct::true.

Referenced by GsfElectronEcalDrivenProducer::produce(), GsfElectronProducer::produce(), and GEDGsfElectronProducer::produce().

948  {
949  if (electronData_!=0)
950  { throw cms::Exception("GsfElectronAlgo|InternalError")<<"unexpected electron data" ; }
951 
952  const GsfElectronCoreCollection * coreCollection = eventData_->coreElectrons.product() ;
953  for ( unsigned int i=0 ; i<coreCollection->size() ; ++i )
954  {
955  // check there is no existing electron with this core
957  bool coreFound = false ;
958  GsfElectronPtrCollection::const_iterator itrEle ;
959  for
960  ( itrEle = eventData_->electrons->begin() ;
961  itrEle != eventData_->electrons->end() ;
962  itrEle++ )
963  {
964  if ((*itrEle)->core()==coreRef)
965  {
966  coreFound = true ;
967  break ;
968  }
969  }
970  if (coreFound) continue ;
971 
972  // check there is a super-cluster
973  if (coreRef->superCluster().isNull()) continue ;
974 
975  // prepare internal structure for electron specific data
976  delete electronData_ ;
977  electronData_ = new ElectronData(coreRef,*eventData_->beamspot) ;
978 
979  // calculate and check Trajectory StatesOnSurface....
981 
982  createElectron(hoc) ;
983 
984  } // loop over tracks
985 
986  delete electronData_ ;
987  electronData_ = 0 ;
988  }
EventSetupData * eventSetupData_
void createElectron(const gsfAlgoHelpers::HeavyObjectCache *)
GsfConstraintAtVertex * constraintAtVtx
std::vector< GsfElectronCore > GsfElectronCoreCollection
const MultiTrajectoryStateTransform * mtsTransform
const reco::BeamSpot * beamspot
GsfElectronPtrCollection * electrons
bool isNull() const
Checks for null.
Definition: Ref.h:249
T const * product() const
Definition: Handle.h:81
bool calculateTSOS(const MultiTrajectoryStateTransform *, GsfConstraintAtVertex *)
EventData * eventData_
ElectronData * electronData_
edm::Handle< reco::GsfElectronCoreCollection > coreElectrons
void GsfElectronAlgo::copyElectrons ( reco::GsfElectronCollection outEle)

Definition at line 813 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::electrons, and eventData_.

Referenced by GsfElectronBaseProducer::fillEvent().

814  {
815  GsfElectronPtrCollection::const_iterator it ;
816  for
817  ( it = eventData_->electrons->begin() ;
818  it != eventData_->electrons->end() ;
819  it++ )
820  { outEle.push_back(**it) ; }
821  }
GsfElectronPtrCollection * electrons
EventData * eventData_
void GsfElectronAlgo::createElectron ( const gsfAlgoHelpers::HeavyObjectCache hoc)
private

Definition at line 1284 of file GsfElectronAlgo.cc.

References funct::abs(), RegressionHelper::applyCombinationRegression(), RegressionHelper::applyEcalRegression(), GsfElectronAlgo::EventData::barrelRecHits, GsfElectronAlgo::EventData::beamspot, GsfElectronAlgo::ElectronData::calculateMode(), GsfElectronAlgo::ElectronData::calculateMomentum(), calculateSaturationInfo(), calculateShowerShape(), calculateShowerShape_full5x5(), GsfElectronAlgo::ElectronData::checkCtfTrack(), GetRecoTauVFromDQM_MC_cff::cl, ElectronEnergyCorrector::classBasedParameterizationEnergy(), ElectronEnergyCorrector::classBasedParameterizationUncertainty(), ElectronClassification::classify(), GsfElectronAlgo::ElectronData::computeCharge(), ConversionInfo::conversionPartnerCtfTk(), ConversionInfo::conversionPartnerGsfTk(), reco::GsfElectron::core(), GsfElectronAlgo::ElectronData::coreRef, ElectronMomentumCorrector::correct(), GsfElectronAlgo::GeneralData::crackCorrectionFunction, reco::GsfElectron::ClosestCtfTrack::ctfTrack, GsfElectronAlgo::ElectronData::ctfTrackRef, gedGsfElectronCores_cfi::ctfTracks, GsfElectronAlgo::StrategyConfiguration::ctfTracksCheck, GsfElectronAlgo::EventData::currentCtfTracks, ConversionInfo::dcot(), reco::GsfElectron::ConversionRejection::dcot, reco::GsfElectron::TrackClusterMatching::deltaEtaEleClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaEtaSeedClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaEtaSuperClusterAtVtx, reco::GsfElectron::TrackClusterMatching::deltaPhiEleClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaPhiSeedClusterAtCalo, reco::GsfElectron::TrackClusterMatching::deltaPhiSuperClusterAtVtx, DetId::det(), gamEcalExtractorBlocks_cff::detector, ConversionInfo::dist(), reco::GsfElectron::ConversionRejection::dist, EcalBarrel, GsfElectronAlgo::EventData::ecalBarrelIsol03, GsfElectronAlgo::EventData::ecalBarrelIsol04, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalEnergyFromClassBasedParameterization, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalErrorFromClassBasedParameterization, EcalEndcap, GsfElectronAlgo::EventData::ecalEndcapIsol03, GsfElectronAlgo::EventData::ecalEndcapIsol04, reco::GsfElectron::IsolationVariables::ecalRecHitSumEt, reco::GsfElectron::TrackClusterMatching::eEleClusterOverPout, ele_convert(), reco::GsfElectron::TrackClusterMatching::electronCluster, reco::GsfElectron::electronCluster(), electronData_, GsfElectronAlgo::EventData::electrons, GsfElectronAlgo::ElectronData::eleMom, GsfElectronAlgo::ElectronData::elePos, GsfElectronAlgo::EventData::endcapRecHits, reco::CaloCluster::energy(), reco::GsfElectron::TrackClusterMatching::eSeedClusterOverP, reco::GsfElectron::TrackClusterMatching::eSeedClusterOverPout, reco::GsfElectron::TrackClusterMatching::eSuperClusterOverP, eventData_, eventSetupData_, Exception, ConversionInfo::flag(), reco::GsfElectron::ConversionRejection::flags, DetId::Forward, generalData_, GsfElectronAlgo::ElectronData::getEleBasicCluster(), EgammaRecHitIsolation::getEtSum(), ElectronTkIsolation::getPtTracks(), EgammaTowerIsolation::getTowerEtSum(), EcalClusterFunctionBaseClass::getValue(), GsfElectronAlgo::EventData::hadDepth1Isolation03, GsfElectronAlgo::EventData::hadDepth1Isolation03Bc, GsfElectronAlgo::EventData::hadDepth1Isolation04, GsfElectronAlgo::EventData::hadDepth1Isolation04Bc, GsfElectronAlgo::EventData::hadDepth2Isolation03, GsfElectronAlgo::EventData::hadDepth2Isolation03Bc, GsfElectronAlgo::EventData::hadDepth2Isolation04, GsfElectronAlgo::EventData::hadDepth2Isolation04Bc, DetId::Hcal, reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEt, reco::GsfElectron::IsolationVariables::hcalDepth1TowerSumEtBc, reco::GsfElectron::IsolationVariables::hcalDepth2TowerSumEt, reco::GsfElectron::IsolationVariables::hcalDepth2TowerSumEtBc, reco::GsfElectron::ShowerShape::hcalTowersBehindClusters, reco::CaloCluster::hitsAndFractions(), EBDetId::ietaAbs(), GsfElectronAlgo::ElectronData::innMom, MagneticField::inTesla(), reco::GsfElectron::FiducialFlags::isEB, reco::GsfElectron::FiducialFlags::isEBEEGap, reco::GsfElectron::FiducialFlags::isEBEtaGap, reco::GsfElectron::FiducialFlags::isEBPhiGap, reco::GsfElectron::FiducialFlags::isEE, reco::GsfElectron::FiducialFlags::isEEDeeGap, reco::GsfElectron::FiducialFlags::isEERingGap, EEDetId::isNextToDBoundary(), EBDetId::isNextToEtaBoundary(), EBDetId::isNextToPhiBoundary(), EEDetId::isNextToRingBoundary(), edm::Ref< C, T, F >::isNull(), edm::HandleBase::isValid(), LogTrace, PV3DBase< T, PVType, FrameType >::mag(), GsfElectronAlgo::EventSetupData::magField, reco::GsfElectron::TrackExtrapolations::momentumAtCalo, reco::GsfElectron::TrackExtrapolations::momentumAtEleClus, reco::GsfElectron::TrackExtrapolations::momentumAtVtx, reco::GsfElectron::TrackExtrapolations::momentumAtVtxWithConstraint, reco::GsfElectron::TrackExtrapolations::momentumOut, GsfElectronAlgo::EventSetupData::mtsMode, GsfElectronAlgo::EventSetupData::mtsTransform, or, GsfElectronAlgo::EventData::originalCtfTracks, GsfElectronAlgo::EventData::originalGsfTracks, GsfElectronAlgo::ElectronData::outMom, reco::GsfElectron::p4(), reco::GsfElectron::ConversionRejection::partner, reco::BeamSpot::position(), reco::CaloCluster::position(), reco::GsfElectron::TrackExtrapolations::positionAtCalo, reco::GsfElectron::TrackExtrapolations::positionAtVtx, GsfElectronAlgo::StrategyConfiguration::PreSelectMVA, GsfElectronAlgo::StrategyConfiguration::pureTrackerDrivenEcalErrorFromSimpleParameterization, reco::GsfElectron::ConversionRejection::radius, ConversionInfo::radiusOfConversion(), ElectronClassification::refineWithPflow(), GsfElectronAlgo::GeneralData::regHelper, GsfElectronAlgo::EventData::retreiveOriginalTrackCollections(), SimDataFormats::CaloAnalysis::sc, GsfElectronAlgo::ElectronData::sclMom, GsfElectronAlgo::ElectronData::sclPos, GsfElectronAlgo::ElectronData::seedMom, GsfElectronAlgo::ElectronData::seedPos, gsfAlgoHelpers::HeavyObjectCache::sElectronMVAEstimator, reco::GsfElectron::setCorrectedEcalEnergyError(), setCutBasedPreselectionFlag(), reco::GsfElectron::setIsolation03(), reco::GsfElectron::setIsolation04(), reco::GsfElectron::setP4(), reco::GsfElectron::setPassMvaPreselection(), setPixelMatchInfomation(), reco::GsfElectron::setSuperClusterFbrem(), reco::GsfElectron::setTrackFbrem(), reco::GsfElectron::ClosestCtfTrack::shFracInnerHits, GsfElectronAlgo::ElectronData::shFracInnerHits, ElectronEnergyCorrector::simpleParameterizationUncertainty(), GsfElectronAlgo::GeneralData::strategyCfg, DetId::subdetId(), reco::GsfElectron::superCluster(), GsfElectronAlgo::GeneralData::superClusterErrorFunction, GsfElectronAlgo::ElectronData::superClusterRef, GsfElectronAlgo::EventData::tkIsolation03, GsfElectronAlgo::EventData::tkIsolation04, reco::GsfElectron::IsolationVariables::tkSumPt, funct::true, GsfElectronAlgo::StrategyConfiguration::useCombinationRegression, GsfElectronAlgo::StrategyConfiguration::useEcalRegression, GsfElectronAlgo::EventData::vertices, GsfElectronAlgo::ElectronData::vtxMom, GsfElectronAlgo::ElectronData::vtxMomWithConstraint, GsfElectronAlgo::ElectronData::vtxPos, GsfElectronAlgo::ElectronData::vtxTSOS, and PV3DBase< T, PVType, FrameType >::z().

Referenced by completeElectrons().

1285  {
1286  // eventually check ctf track
1289 
1290  // charge ID
1291  int eleCharge ;
1292  GsfElectron::ChargeInfo eleChargeInfo ;
1293  electronData_->computeCharge(eleCharge,eleChargeInfo) ;
1294 
1295  // electron basic cluster
1297 
1298  // Seed cluster
1299  const reco::CaloCluster & seedCluster = *(electronData_->superClusterRef->seed()) ;
1300 
1301  // seed Xtal
1302  // temporary, till CaloCluster->seed() is made available
1303  DetId seedXtalId = seedCluster.hitsAndFractions()[0].first ;
1304 
1306 
1307 
1308  //====================================================
1309  // Candidate attributes
1310  //====================================================
1311 
1313 
1314 
1315  //====================================================
1316  // Track-Cluster Matching
1317  //====================================================
1318 
1320  tcMatching.electronCluster = elbcRef ;
1321  tcMatching.eSuperClusterOverP = (electronData_->vtxMom.mag()>0)?(electronData_->superClusterRef->energy()/electronData_->vtxMom.mag()):(-1.) ;
1322  tcMatching.eSeedClusterOverP = (electronData_->vtxMom.mag()>0.)?(seedCluster.energy()/electronData_->vtxMom.mag()):(-1) ;
1323  tcMatching.eSeedClusterOverPout = (electronData_->seedMom.mag()>0.)?(seedCluster.energy()/electronData_->seedMom.mag()):(-1.) ;
1324  tcMatching.eEleClusterOverPout = (electronData_->eleMom.mag()>0.)?(elbcRef->energy()/electronData_->eleMom.mag()):(-1.) ;
1325 
1327  tcMatching.deltaEtaSuperClusterAtVtx = scAtVtx.dEta() ;
1328  tcMatching.deltaPhiSuperClusterAtVtx = scAtVtx.dPhi() ;
1329 
1330  EleRelPointPair seedAtCalo(seedCluster.position(),electronData_->seedPos,eventData_->beamspot->position()) ;
1331  tcMatching.deltaEtaSeedClusterAtCalo = seedAtCalo.dEta() ;
1332  tcMatching.deltaPhiSeedClusterAtCalo = seedAtCalo.dPhi() ;
1333 
1335  tcMatching.deltaEtaEleClusterAtCalo = ecAtCalo.dEta() ;
1336  tcMatching.deltaPhiEleClusterAtCalo = ecAtCalo.dPhi() ;
1337 
1338 
1339  //=======================================================
1340  // Track extrapolations
1341  //=======================================================
1342 
1351 
1352 
1353  //=======================================================
1354  // Closest Ctf Track
1355  //=======================================================
1356 
1358  ctfInfo.ctfTrack = electronData_->ctfTrackRef ;
1360 
1361 
1362  //====================================================
1363  // FiducialFlags, using nextToBoundary definition of gaps
1364  //====================================================
1365 
1366  reco::GsfElectron::FiducialFlags fiducialFlags ;
1367  int region = seedXtalId.det();
1368  int detector = seedXtalId.subdetId() ;
1369  double feta=std::abs(electronData_->superClusterRef->position().eta()) ;
1370  if (detector==EcalBarrel)
1371  {
1372  fiducialFlags.isEB = true ;
1373  EBDetId ebdetid(seedXtalId);
1374  if (EBDetId::isNextToEtaBoundary(ebdetid))
1375  {
1376  if (ebdetid.ietaAbs()==85)
1377  { fiducialFlags.isEBEEGap = true ; }
1378  else
1379  { fiducialFlags.isEBEtaGap = true ; }
1380  }
1381  if (EBDetId::isNextToPhiBoundary(ebdetid))
1382  { fiducialFlags.isEBPhiGap = true ; }
1383  }
1384  else if (detector==EcalEndcap)
1385  {
1386  fiducialFlags.isEE = true ;
1387  EEDetId eedetid(seedXtalId);
1388  if (EEDetId::isNextToRingBoundary(eedetid))
1389  {
1390  if (std::abs(feta)<2.)
1391  { fiducialFlags.isEBEEGap = true ; }
1392  else
1393  { fiducialFlags.isEERingGap = true ; }
1394  }
1395  if (EEDetId::isNextToDBoundary(eedetid))
1396  { fiducialFlags.isEEDeeGap = true ; }
1397  }
1398  else if ( region==DetId::Forward || region == DetId::Hcal )
1399  {
1400  fiducialFlags.isEE = true ;
1401  //HGCalDetId eeDetid(seedXtalId);
1402  // fill in fiducial information when we know how to use it...
1403  }
1404  else
1405  { throw cms::Exception("GsfElectronAlgo|UnknownXtalRegion")<<"createElectron(): do not know if it is a barrel or endcap seed cluster !!!!" ; }
1406 
1407 
1408  //====================================================
1409  // SaturationInfo
1410  //====================================================
1411 
1412  reco::GsfElectron::SaturationInfo saturationInfo;
1414 
1415  //====================================================
1416  // ShowerShape
1417  //====================================================
1418 
1419  reco::GsfElectron::ShowerShape showerShape;
1420  reco::GsfElectron::ShowerShape full5x5_showerShape;
1421  if( !(region==DetId::Forward || region == DetId::Hcal) ) {
1422  calculateShowerShape(electronData_->superClusterRef,!(electronData_->coreRef->ecalDrivenSeed()),showerShape) ;
1423  calculateShowerShape_full5x5(electronData_->superClusterRef,!(electronData_->coreRef->ecalDrivenSeed()),full5x5_showerShape) ;
1424  }
1425 
1426  //====================================================
1427  // ConversionRejection
1428  //====================================================
1429 
1431 
1432  ConversionFinder conversionFinder ;
1433  double BInTesla = eventSetupData_->magField->inTesla(GlobalPoint(0.,0.,0.)).z() ;
1435  if (!ctfTracks.isValid()) { ctfTracks = eventData_->currentCtfTracks ; }
1436 
1437  // values of conversionInfo.flag()
1438  // -9999 : Partner track was not found
1439  // 0 : Partner track found in the CTF collection using
1440  // 1 : Partner track found in the CTF collection using
1441  // 2 : Partner track found in the GSF collection using
1442  // 3 : Partner track found in the GSF collection using the electron's GSF track
1443  ConversionInfo conversionInfo = conversionFinder.getConversionInfo
1444  (*electronData_->coreRef,ctfTracks,eventData_->originalGsfTracks,BInTesla) ;
1445 
1447  conversionVars.flags = conversionInfo.flag() ;
1448  conversionVars.dist = conversionInfo.dist() ;
1449  conversionVars.dcot = conversionInfo.dcot() ;
1450  conversionVars.radius = conversionInfo.radiusOfConversion() ;
1451  if ((conversionVars.flags==0)or(conversionVars.flags==1))
1452  conversionVars.partner = TrackBaseRef(conversionInfo.conversionPartnerCtfTk()) ;
1453  else if ((conversionVars.flags==2)or(conversionVars.flags==3))
1454  conversionVars.partner = TrackBaseRef(conversionInfo.conversionPartnerGsfTk()) ;
1455 
1456 
1457  //====================================================
1458  // Go !
1459  //====================================================
1460 
1461  GsfElectron * ele = new
1462  GsfElectron
1463  ( eleCharge,eleChargeInfo,electronData_->coreRef,
1464  tcMatching, tkExtra, ctfInfo,
1465  fiducialFlags,showerShape, full5x5_showerShape,
1466  conversionVars, saturationInfo ) ;
1467  // Will be overwritten later in the case of the regression
1469  ele->setP4(GsfElectron::P4_FROM_SUPER_CLUSTER,momentum,0,true) ;
1470 
1471  //====================================================
1472  // brems fractions
1473  //====================================================
1474 
1475  if (electronData_->innMom.mag()>0.)
1477 
1478  // the supercluster is the refined one The seed is not necessarily the first cluster
1479  // hence the use of the electronCluster
1480  SuperClusterRef sc = ele->superCluster() ;
1481  if (!(sc.isNull()))
1482  {
1483  CaloClusterPtr cl = ele->electronCluster() ;
1484  if (sc->clustersSize()>1)
1485  {
1486  float pf_fbrem =( sc->energy() - cl->energy() ) / sc->energy();
1487  ele->setSuperClusterFbrem( pf_fbrem ) ;
1488  }
1489  else
1490  {
1491  ele->setSuperClusterFbrem(0) ;
1492  }
1493  }
1494 
1495  //====================================================
1496  // classification and corrections
1497  //====================================================
1498  // classification
1499  ElectronClassification theClassifier ;
1500  theClassifier.classify(*ele) ;
1501  theClassifier.refineWithPflow(*ele) ;
1502  // ecal energy
1505  {
1510  }
1511  else // original implementation
1512  {
1513  if( region!=DetId::Forward && region != DetId::Hcal ) {
1514  if (ele->core()->ecalDrivenSeed())
1515  {
1517  { theEnCorrector.classBasedParameterizationEnergy(*ele,*eventData_->beamspot) ; }
1519  { theEnCorrector.classBasedParameterizationUncertainty(*ele) ; }
1520  }
1521  else
1522  {
1524  { theEnCorrector.simpleParameterizationUncertainty(*ele) ; }
1525  }
1526  }
1527  }
1528 
1529  // momentum
1530  // Keep the default correction running first. The track momentum error is computed in there
1531  if (ele->core()->ecalDrivenSeed())
1532  {
1533  ElectronMomentumCorrector theMomCorrector;
1534  theMomCorrector.correct(*ele,electronData_->vtxTSOS);
1535  }
1537  {
1539  }
1540 
1541  //====================================================
1542  // now isolation variables
1543  //====================================================
1544 
1548  if( !(region==DetId::Forward || region == DetId::Hcal) ) {
1561  }
1562  ele->setIsolation03(dr03);
1563  ele->setIsolation04(dr04);
1564 
1565 
1566  //====================================================
1567  // preselection flag
1568  //====================================================
1569 
1571  //setting mva flag, currently GedGsfElectron and GsfElectron pre-selection flags have desynced
1572  //this is for GedGsfElectrons, GsfElectrons (ie old pre 7X std reco) resets this later on
1573  //in the function "addPfInfo"
1574  //yes this is awful, we'll fix it once we work out how to...
1575  float mvaValue = hoc->sElectronMVAEstimator->mva( *(ele),*(eventData_->vertices));
1577 
1578  //====================================================
1579  // Pixel match variables
1580  //====================================================
1582 
1583  LogTrace("GsfElectronAlgo")<<"Constructed new electron with energy "<< ele->p4().e() ;
1584 
1585  eventData_->electrons->push_back(ele) ;
1586  }
CaloClusterPtr electronCluster() const
Definition: GsfElectron.h:244
void setPixelMatchInfomation(reco::GsfElectron *)
edm::Handle< reco::TrackCollection > originalCtfTracks
const MultiTrajectoryStateMode * mtsMode
const math::XYZPoint & position() const
cluster centroid position
Definition: CaloCluster.h:129
void applyCombinationRegression(reco::GsfElectron &ele) const
void setTrackFbrem(float fbrem)
Definition: GsfElectron.h:753
std::unique_ptr< const SoftElectronMVAEstimator > sElectronMVAEstimator
void setP4(P4Kind kind, const LorentzVector &p4, float p4Error, bool setCandidate)
Definition: GsfElectron.cc:199
GeneralData * generalData_
static bool isNextToEtaBoundary(EBDetId id)
Definition: EBDetId.cc:125
EgammaTowerIsolation * hadDepth1Isolation04Bc
reco::GsfTrackRef conversionPartnerGsfTk() const
EgammaTowerIsolation * hadDepth1Isolation03Bc
double radiusOfConversion() const
const LorentzVector & p4(P4Kind kind) const
Definition: GsfElectron.cc:225
void retreiveOriginalTrackCollections(const reco::TrackRef &, const reco::GsfTrackRef &)
double getEtSum(const reco::Candidate *emObject) const
void calculateShowerShape(const reco::SuperClusterRef &, bool pflow, reco::GsfElectron::ShowerShape &)
EventSetupData * eventSetupData_
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
edm::Handle< EcalRecHitCollection > endcapRecHits
double dist() const
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:195
void computeCharge(int &charge, reco::GsfElectron::ChargeInfo &info)
void checkCtfTrack(edm::Handle< reco::TrackCollection > currentCtfTracks)
EgammaTowerIsolation * hadDepth1Isolation03
const StrategyConfiguration strategyCfg
reco::TrackRef conversionPartnerCtfTk() const
void setSuperClusterFbrem(float fbrem)
Definition: GsfElectron.h:754
EgammaRecHitIsolation * ecalBarrelIsol04
EgammaTowerIsolation * hadDepth2Isolation03
EgammaTowerIsolation * hadDepth1Isolation04
ElectronTkIsolation * tkIsolation03
virtual float getValue(const reco::BasicCluster &, const EcalRecHitCollection &) const =0
void setCorrectedEcalEnergyError(float newEnergyError)
Definition: GsfElectron.cc:179
T mag() const
Definition: PV3DBase.h:67
void calculateShowerShape_full5x5(const reco::SuperClusterRef &, bool pflow, reco::GsfElectron::ShowerShape &)
void setCutBasedPreselectionFlag(reco::GsfElectron *ele, const reco::BeamSpot &)
edm::RefToBase< reco::Track > TrackBaseRef
persistent reference to a Track, using views
Definition: TrackFwd.h:32
EgammaRecHitIsolation * ecalEndcapIsol03
EgammaTowerIsolation * hadDepth2Isolation03Bc
virtual SuperClusterRef superCluster() const
reference to a SuperCluster
Definition: GsfElectron.h:184
static bool isNextToPhiBoundary(EBDetId id)
Definition: EBDetId.cc:130
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::Handle< EcalRecHitCollection > barrelRecHits
T z() const
Definition: PV3DBase.h:64
void correct(reco::GsfElectron &, TrajectoryStateOnSurface &)
void setPassMvaPreselection(bool flag)
Definition: GsfElectron.h:713
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
std::vector< CaloTowerDetId > hcalTowersBehindClusters
Definition: GsfElectron.h:396
const MultiTrajectoryStateTransform * mtsTransform
static bool isNextToRingBoundary(EEDetId id)
Definition: EEDetId.cc:375
double energy() const
cluster energy
Definition: CaloCluster.h:124
const reco::BeamSpot * beamspot
edm::ESHandle< MagneticField > magField
GsfElectronPtrCollection * electrons
CaloClusterPtr getEleBasicCluster(const MultiTrajectoryStateTransform *)
static bool isNextToDBoundary(EEDetId id)
Definition: EEDetId.cc:367
bool isValid() const
Definition: HandleBase.h:74
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:37
bool isNull() const
Checks for null.
Definition: Ref.h:249
void setIsolation04(const IsolationVariables &dr04)
Definition: GsfElectron.h:570
#define LogTrace(id)
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
void classify(reco::GsfElectron &)
EgammaTowerIsolation * hadDepth2Isolation04Bc
Definition: DetId.h:18
edm::Handle< reco::VertexCollection > vertices
EgammaRecHitIsolation * ecalBarrelIsol03
int flag() const
void calculateSaturationInfo(const reco::SuperClusterRef &, reco::GsfElectron::SaturationInfo &)
EcalClusterFunctionBaseClass * superClusterErrorFunction
void ele_convert(const Type1 &obj1, Type2 &obj2)
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Candidate.h:37
virtual GsfElectronCoreRef core() const
Definition: GsfElectron.cc:8
math::XYZVectorF momentumAtVtxWithConstraint
Definition: GsfElectron.h:285
double getPtTracks(const reco::GsfElectron *) const
void refineWithPflow(reco::GsfElectron &)
void setIsolation03(const IsolationVariables &dr03)
Definition: GsfElectron.h:569
edm::Handle< reco::GsfTrackCollection > originalGsfTracks
void applyEcalRegression(reco::GsfElectron &electron, const edm::Handle< reco::VertexCollection > &vertices, const edm::Handle< EcalRecHitCollection > &rechitsEB, const edm::Handle< EcalRecHitCollection > &rechitsEE) const
EgammaTowerIsolation * hadDepth2Isolation04
const reco::GsfElectronCoreRef coreRef
edm::Handle< reco::TrackCollection > currentCtfTracks
double getTowerEtSum(const reco::Candidate *cand, const std::vector< CaloTowerDetId > *detIdToExclude=0) const
EcalClusterFunctionBaseClass * crackCorrectionFunction
EgammaRecHitIsolation * ecalEndcapIsol04
const reco::SuperClusterRef superClusterRef
const Point & position() const
position
Definition: BeamSpot.h:62
EventData * eventData_
double dcot() const
RegressionHelper * regHelper
ElectronTkIsolation * tkIsolation04
ElectronData * electronData_
Detector det() const
get the detector field from this detid
Definition: DetId.h:35
void calculateMode(const MultiTrajectoryStateMode *mtsMode)
TrajectoryStateOnSurface vtxTSOS
Candidate::LorentzVector calculateMomentum()
void GsfElectronAlgo::displayInternalElectrons ( const std::string &  title) const

Definition at line 933 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::electrons, GsfElectronAlgo::EventData::event, eventData_, edm::EventBase::id(), and LogTrace.

Referenced by GsfElectronBaseProducer::fillEvent().

934  {
935  LogTrace("GsfElectronAlgo") << "========== " << title << " ==========";
936  LogTrace("GsfElectronAlgo") << "Event: " << eventData_->event->id();
937  LogTrace("GsfElectronAlgo") << "Number of electrons: " << eventData_->electrons->size() ;
938  GsfElectronPtrCollection::const_iterator it ;
939  for ( it = eventData_->electrons->begin(); it != eventData_->electrons->end(); it++ )
940  {
941  LogTrace("GsfElectronAlgo") << "Electron with charge, pt, eta, phi: " << (*it)->charge() << " , "
942  << (*it)->pt() << " , " << (*it)->eta() << " , " << (*it)->phi();
943  }
944  LogTrace("GsfElectronAlgo") << "=================================================";
945  }
GsfElectronPtrCollection * electrons
#define LogTrace(id)
edm::EventID id() const
Definition: EventBase.h:60
EventData * eventData_
void GsfElectronAlgo::endEvent ( )

Definition at line 925 of file GsfElectronAlgo.cc.

References eventData_, and Exception.

Referenced by GsfElectronBaseProducer::endEvent().

926  {
927  if (eventData_==0)
928  { throw cms::Exception("GsfElectronAlgo|InternalError")<<"lacking event data" ; }
929  delete eventData_ ;
930  eventData_ = 0 ;
931  }
EventData * eventData_
const reco::SuperClusterRef GsfElectronAlgo::getTrSuperCluster ( const reco::GsfTrackRef trackRef)
private
bool GsfElectronAlgo::isPreselected ( reco::GsfElectron ele)
private

Definition at line 1106 of file GsfElectronAlgo.cc.

References reco::GsfElectron::ecalDrivenSeed(), GsfElectronAlgo::StrategyConfiguration::gedElectronMode, generalData_, GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA, reco::GsfElectron::passingCutBasedPreselection(), reco::GsfElectron::passingMvaPreselection(), reco::GsfElectron::passingPflowPreselection(), reco::LeafCandidate::pt(), and GsfElectronAlgo::GeneralData::strategyCfg.

Referenced by removeNotPreselectedElectrons(), and setAmbiguityData().

1107  {
1108  bool passCutBased=ele->passingCutBasedPreselection();
1109  bool passPF=ele->passingPflowPreselection(); //it is worth nothing for gedGsfElectrons, this does nothing as its not set till GedGsfElectron finaliser, this is always false
1111  bool passmva=ele->passingMvaPreselection();
1112  if(!ele->ecalDrivenSeed()){
1114  return passmva && passCutBased;
1115  else
1116  return passmva;
1117  }
1118  else{
1119  return passCutBased || passPF || passmva;
1120  }
1121  }
1122  else{
1123  return passCutBased || passPF;
1124  }
1125 
1126  return true;
1127  }
virtual double pt() const final
transverse momentum
GeneralData * generalData_
bool passingCutBasedPreselection() const
Definition: GsfElectron.h:698
bool passingMvaPreselection() const
Definition: GsfElectron.h:714
const StrategyConfiguration strategyCfg
bool ecalDrivenSeed() const
Definition: GsfElectron.h:188
bool passingPflowPreselection() const
Definition: GsfElectron.h:699
void GsfElectronAlgo::removeAmbiguousElectrons ( )

Definition at line 1718 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::electrons, eventData_, and LogTrace.

Referenced by GsfElectronBaseProducer::fillEvent().

1719  {
1720  GsfElectronPtrCollection::size_type ei = 1, emax = eventData_->electrons->size() ;
1721  GsfElectronPtrCollection::iterator eitr = eventData_->electrons->begin() ;
1722  while (eitr!=eventData_->electrons->end())
1723  {
1724  LogTrace("GsfElectronAlgo")<<"========== remove ambiguous "<<ei<<"/"<<emax<<"==========" ;
1725  if ((*eitr)->ambiguous())
1726  { delete (*eitr) ; eitr = eventData_->electrons->erase(eitr) ; ++ei ; }
1727  else
1728  { ++eitr ; ++ei ; }
1729  }
1730  }
uint16_t size_type
GsfElectronPtrCollection * electrons
#define LogTrace(id)
EventData * eventData_
void GsfElectronAlgo::removeNotPreselectedElectrons ( )

Definition at line 1129 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::electrons, eventData_, isPreselected(), and LogTrace.

Referenced by GsfElectronBaseProducer::fillEvent().

1130  {
1131  GsfElectronPtrCollection::size_type ei = 1, emax = eventData_->electrons->size() ;
1132  GsfElectronPtrCollection::iterator eitr = eventData_->electrons->begin() ;
1133  while (eitr!=eventData_->electrons->end())
1134  {
1135  LogTrace("GsfElectronAlgo")<<"========== removed not preselected "<<ei<<"/"<<emax<<"==========" ;
1136  if (isPreselected(*eitr))
1137  { ++eitr ; ++ei ; }
1138  else
1139  { delete (*eitr) ; eitr = eventData_->electrons->erase(eitr) ; ++ei ; }
1140  }
1141  }
bool isPreselected(reco::GsfElectron *ele)
uint16_t size_type
GsfElectronPtrCollection * electrons
#define LogTrace(id)
EventData * eventData_
void GsfElectronAlgo::setAmbiguityData ( bool  ignoreNotPreselected = true)

Definition at line 1596 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::EventData::barrelRecHits, GsfElectronAlgo::EventData::beamspot, reco::e1, reco::e2, GsfElectronAlgo::EventData::electrons, photonPostprocessing_cfi::eMin, GsfElectronAlgo::EventData::endcapRecHits, stringResolutionProvider_cfi::eta, eventData_, eventSetupData_, Exception, funct::false, runEdmFileComparison::found, generalData_, edm::Ref< C, T, F >::get(), GsfElectronAlgo::EventData::gsfPfRecTracks, EgAmbiguityTools::isBetter(), isPreselected(), LogDebug, reco::BeamSpot::position(), edm::Handle< T >::product(), EgAmbiguityTools::sharedEnergy(), GsfElectronAlgo::GeneralData::strategyCfg, ctppsDiamondLocalTracks_cfi::threshold, GsfElectronAlgo::EventSetupData::trackerHandle, funct::true, and GsfElectronAlgo::StrategyConfiguration::useGsfPfRecTracks.

Referenced by GsfElectronBaseProducer::fillEvent().

1597  {
1598  GsfElectronPtrCollection::iterator e1, e2 ;
1603  else
1604  { throw cms::Exception("GsfElectronAlgo|UnknownAmbiguitySortingStrategy")<<"value of generalData_->strategyCfg.ambSortingStrategy is : "<<generalData_->strategyCfg.ambSortingStrategy ; }
1605 
1606  // init
1607  for
1608  ( e1 = eventData_->electrons->begin() ;
1609  e1 != eventData_->electrons->end() ;
1610  ++e1 )
1611  {
1612  (*e1)->clearAmbiguousGsfTracks() ;
1613  (*e1)->setAmbiguous(false) ;
1614  }
1615 
1616  // get ambiguous from GsfPfRecTracks
1618  {
1619  for
1620  ( e1 = eventData_->electrons->begin() ;
1621  e1 != eventData_->electrons->end() ;
1622  ++e1 )
1623  {
1624  bool found = false ;
1625  const GsfPFRecTrackCollection * gsfPfRecTrackCollection = eventData_->gsfPfRecTracks.product() ;
1626  GsfPFRecTrackCollection::const_iterator gsfPfRecTrack ;
1627  for ( gsfPfRecTrack=gsfPfRecTrackCollection->begin() ;
1628  gsfPfRecTrack!=gsfPfRecTrackCollection->end() ;
1629  ++gsfPfRecTrack )
1630  {
1631  if (gsfPfRecTrack->gsfTrackRef()==(*e1)->gsfTrack())
1632  {
1633  if (found)
1634  {
1635  edm::LogWarning("GsfElectronAlgo")<<"associated gsfPfRecTrack already found" ;
1636  }
1637  else
1638  {
1639  found = true ;
1640  const std::vector<reco::GsfPFRecTrackRef> & duplicates(gsfPfRecTrack->convBremGsfPFRecTrackRef()) ;
1641  std::vector<reco::GsfPFRecTrackRef>::const_iterator duplicate ;
1642  for ( duplicate = duplicates.begin() ; duplicate != duplicates.end() ; duplicate ++ )
1643  { (*e1)->addAmbiguousGsfTrack((*duplicate)->gsfTrackRef()) ; }
1644  }
1645  }
1646  }
1647  }
1648  }
1649  // or search overlapping clusters
1650  else
1651  {
1652  for
1653  ( e1 = eventData_->electrons->begin() ;
1654  e1 != eventData_->electrons->end() ;
1655  ++e1 )
1656  {
1657  if ((*e1)->ambiguous()) continue ;
1658  if ( ignoreNotPreselected && !isPreselected(*e1) ) continue ;
1659 
1660  SuperClusterRef scRef1 = (*e1)->superCluster();
1661  CaloClusterPtr eleClu1 = (*e1)->electronCluster();
1662  LogDebug("GsfElectronAlgo")
1663  << "Blessing electron with E/P " << (*e1)->eSuperClusterOverP()
1664  << ", cluster " << scRef1.get()
1665  << " & track " << (*e1)->gsfTrack().get() ;
1666 
1667  for
1668  ( e2 = e1, ++e2 ;
1669  e2 != eventData_->electrons->end() ;
1670  ++e2 )
1671  {
1672  if ((*e2)->ambiguous()) continue ;
1673  if ( ignoreNotPreselected && !isPreselected(*e2) ) continue ;
1674 
1675  SuperClusterRef scRef2 = (*e2)->superCluster();
1676  CaloClusterPtr eleClu2 = (*e2)->electronCluster();
1677 
1678  // search if same cluster
1679  bool sameCluster = false ;
1681  { sameCluster = (scRef1==scRef2) ; }
1683  {
1684  float eMin = 1. ;
1685  float threshold = eMin*cosh(EleRelPoint(scRef1->position(),eventData_->beamspot->position()).eta()) ;
1686  sameCluster =
1688  (EgAmbiguityTools::sharedEnergy(&(*scRef1->seed()),&(*eleClu2),eventData_->barrelRecHits,eventData_->endcapRecHits)>=threshold) ||
1690  (EgAmbiguityTools::sharedEnergy(&(*scRef1->seed()),&(*scRef2->seed()),eventData_->barrelRecHits,eventData_->endcapRecHits)>=threshold) ) ;
1691  }
1692  else
1693  { throw cms::Exception("GsfElectronAlgo|UnknownAmbiguityClustersOverlapStrategy")<<"value of generalData_->strategyCfg.ambClustersOverlapStrategy is : "<<generalData_->strategyCfg.ambClustersOverlapStrategy ; }
1694 
1695  // main instructions
1696  if (sameCluster)
1697  {
1698  LogDebug("GsfElectronAlgo")
1699  << "Discarding electron with E/P " << (*e2)->eSuperClusterOverP()
1700  << ", cluster " << scRef2.get()
1701  << " and track " << (*e2)->gsfTrack().get() ;
1702  (*e1)->addAmbiguousGsfTrack((*e2)->gsfTrack()) ;
1703  (*e2)->setAmbiguous(true) ;
1704  }
1705  else if ((*e1)->gsfTrack()==(*e2)->gsfTrack())
1706  {
1707  edm::LogWarning("GsfElectronAlgo")
1708  << "Forgetting electron with E/P " << (*e2)->eSuperClusterOverP()
1709  << ", cluster " << scRef2.get()
1710  << " and track " << (*e2)->gsfTrack().get() ;
1711  (*e2)->setAmbiguous(true) ;
1712  }
1713  }
1714  }
1715  }
1716  }
#define LogDebug(id)
bool isPreselected(reco::GsfElectron *ele)
GeneralData * generalData_
bool isBetter(const reco::GsfElectron *, const reco::GsfElectron *)
EventSetupData * eventSetupData_
edm::Handle< EcalRecHitCollection > endcapRecHits
const StrategyConfiguration strategyCfg
std::vector< GsfPFRecTrack > GsfPFRecTrackCollection
collection of GsfPFRecTrack objects
float sharedEnergy(const reco::CaloCluster *, const reco::CaloCluster *, edm::Handle< EcalRecHitCollection > &barrelRecHits, edm::Handle< EcalRecHitCollection > &endcapRecHits)
edm::Handle< EcalRecHitCollection > barrelRecHits
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:244
const reco::BeamSpot * beamspot
GsfElectronPtrCollection * electrons
Float e1
Definition: deltaR.h:20
T const * product() const
Definition: Handle.h:81
Float e2
Definition: deltaR.h:21
const Point & position() const
position
Definition: BeamSpot.h:62
EventData * eventData_
edm::ESHandle< TrackerGeometry > trackerHandle
edm::Handle< reco::GsfPFRecTrackCollection > gsfPfRecTracks
void GsfElectronAlgo::setCutBasedPreselectionFlag ( reco::GsfElectron ele,
const reco::BeamSpot bs 
)
private

Definition at line 1144 of file GsfElectronAlgo.cc.

References funct::abs(), edm::RefToBase< T >::castTo(), looper::cfg, reco::GsfElectron::core(), GsfElectronAlgo::GeneralData::cutsCfg, GsfElectronAlgo::GeneralData::cutsCfgPflow, reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), gamEcalExtractorBlocks_cff::detector, EcalBarrel, EcalEndcap, reco::GsfElectron::eSuperClusterOverP(), stringResolutionProvider_cfi::eta, Exception, funct::false, GsfElectronAlgo::StrategyConfiguration::gedElectronMode, generalData_, reco::GsfElectron::gsfTrack(), reco::GsfElectron::hcalDepth1OverEcal(), reco::GsfElectron::hcalDepth2OverEcal(), reco::GsfElectron::hcalOverEcal(), reco::CaloCluster::hitsAndFractions(), GsfElectronAlgo::CutsConfiguration::isBarrel, reco::GsfElectron::isEB(), reco::GsfElectron::isEBEEGap(), reco::GsfElectron::isEBEtaGap(), reco::GsfElectron::isEBPhiGap(), reco::GsfElectron::isEE(), reco::GsfElectron::isEEDeeGap(), reco::GsfElectron::isEERingGap(), GsfElectronAlgo::CutsConfiguration::isEndcaps, GsfElectronAlgo::CutsConfiguration::isFiducial, edm::Ref< C, T, F >::isNull(), LogTrace, GsfElectronAlgo::CutsConfiguration::maxDeltaEtaBarrel, GsfElectronAlgo::CutsConfiguration::maxDeltaEtaEndcaps, GsfElectronAlgo::CutsConfiguration::maxDeltaPhiBarrel, GsfElectronAlgo::CutsConfiguration::maxDeltaPhiEndcaps, GsfElectronAlgo::CutsConfiguration::maxEOverPBarrel, GsfElectronAlgo::CutsConfiguration::maxEOverPEndcaps, ecalDrivenElectronSeedsParameters_cff::maxHBarrel, ecalDrivenElectronSeedsParameters_cff::maxHEndcaps, GsfElectronAlgo::CutsConfiguration::maxHOverEBarrel, GsfElectronAlgo::CutsConfiguration::maxHOverEEndcaps, GsfElectronAlgo::CutsConfiguration::maxSigmaIetaIetaBarrel, GsfElectronAlgo::CutsConfiguration::maxSigmaIetaIetaEndcaps, GsfElectronAlgo::CutsConfiguration::maxTIP, GsfElectronAlgo::CutsConfiguration::minEOverPBarrel, GsfElectronAlgo::CutsConfiguration::minEOverPEndcaps, GsfElectronAlgo::CutsConfiguration::minSCEtBarrel, GsfElectronAlgo::CutsConfiguration::minSCEtEndcaps, packedPFCandidateRefMixer_cfi::pf, reco::BeamSpot::position(), reco::return(), SurveyInfoScenario_cff::seed, GsfElectronAlgo::CutsConfiguration::seedFromTEC, reco::GsfElectron::setPassCutBasedPreselection(), reco::GsfElectron::sigmaIetaIeta(), GsfElectronAlgo::GeneralData::strategyCfg, and reco::GsfElectron::superCluster().

Referenced by createElectron().

1145  {
1146  // default value
1147  ele->setPassCutBasedPreselection(false) ;
1148 
1149  // kind of seeding
1150  bool eg = ele->core()->ecalDrivenSeed() ;
1151  bool pf = ele->core()->trackerDrivenSeed() && !ele->core()->ecalDrivenSeed() ;
1152  bool gedMode = generalData_->strategyCfg.gedElectronMode;
1153  if (eg&&pf) { throw cms::Exception("GsfElectronAlgo|BothEcalAndPureTrackerDriven")<<"An electron cannot be both egamma and purely pflow" ; }
1154  if ((!eg)&&(!pf)) { throw cms::Exception("GsfElectronAlgo|NeitherEcalNorPureTrackerDriven")<<"An electron cannot be neither egamma nor purely pflow" ; }
1155 
1156  const CutsConfiguration * cfg = ((eg||gedMode)?&generalData_->cutsCfg:&generalData_->cutsCfgPflow);
1157 
1158  // Et cut
1159  double etaValue = EleRelPoint(ele->superCluster()->position(),bs.position()).eta() ;
1160  double etValue = ele->superCluster()->energy()/cosh(etaValue) ;
1161  LogTrace("GsfElectronAlgo") << "Et : " << etValue ;
1162  if (ele->isEB() && (etValue < cfg->minSCEtBarrel)) return ;
1163  if (ele->isEE() && (etValue < cfg->minSCEtEndcaps)) return ;
1164  LogTrace("GsfElectronAlgo") << "Et criteria are satisfied";
1165 
1166  // E/p cut
1167  double eopValue = ele->eSuperClusterOverP() ;
1168  LogTrace("GsfElectronAlgo") << "E/p : " << eopValue ;
1169  if (ele->isEB() && (eopValue > cfg->maxEOverPBarrel)) return ;
1170  if (ele->isEE() && (eopValue > cfg->maxEOverPEndcaps)) return ;
1171  if (ele->isEB() && (eopValue < cfg->minEOverPBarrel)) return ;
1172  if (ele->isEE() && (eopValue < cfg->minEOverPEndcaps)) return ;
1173  LogTrace("GsfElectronAlgo") << "E/p criteria are satisfied";
1174 
1175  // HoE cuts
1176  LogTrace("GsfElectronAlgo") << "HoE1 : " << ele->hcalDepth1OverEcal() << ", HoE2 : " << ele->hcalDepth2OverEcal();
1177  double had = ele->hcalOverEcal()*ele->superCluster()->energy() ;
1178  const reco::CaloCluster & seedCluster = *(ele->superCluster()->seed()) ;
1179  int detector = seedCluster.hitsAndFractions()[0].first.subdetId() ;
1180  bool HoEveto = false ;
1181  if (detector==EcalBarrel && (had<cfg->maxHBarrel || (had/ele->superCluster()->energy())<cfg->maxHOverEBarrel)) HoEveto=true;
1182  else if (detector==EcalEndcap && (had<cfg->maxHEndcaps || (had/ele->superCluster()->energy())<cfg->maxHOverEEndcaps)) HoEveto=true;
1183  if ( !HoEveto ) return ;
1184  LogTrace("GsfElectronAlgo") << "H/E criteria are satisfied";
1185 
1186  // delta eta criteria
1187  double deta = ele->deltaEtaSuperClusterTrackAtVtx() ;
1188  LogTrace("GsfElectronAlgo") << "delta eta : " << deta ;
1189  if (ele->isEB() && (std::abs(deta) > cfg->maxDeltaEtaBarrel)) return ;
1190  if (ele->isEE() && (std::abs(deta) > cfg->maxDeltaEtaEndcaps)) return ;
1191  LogTrace("GsfElectronAlgo") << "Delta eta criteria are satisfied";
1192 
1193  // delta phi criteria
1194  double dphi = ele->deltaPhiSuperClusterTrackAtVtx();
1195  LogTrace("GsfElectronAlgo") << "delta phi : " << dphi;
1196  if (ele->isEB() && (std::abs(dphi) > cfg->maxDeltaPhiBarrel)) return ;
1197  if (ele->isEE() && (std::abs(dphi) > cfg->maxDeltaPhiEndcaps)) return ;
1198  LogTrace("GsfElectronAlgo") << "Delta phi criteria are satisfied";
1199 
1200  // sigma ieta ieta
1201  LogTrace("GsfElectronAlgo") << "sigma ieta ieta : " << ele->sigmaIetaIeta();
1202  if (ele->isEB() && (ele->sigmaIetaIeta() > cfg->maxSigmaIetaIetaBarrel)) return ;
1203  if (ele->isEE() && (ele->sigmaIetaIeta() > cfg->maxSigmaIetaIetaEndcaps)) return ;
1204  LogTrace("GsfElectronAlgo") << "Sigma ieta ieta criteria are satisfied";
1205 
1206  // fiducial
1207  if (!ele->isEB() && cfg->isBarrel) return ;
1208  if (!ele->isEE() && cfg->isEndcaps) return ;
1209  if (cfg->isFiducial && (ele->isEBEEGap()||ele->isEBEtaGap()||ele->isEBPhiGap()||ele->isEERingGap()||ele->isEEDeeGap())) return ;
1210  LogTrace("GsfElectronAlgo") << "Fiducial flags criteria are satisfied";
1211 
1212  // seed in TEC
1213  edm::RefToBase<TrajectorySeed> seed = ele->gsfTrack()->extra()->seedRef() ;
1214  ElectronSeedRef elseed = seed.castTo<ElectronSeedRef>() ;
1215  if (eg && !generalData_->cutsCfg.seedFromTEC)
1216  {
1217  if (elseed.isNull())
1218  { throw cms::Exception("GsfElectronAlgo|NotElectronSeed")<<"The GsfTrack seed is not an ElectronSeed ?!" ; }
1219  else
1220  { if (elseed->subDet2()==6) return ; }
1221  }
1222 
1223  // transverse impact parameter
1224  if (std::abs(ele->gsfTrack()->dxy(bs.position()))>cfg->maxTIP) return ;
1225  LogTrace("GsfElectronAlgo") << "TIP criterion is satisfied" ;
1226 
1227  LogTrace("GsfElectronAlgo") << "All cut based criteria are satisfied" ;
1228  ele->setPassCutBasedPreselection(true) ;
1229  }
GeneralData * generalData_
const CutsConfiguration cutsCfgPflow
void setPassCutBasedPreselection(bool flag)
Definition: GsfElectron.h:706
bool isEBEtaGap() const
Definition: GsfElectron.h:357
float eSuperClusterOverP() const
Definition: GsfElectron.h:245
bool isEBEEGap() const
Definition: GsfElectron.h:355
float hcalDepth2OverEcal() const
Definition: GsfElectron.h:441
const std::vector< std::pair< DetId, float > > & hitsAndFractions() const
Definition: CaloCluster.h:195
bool isEERingGap() const
Definition: GsfElectron.h:361
bool isEEDeeGap() const
Definition: GsfElectron.h:360
const StrategyConfiguration strategyCfg
bool isEE() const
Definition: GsfElectron.h:353
bool isEB() const
Definition: GsfElectron.h:352
float deltaEtaSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:249
float sigmaIetaIeta() const
Definition: GsfElectron.h:434
virtual SuperClusterRef superCluster() const
reference to a SuperCluster
Definition: GsfElectron.h:184
float deltaPhiSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:252
float hcalOverEcal() const
Definition: GsfElectron.h:442
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
const CutsConfiguration cutsCfg
bool isNull() const
Checks for null.
Definition: Ref.h:249
#define LogTrace(id)
float hcalDepth1OverEcal() const
Definition: GsfElectron.h:440
REF castTo() const
Definition: RefToBase.h:286
virtual GsfElectronCoreRef core() const
Definition: GsfElectron.cc:8
return(e1-e2)*(e1-e2)+dp *dp
bool isEBPhiGap() const
Definition: GsfElectron.h:358
const Point & position() const
position
Definition: BeamSpot.h:62
virtual GsfTrackRef gsfTrack() const
reference to a GsfTrack
Definition: GsfElectron.h:185
void GsfElectronAlgo::setMVAepiBasedPreselectionFlag ( reco::GsfElectron ele)
private
void GsfElectronAlgo::setMVAInputs ( const std::map< reco::GsfTrackRef, reco::GsfElectron::MvaInput > &  mvaInputs)

Definition at line 1247 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::electrons, and eventData_.

Referenced by GEDGsfElectronProducer::produce().

1248 {
1249  GsfElectronPtrCollection::iterator el ;
1250  for
1251  ( el = eventData_->electrons->begin() ;
1252  el != eventData_->electrons->end() ;
1253  el++ )
1254  {
1255  std::map<reco::GsfTrackRef,reco::GsfElectron::MvaInput>::const_iterator itcheck=mvaInputs.find((*el)->gsfTrack());
1256  (*el)->setMvaInput(itcheck->second);
1257  }
1258 }
GsfElectronPtrCollection * electrons
EventData * eventData_
void GsfElectronAlgo::setMVAOutputs ( const gsfAlgoHelpers::HeavyObjectCache hoc,
const std::map< reco::GsfTrackRef, reco::GsfElectron::MvaOutput > &  mvaOutputs 
)

Definition at line 1260 of file GsfElectronAlgo.cc.

References GsfElectronAlgo::EventData::electrons, eventData_, GsfElectronAlgo::StrategyConfiguration::gedElectronMode, generalData_, gsfAlgoHelpers::HeavyObjectCache::iElectronMVAEstimator, reco::GsfElectron::MvaOutput::mva_e_pi, reco::GsfElectron::MvaOutput::mva_Isolated, gsfAlgoHelpers::HeavyObjectCache::sElectronMVAEstimator, GsfElectronAlgo::GeneralData::strategyCfg, and GsfElectronAlgo::EventData::vertices.

Referenced by GEDGsfElectronProducer::produce().

1262 {
1263  GsfElectronPtrCollection::iterator el ;
1264  for
1265  ( el = eventData_->electrons->begin() ;
1266  el != eventData_->electrons->end() ;
1267  el++ )
1268  {
1270  float mva_NIso_Value= hoc->sElectronMVAEstimator->mva( *(*el), *(eventData_->vertices));
1271  float mva_Iso_Value = hoc->iElectronMVAEstimator->mva( *(*el), eventData_->vertices->size() );
1272  GsfElectron::MvaOutput mvaOutput ;
1273  mvaOutput.mva_e_pi = mva_NIso_Value ;
1274  mvaOutput.mva_Isolated = mva_Iso_Value ;
1275  (*el)->setMvaOutput(mvaOutput);
1276  }
1277  else{
1278  std::map<reco::GsfTrackRef,reco::GsfElectron::MvaOutput>::const_iterator itcheck=mvaOutputs.find((*el)->gsfTrack());
1279  (*el)->setMvaOutput(itcheck->second);
1280  }
1281  }
1282 }
std::unique_ptr< const SoftElectronMVAEstimator > sElectronMVAEstimator
GeneralData * generalData_
const StrategyConfiguration strategyCfg
GsfElectronPtrCollection * electrons
edm::Handle< reco::VertexCollection > vertices
EventData * eventData_
std::unique_ptr< const ElectronMVAEstimator > iElectronMVAEstimator
void GsfElectronAlgo::setPflowPreselectionFlag ( reco::GsfElectron ele)
private

Definition at line 1231 of file GsfElectronAlgo.cc.

References reco::GsfElectron::core(), GsfElectronAlgo::GeneralData::cutsCfg, GsfElectronAlgo::GeneralData::cutsCfgPflow, generalData_, LogTrace, GsfElectronAlgo::CutsConfiguration::minMVA, reco::GsfElectron::MvaOutput::mva_e_pi, reco::GsfElectron::mvaOutput(), reco::GsfElectron::passingMvaPreselection(), reco::GsfElectron::setPassMvaPreselection(), and reco::GsfElectron::setPassPflowPreselection().

Referenced by addPflowInfo().

1232  {
1233  ele->setPassMvaPreselection(false) ;
1234 
1235  if (ele->core()->ecalDrivenSeed())
1236  { if (ele->mvaOutput().mva_e_pi>=generalData_->cutsCfg.minMVA) ele->setPassMvaPreselection(true) ; }
1237  else
1239 
1240  if (ele->passingMvaPreselection())
1241  { LogTrace("GsfElectronAlgo") << "Main mva criterion is satisfied" ; }
1242 
1244 
1245  }
GeneralData * generalData_
const CutsConfiguration cutsCfgPflow
bool passingMvaPreselection() const
Definition: GsfElectron.h:714
void setPassMvaPreselection(bool flag)
Definition: GsfElectron.h:713
const CutsConfiguration cutsCfg
#define LogTrace(id)
const MvaOutput & mvaOutput() const
Definition: GsfElectron.h:672
virtual GsfElectronCoreRef core() const
Definition: GsfElectron.cc:8
void setPassPflowPreselection(bool flag)
Definition: GsfElectron.h:707
void GsfElectronAlgo::setPixelMatchInfomation ( reco::GsfElectron ele)
private

Definition at line 1734 of file GsfElectronAlgo.cc.

References edm::RefToBase< T >::castTo(), reco::LeafCandidate::charge(), reco::GsfElectron::gsfTrack(), edm::RefToBase< T >::isNull(), edm::Ref< C, T, F >::isNull(), SurveyInfoScenario_cff::seed, reco::GsfElectron::setPixelMatchDPhi1(), reco::GsfElectron::setPixelMatchDPhi2(), reco::GsfElectron::setPixelMatchDRz1(), reco::GsfElectron::setPixelMatchDRz2(), and reco::GsfElectron::setPixelMatchSubdetectors().

Referenced by createElectron().

1734  {
1735  int sd1 = 0 ;
1736  int sd2 = 0 ;
1737  float dPhi1 = 0 ;
1738  float dPhi2 = 0 ;
1739  float dRz1 = 0 ;
1740  float dRz2 = 0 ;
1741  edm::RefToBase<TrajectorySeed> seed = ele->gsfTrack()->extra()->seedRef();
1742  ElectronSeedRef elseed = seed.castTo<ElectronSeedRef>();
1743  if(seed.isNull()){}
1744  else{
1745  if(elseed.isNull()){}
1746  else{
1747  sd1 = elseed->subDet1() ;
1748  sd2 = elseed->subDet2() ;
1749  dPhi1 = (ele->charge()>0) ? elseed->dPhi1Pos() : elseed->dPhi1() ;
1750  dPhi2 = (ele->charge()>0) ? elseed->dPhi2Pos() : elseed->dPhi2() ;
1751  dRz1 = (ele->charge()>0) ? elseed->dRz1Pos () : elseed->dRz1 () ;
1752  dRz2 = (ele->charge()>0) ? elseed->dRz2Pos () : elseed->dRz2 () ;
1753  }
1754  }
1755  ele->setPixelMatchSubdetectors(sd1,sd2) ;
1756  ele->setPixelMatchDPhi1(dPhi1) ;
1757  ele->setPixelMatchDPhi2(dPhi2) ;
1758  ele->setPixelMatchDRz1 (dRz1 ) ;
1759  ele->setPixelMatchDRz2 (dRz2 ) ;
1760 }
void setPixelMatchDRz2(float dRz2)
Definition: GsfElectron.h:881
void setPixelMatchDPhi1(float dPhi1)
Definition: GsfElectron.h:878
void setPixelMatchSubdetectors(int sd1, int sd2)
Definition: GsfElectron.h:877
virtual int charge() const final
electric charge
Definition: LeafCandidate.h:91
bool isNull() const
Checks for null.
Definition: Ref.h:249
void setPixelMatchDPhi2(float dPhi2)
Definition: GsfElectron.h:879
REF castTo() const
Definition: RefToBase.h:286
bool isNull() const
Checks for null.
Definition: RefToBase.h:328
void setPixelMatchDRz1(float dRz1)
Definition: GsfElectron.h:880
virtual GsfTrackRef gsfTrack() const
reference to a GsfTrack
Definition: GsfElectron.h:185

Member Data Documentation

ElectronData* GsfElectronAlgo::electronData_
private

Definition at line 244 of file GsfElectronAlgo.h.

Referenced by completeElectrons(), createElectron(), and ~GsfElectronAlgo().

EventData* GsfElectronAlgo::eventData_
private
EventSetupData* GsfElectronAlgo::eventSetupData_
private
GeneralData* GsfElectronAlgo::generalData_
private