GsfElectronBaseProducer Class Reference

#include <GsfElectronBaseProducer.h>

Inheritance diagram for GsfElectronBaseProducer:

Public Member Functions
	GsfElectronBaseProducer (const edm::ParameterSet &, const gsfAlgoHelpers::HeavyObjectCache *)
virtual	~GsfElectronBaseProducer ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< gsfAlgoHelpers::HeavyObjectCache > >
	EDProducer ()=default
Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducerBase ()
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescription (edm::ParameterSetDescription &)
static void	globalEndJob (gsfAlgoHelpers::HeavyObjectCache const *)
static std::unique_ptr < gsfAlgoHelpers::HeavyObjectCache >	initializeGlobalCache (const edm::ParameterSet &conf)
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions
void	beginEvent (edm::Event &, const edm::EventSetup &)
void	endEvent ()
void	fillEvent (edm::Event &)
reco::GsfElectron *	newElectron ()
const edm::OrphanHandle < reco::GsfElectronCollection > &	orphanHandle () const
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Protected Attributes
GsfElectronAlgo *	algo_
GsfElectronAlgo::CutsConfiguration	cutsCfg_
GsfElectronAlgo::CutsConfiguration	cutsCfgPflow_
ElectronHcalHelper::Configuration	hcalCfg_
ElectronHcalHelper::Configuration	hcalCfgPflow_
GsfElectronAlgo::InputTagsConfiguration	inputCfg_
ElectronMVAEstimator::Configuration	mva_Iso_Cfg_
SoftElectronMVAEstimator::Configuration	mva_NIso_Cfg_
GsfElectronAlgo::StrategyConfiguration	strategyCfg_

Private Member Functions
void	checkEcalSeedingParameters (edm::ParameterSet const &)

Private Attributes
bool	ecalSeedingParametersChecked_
edm::OrphanHandle < reco::GsfElectronCollection >	orphanHandle_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< gsfAlgoHelpers::HeavyObjectCache > >
typedef CacheContexts< T...>	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T...>	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Detailed Description

Definition at line 29 of file GsfElectronBaseProducer.h.

Constructor & Destructor Documentation

GsfElectronBaseProducer::GsfElectronBaseProducer ( const edm::ParameterSet &  cfg, const gsfAlgoHelpers::HeavyObjectCache *    )

explicit

Definition at line 155 of file GsfElectronBaseProducer.cc.

References GsfElectronAlgo::StrategyConfiguration::addPflowElectrons, algo_, GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::StrategyConfiguration::applyAmbResolution, GsfElectronAlgo::StrategyConfiguration::applyPreselection, GsfElectronAlgo::InputTagsConfiguration::barrelRecHitCollection, GsfElectronAlgo::InputTagsConfiguration::beamSpotTag, GsfElectronAlgo::InputTagsConfiguration::ctfTracks, GsfElectronAlgo::StrategyConfiguration::ctfTracksCheck, cutsCfg_, cutsCfgPflow_, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalEnergyFromClassBasedParameterization, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalErrorFromClassBasedParameterization, RegressionHelper::Configuration::ecalRegressionWeightLabels, GsfElectronAlgo::InputTagsConfiguration::edIsoVals, GsfElectronAlgo::InputTagsConfiguration::endcapRecHitCollection, Exception, edm::ParameterSet::exists(), GsfElectronAlgo::StrategyConfiguration::gedElectronMode, reco::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), GsfElectronAlgo::InputTagsConfiguration::gsfElectronCores, GsfElectronAlgo::InputTagsConfiguration::gsfPfRecTracksTag, hcalCfg_, hcalCfgPflow_, ElectronHcalHelper::Configuration::hcalTowers, GsfElectronAlgo::InputTagsConfiguration::hcalTowersTag, ElectronHcalHelper::Configuration::hOverEConeSize, ElectronHcalHelper::Configuration::hOverEPtMin, inputCfg_, GsfElectronAlgo::IsolationConfiguration::intRadiusBarrelTk, GsfElectronAlgo::CutsConfiguration::isBarrel, GsfElectronAlgo::CutsConfiguration::isEndcaps, GsfElectronAlgo::CutsConfiguration::isFiducial, GsfElectronAlgo::CutsConfiguration::maxDeltaEtaBarrel, GsfElectronAlgo::CutsConfiguration::maxDeltaEtaEndcaps, GsfElectronAlgo::CutsConfiguration::maxDeltaPhiBarrel, GsfElectronAlgo::CutsConfiguration::maxDeltaPhiEndcaps, GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA, GsfElectronAlgo::CutsConfiguration::maxEOverPBarrel, GsfElectronAlgo::CutsConfiguration::maxEOverPEndcaps, GsfElectronAlgo::CutsConfiguration::maxFbremBarrel, GsfElectronAlgo::CutsConfiguration::maxFbremEndcaps, GsfElectronAlgo::CutsConfiguration::maxHBarrel, GsfElectronAlgo::CutsConfiguration::maxHEndcaps, GsfElectronAlgo::CutsConfiguration::maxHOverEBarrel, GsfElectronAlgo::CutsConfiguration::maxHOverEEndcaps, GsfElectronAlgo::CutsConfiguration::maxSigmaIetaIetaBarrel, GsfElectronAlgo::CutsConfiguration::maxSigmaIetaIetaEndcaps, GsfElectronAlgo::CutsConfiguration::maxTIP, GsfElectronAlgo::CutsConfiguration::minEOverPBarrel, GsfElectronAlgo::CutsConfiguration::minEOverPEndcaps, GsfElectronAlgo::CutsConfiguration::minMVA, GsfElectronAlgo::CutsConfiguration::minMvaByPassForIsolated, GsfElectronAlgo::CutsConfiguration::minSCEtBarrel, GsfElectronAlgo::CutsConfiguration::minSCEtEndcaps, mva_Iso_Cfg_, mva_NIso_Cfg_, mergeVDriftHistosByStation::name, GsfElectronAlgo::InputTagsConfiguration::pfIsoVals, GsfElectronAlgo::InputTagsConfiguration::pflowGsfElectronsTag, GsfElectronAlgo::InputTagsConfiguration::pfMVA, GsfElectronAlgo::StrategyConfiguration::PreSelectMVA, GsfElectronAlgo::InputTagsConfiguration::previousGsfElectrons, GsfElectronAlgo::StrategyConfiguration::pureTrackerDrivenEcalErrorFromSimpleParameterization, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitFlagsToBeExcludedEndcaps, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedBarrel, GsfElectronAlgo::EcalRecHitsConfiguration::recHitSeverityToBeExcludedEndcaps, GsfElectronAlgo::CutsConfiguration::seedFromTEC, GsfElectronAlgo::InputTagsConfiguration::seedsTag, strategyCfg_, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, funct::true, GsfElectronAlgo::StrategyConfiguration::useCombinationRegression, GsfElectronAlgo::StrategyConfiguration::useEcalRegression, GsfElectronAlgo::StrategyConfiguration::useGsfPfRecTracks, ElectronHcalHelper::Configuration::useTowers, GsfElectronAlgo::InputTagsConfiguration::vtxCollectionTag, ElectronMVAEstimator::Configuration::vweightsfiles, and SoftElectronMVAEstimator::Configuration::vweightsfiles.

 : ecalSeedingParametersChecked_(false)
 {
  produces<GsfElectronCollection>();

  inputCfg_.previousGsfElectrons = consumes<reco::GsfElectronCollection>(cfg.getParameter<edm::InputTag>("previousGsfElectronsTag"));
  inputCfg_.pflowGsfElectronsTag = consumes<reco::GsfElectronCollection>(cfg.getParameter<edm::InputTag>("pflowGsfElectronsTag"));
  inputCfg_.gsfElectronCores = consumes<reco::GsfElectronCoreCollection>(cfg.getParameter<edm::InputTag>("gsfElectronCoresTag"));
  inputCfg_.hcalTowersTag = consumes<CaloTowerCollection>(cfg.getParameter<edm::InputTag>("hcalTowers"));
  //inputCfg_.tracks_ = cfg.getParameter<edm::InputTag>("tracks");
  inputCfg_.barrelRecHitCollection = consumes<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("barrelRecHitCollectionTag"));
  inputCfg_.endcapRecHitCollection = consumes<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("endcapRecHitCollectionTag"));
  inputCfg_.pfMVA = consumes<edm::ValueMap<float> >(cfg.getParameter<edm::InputTag>("pfMvaTag"));
  inputCfg_.ctfTracks = consumes<reco::TrackCollection>(cfg.getParameter<edm::InputTag>("ctfTracksTag"));
  inputCfg_.seedsTag = consumes<reco::ElectronSeedCollection>(cfg.getParameter<edm::InputTag>("seedsTag")); // used to check config consistency with seeding
  inputCfg_.beamSpotTag = consumes<reco::BeamSpot>(cfg.getParameter<edm::InputTag>("beamSpotTag"));
  inputCfg_.gsfPfRecTracksTag = consumes<reco::GsfPFRecTrackCollection>(cfg.getParameter<edm::InputTag>("gsfPfRecTracksTag"));
  inputCfg_.vtxCollectionTag = consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>("vtxTag"));

  bool useIsolationValues = cfg.getParameter<bool>("useIsolationValues") ;
  if ( useIsolationValues ) {
    if( ! cfg.exists("pfIsolationValues") ) {
      throw cms::Exception("GsfElectronBaseProducer|InternalError")
    <<"Missing ParameterSet pfIsolationValues" ;
    } else {
      inputCfg_.pfIsoVals = 
    cfg.getParameter<edm::ParameterSet> ("pfIsolationValues");
      std::vector<std::string> isoNames = 
    inputCfg_.pfIsoVals.getParameterNamesForType<edm::InputTag>();
      for(const std::string& name : isoNames) {
    edm::InputTag tag = 
      inputCfg_.pfIsoVals.getParameter<edm::InputTag>(name);
    mayConsume<edm::ValueMap<double> >(tag);
      }
    }
      
    if ( ! cfg.exists("edIsolationValues") ) {
      throw cms::Exception("GsfElectronBaseProducer|InternalError")
    <<"Missing ParameterSet edIsolationValues" ;
    } else {
      inputCfg_.edIsoVals = 
    cfg.getParameter<edm::ParameterSet> ("edIsolationValues");
      std::vector<std::string> isoNames = 
    inputCfg_.edIsoVals.getParameterNamesForType<edm::InputTag>();
      for(const std::string& name : isoNames) {
    edm::InputTag tag = 
      inputCfg_.edIsoVals.getParameter<edm::InputTag>(name);
    mayConsume<edm::ValueMap<double> >(tag);
      }
    }
  }

  strategyCfg_.useGsfPfRecTracks = cfg.getParameter<bool>("useGsfPfRecTracks") ;
  strategyCfg_.applyPreselection = cfg.getParameter<bool>("applyPreselection") ;
  strategyCfg_.ecalDrivenEcalEnergyFromClassBasedParameterization = cfg.getParameter<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization") ;
  strategyCfg_.ecalDrivenEcalErrorFromClassBasedParameterization = cfg.getParameter<bool>("ecalDrivenEcalErrorFromClassBasedParameterization") ;
  strategyCfg_.pureTrackerDrivenEcalErrorFromSimpleParameterization = cfg.getParameter<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization") ;
  strategyCfg_.applyAmbResolution = cfg.getParameter<bool>("applyAmbResolution") ;
  strategyCfg_.ambSortingStrategy = cfg.getParameter<unsigned>("ambSortingStrategy") ;
  strategyCfg_.ambClustersOverlapStrategy = cfg.getParameter<unsigned>("ambClustersOverlapStrategy") ;
  strategyCfg_.addPflowElectrons = cfg.getParameter<bool>("addPflowElectrons") ;
  strategyCfg_.ctfTracksCheck = cfg.getParameter<bool>("ctfTracksCheck");
  strategyCfg_.gedElectronMode = cfg.getParameter<bool>("gedElectronMode");
  strategyCfg_.PreSelectMVA = cfg.getParameter<double>("PreSelectMVA");  
  strategyCfg_.MaxElePtForOnlyMVA = cfg.getParameter<double>("MaxElePtForOnlyMVA");  
  strategyCfg_.useEcalRegression = cfg.getParameter<bool>("useEcalRegression");
  strategyCfg_.useCombinationRegression = cfg.getParameter<bool>("useCombinationRegression");

  cutsCfg_.minSCEtBarrel = cfg.getParameter<double>("minSCEtBarrel") ;
  cutsCfg_.minSCEtEndcaps = cfg.getParameter<double>("minSCEtEndcaps") ;
  cutsCfg_.maxEOverPBarrel = cfg.getParameter<double>("maxEOverPBarrel") ;
  cutsCfg_.maxEOverPEndcaps = cfg.getParameter<double>("maxEOverPEndcaps") ;
  cutsCfg_.minEOverPBarrel = cfg.getParameter<double>("minEOverPBarrel") ;
  cutsCfg_.minEOverPEndcaps = cfg.getParameter<double>("minEOverPEndcaps") ;

  // H/E
  cutsCfg_.maxHOverEBarrel = cfg.getParameter<double>("maxHOverEBarrel") ;
  cutsCfg_.maxHOverEEndcaps = cfg.getParameter<double>("maxHOverEEndcaps") ;
  cutsCfg_.maxHBarrel = cfg.getParameter<double>("maxHBarrel") ;
  cutsCfg_.maxHEndcaps = cfg.getParameter<double>("maxHEndcaps") ;

  cutsCfg_.maxDeltaEtaBarrel = cfg.getParameter<double>("maxDeltaEtaBarrel") ;
  cutsCfg_.maxDeltaEtaEndcaps = cfg.getParameter<double>("maxDeltaEtaEndcaps") ;
  cutsCfg_.maxDeltaPhiBarrel = cfg.getParameter<double>("maxDeltaPhiBarrel") ;
  cutsCfg_.maxDeltaPhiEndcaps = cfg.getParameter<double>("maxDeltaPhiEndcaps") ;
  cutsCfg_.maxSigmaIetaIetaBarrel = cfg.getParameter<double>("maxSigmaIetaIetaBarrel") ;
  cutsCfg_.maxSigmaIetaIetaEndcaps = cfg.getParameter<double>("maxSigmaIetaIetaEndcaps") ;
  cutsCfg_.maxFbremBarrel = cfg.getParameter<double>("maxFbremBarrel") ;
  cutsCfg_.maxFbremEndcaps = cfg.getParameter<double>("maxFbremEndcaps") ;
  cutsCfg_.isBarrel = cfg.getParameter<bool>("isBarrel") ;
  cutsCfg_.isEndcaps = cfg.getParameter<bool>("isEndcaps") ;
  cutsCfg_.isFiducial = cfg.getParameter<bool>("isFiducial") ;
  cutsCfg_.minMVA = cfg.getParameter<double>("minMVA") ;
  cutsCfg_.minMvaByPassForIsolated = cfg.getParameter<double>("minMvaByPassForIsolated") ;
  cutsCfg_.maxTIP = cfg.getParameter<double>("maxTIP") ;
  cutsCfg_.seedFromTEC = cfg.getParameter<bool>("seedFromTEC") ;

  cutsCfgPflow_.minSCEtBarrel = cfg.getParameter<double>("minSCEtBarrelPflow") ;
  cutsCfgPflow_.minSCEtEndcaps = cfg.getParameter<double>("minSCEtEndcapsPflow") ;
  cutsCfgPflow_.maxEOverPBarrel = cfg.getParameter<double>("maxEOverPBarrelPflow") ;
  cutsCfgPflow_.maxEOverPEndcaps = cfg.getParameter<double>("maxEOverPEndcapsPflow") ;
  cutsCfgPflow_.minEOverPBarrel = cfg.getParameter<double>("minEOverPBarrelPflow") ;
  cutsCfgPflow_.minEOverPEndcaps = cfg.getParameter<double>("minEOverPEndcapsPflow") ;

  // H/E
  cutsCfgPflow_.maxHOverEBarrel = cfg.getParameter<double>("maxHOverEBarrelPflow") ;
  cutsCfgPflow_.maxHOverEEndcaps = cfg.getParameter<double>("maxHOverEEndcapsPflow") ;
  cutsCfgPflow_.maxHBarrel = cfg.getParameter<double>("maxHBarrelPflow") ;
  cutsCfgPflow_.maxHEndcaps = cfg.getParameter<double>("maxHEndcapsPflow") ;

  cutsCfgPflow_.maxDeltaEtaBarrel = cfg.getParameter<double>("maxDeltaEtaBarrelPflow") ;
  cutsCfgPflow_.maxDeltaEtaEndcaps = cfg.getParameter<double>("maxDeltaEtaEndcapsPflow") ;
  cutsCfgPflow_.maxDeltaPhiBarrel = cfg.getParameter<double>("maxDeltaPhiBarrelPflow") ;
  cutsCfgPflow_.maxDeltaPhiEndcaps = cfg.getParameter<double>("maxDeltaPhiEndcapsPflow") ;
  cutsCfgPflow_.maxDeltaPhiBarrel = cfg.getParameter<double>("maxDeltaPhiBarrelPflow") ;
  cutsCfgPflow_.maxDeltaPhiEndcaps = cfg.getParameter<double>("maxDeltaPhiEndcapsPflow") ;
  cutsCfgPflow_.maxDeltaPhiBarrel = cfg.getParameter<double>("maxDeltaPhiBarrelPflow") ;
  cutsCfgPflow_.maxDeltaPhiEndcaps = cfg.getParameter<double>("maxDeltaPhiEndcapsPflow") ;
  cutsCfgPflow_.maxSigmaIetaIetaBarrel = cfg.getParameter<double>("maxSigmaIetaIetaBarrelPflow") ;
  cutsCfgPflow_.maxSigmaIetaIetaEndcaps = cfg.getParameter<double>("maxSigmaIetaIetaEndcapsPflow") ;
  cutsCfgPflow_.maxFbremBarrel = cfg.getParameter<double>("maxFbremBarrelPflow") ;
  cutsCfgPflow_.maxFbremEndcaps = cfg.getParameter<double>("maxFbremEndcapsPflow") ;
  cutsCfgPflow_.isBarrel = cfg.getParameter<bool>("isBarrelPflow") ;
  cutsCfgPflow_.isEndcaps = cfg.getParameter<bool>("isEndcapsPflow") ;
  cutsCfgPflow_.isFiducial = cfg.getParameter<bool>("isFiducialPflow") ;
  cutsCfgPflow_.minMVA = cfg.getParameter<double>("minMVAPflow") ;
  cutsCfgPflow_.minMvaByPassForIsolated = cfg.getParameter<double>("minMvaByPassForIsolatedPflow") ;
  cutsCfgPflow_.maxTIP = cfg.getParameter<double>("maxTIPPflow") ;
  cutsCfgPflow_.seedFromTEC = true ; // not applied for pflow

  // hcal helpers
  hcalCfg_.hOverEConeSize = cfg.getParameter<double>("hOverEConeSize") ;
  if (hcalCfg_.hOverEConeSize>0)
   {
    hcalCfg_.useTowers = true ;
    hcalCfg_.hcalTowers = 
      consumes<CaloTowerCollection>(cfg.getParameter<edm::InputTag>("hcalTowers")) ;
    hcalCfg_.hOverEPtMin = cfg.getParameter<double>("hOverEPtMin") ;
   }
  hcalCfgPflow_.hOverEConeSize = cfg.getParameter<double>("hOverEConeSizePflow") ;
  if (hcalCfgPflow_.hOverEConeSize>0)
   {
    hcalCfgPflow_.useTowers = true ;
    hcalCfgPflow_.hcalTowers = 
      consumes<CaloTowerCollection>(cfg.getParameter<edm::InputTag>("hcalTowers")) ;
    hcalCfgPflow_.hOverEPtMin = cfg.getParameter<double>("hOverEPtMinPflow") ;
   }

  // Ecal rec hits configuration
  GsfElectronAlgo::EcalRecHitsConfiguration recHitsCfg ;
  const std::vector<std::string> flagnamesbarrel = cfg.getParameter<std::vector<std::string> >("recHitFlagsToBeExcludedBarrel");
  recHitsCfg.recHitFlagsToBeExcludedBarrel = StringToEnumValue<EcalRecHit::Flags>(flagnamesbarrel);
  const std::vector<std::string> flagnamesendcaps = cfg.getParameter<std::vector<std::string> >("recHitFlagsToBeExcludedEndcaps");
  recHitsCfg.recHitFlagsToBeExcludedEndcaps = StringToEnumValue<EcalRecHit::Flags>(flagnamesendcaps);
  const std::vector<std::string> severitynamesbarrel = cfg.getParameter<std::vector<std::string> >("recHitSeverityToBeExcludedBarrel");
  recHitsCfg.recHitSeverityToBeExcludedBarrel = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesbarrel);
  const std::vector<std::string> severitynamesendcaps = cfg.getParameter<std::vector<std::string> >("recHitSeverityToBeExcludedEndcaps");
  recHitsCfg.recHitSeverityToBeExcludedEndcaps = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesendcaps);
  //recHitsCfg.severityLevelCut = cfg.getParameter<int>("severityLevelCut") ;

  // isolation
  GsfElectronAlgo::IsolationConfiguration isoCfg ;
  isoCfg.intRadiusBarrelTk = cfg.getParameter<double>("intRadiusBarrelTk") ;
  isoCfg.intRadiusEndcapTk = cfg.getParameter<double>("intRadiusEndcapTk") ;
  isoCfg.stripBarrelTk = cfg.getParameter<double>("stripBarrelTk") ;
  isoCfg.stripEndcapTk = cfg.getParameter<double>("stripEndcapTk") ;
  isoCfg.ptMinTk = cfg.getParameter<double>("ptMinTk") ;
  isoCfg.maxVtxDistTk = cfg.getParameter<double>("maxVtxDistTk") ;
  isoCfg.maxDrbTk = cfg.getParameter<double>("maxDrbTk") ;
  isoCfg.intRadiusHcal = cfg.getParameter<double>("intRadiusHcal") ;
  isoCfg.etMinHcal = cfg.getParameter<double>("etMinHcal") ;
  isoCfg.intRadiusEcalBarrel = cfg.getParameter<double>("intRadiusEcalBarrel") ;
  isoCfg.intRadiusEcalEndcaps = cfg.getParameter<double>("intRadiusEcalEndcaps") ;
  isoCfg.jurassicWidth = cfg.getParameter<double>("jurassicWidth") ;
  isoCfg.etMinBarrel = cfg.getParameter<double>("etMinBarrel") ;
  isoCfg.eMinBarrel = cfg.getParameter<double>("eMinBarrel") ;
  isoCfg.etMinEndcaps = cfg.getParameter<double>("etMinEndcaps") ;
  isoCfg.eMinEndcaps = cfg.getParameter<double>("eMinEndcaps") ;
  isoCfg.vetoClustered = cfg.getParameter<bool>("vetoClustered") ;
  isoCfg.useNumCrystals = cfg.getParameter<bool>("useNumCrystals") ;

 
  RegressionHelper::Configuration regressionCfg ;
  regressionCfg.ecalRegressionWeightLabels = cfg.getParameter<std::vector<std::string> >("ecalRefinedRegressionWeightLabels");
  regressionCfg.combinationRegressionWeightLabels = cfg.getParameter<std::vector<std::string> >("combinationRegressionWeightLabels");
  regressionCfg.ecalRegressionWeightFiles = cfg.getParameter<std::vector<std::string> >("ecalRefinedRegressionWeightFiles");
  regressionCfg.combinationRegressionWeightFiles = cfg.getParameter<std::vector<std::string> >("combinationRegressionWeightFile");
  regressionCfg.ecalWeightsFromDB = cfg.getParameter<bool>("ecalWeightsFromDB");
  regressionCfg.combinationWeightsFromDB = cfg.getParameter<bool>("combinationWeightsFromDB");
  // functions for corrector
  EcalClusterFunctionBaseClass * superClusterErrorFunction = 0 ;
  std::string superClusterErrorFunctionName
   = cfg.getParameter<std::string>("superClusterErrorFunction") ;
  if (superClusterErrorFunctionName!="")
   {
    superClusterErrorFunction
     = EcalClusterFunctionFactory::get()->create(superClusterErrorFunctionName,cfg) ;
   }
  else
  {
   superClusterErrorFunction
    = EcalClusterFunctionFactory::get()->create("EcalClusterEnergyUncertaintyObjectSpecific",cfg) ;
  }
  EcalClusterFunctionBaseClass * crackCorrectionFunction = 0 ;
  std::string crackCorrectionFunctionName
   = cfg.getParameter<std::string>("crackCorrectionFunction") ;
  if (crackCorrectionFunctionName!="")
   {
    crackCorrectionFunction
     = EcalClusterFunctionFactory::get()->create(crackCorrectionFunctionName,cfg) ;
   }


   mva_NIso_Cfg_.vweightsfiles = cfg.getParameter<std::vector<std::string>>("SoftElecMVAFilesString");
   mva_Iso_Cfg_.vweightsfiles  = cfg.getParameter<std::vector<std::string>>("ElecMVAFilesString");
  // create algo
  algo_ = new GsfElectronAlgo
   ( inputCfg_, strategyCfg_,
     cutsCfg_,cutsCfgPflow_,
     hcalCfg_,hcalCfgPflow_,
     isoCfg,recHitsCfg,
     superClusterErrorFunction,
     crackCorrectionFunction,
     mva_NIso_Cfg_,
     mva_Iso_Cfg_,
     regressionCfg
   ) ;


 }

GsfElectronBaseProducer::~GsfElectronBaseProducer ( )

virtual

Definition at line 386 of file GsfElectronBaseProducer.cc.

References algo_.

 { delete algo_ ; }

Member Function Documentation

void GsfElectronBaseProducer::beginEvent ( edm::Event &  event, const edm::EventSetup &  setup  )

protected

Definition at line 389 of file GsfElectronBaseProducer.cc.

References algo_, GsfElectronAlgo::beginEvent(), checkEcalSeedingParameters(), GsfElectronAlgo::checkSetup(), ecalSeedingParametersChecked_, inputCfg_, edm::HandleBase::isValid(), edm::parameterSet(), edm::HandleBase::provenance(), GsfElectronAlgo::InputTagsConfiguration::seedsTag, and funct::true.

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

 {
  // check configuration
  if (!ecalSeedingParametersChecked_)
   {
    ecalSeedingParametersChecked_ = true ;
    edm::Handle<reco::ElectronSeedCollection> seeds ;
    event.getByToken(inputCfg_.seedsTag,seeds) ;
    if (!seeds.isValid())
     {
      edm::LogWarning("GsfElectronAlgo|UnreachableSeedsProvenance")
        <<"Cannot check consistency of parameters with ecal seeding ones,"
        <<" because the original collection of seeds is not any more available." ;
     }
    else
     {
      checkEcalSeedingParameters(edm::parameterSet(*seeds.provenance())) ;
     }
   }

  // init the algo
  algo_->checkSetup(setup) ;
  algo_->beginEvent(event) ;
 }

void GsfElectronBaseProducer::checkEcalSeedingParameters ( edm::ParameterSet const &  pset )

private

Definition at line 442 of file GsfElectronBaseProducer.cc.

References cutsCfg_, edm::ParameterSet::getParameter(), hcalCfg_, ElectronHcalHelper::Configuration::hOverEConeSize, GsfElectronAlgo::CutsConfiguration::maxHOverEBarrel, GsfElectronAlgo::CutsConfiguration::maxHOverEEndcaps, GsfElectronAlgo::CutsConfiguration::minSCEtBarrel, and GsfElectronAlgo::CutsConfiguration::minSCEtEndcaps.

Referenced by beginEvent().

 {
  edm::ParameterSet seedConfiguration = pset.getParameter<edm::ParameterSet>("SeedConfiguration") ;
  //edm::ParameterSet orderedHitsFactoryPSet = seedConfiguration.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet") ;
  //edm::ParameterSet seedParameters = seedConfiguration.getParameter<edm::ParameterSet>("ecalDrivenElectronSeedsParameters") ;

  if (seedConfiguration.getParameter<bool>("applyHOverECut"))
   {
    if ((hcalCfg_.hOverEConeSize!=0)&&(hcalCfg_.hOverEConeSize!=seedConfiguration.getParameter<double>("hOverEConeSize")))
     { edm::LogWarning("GsfElectronAlgo|InconsistentParameters") <<"The H/E cone size ("<<hcalCfg_.hOverEConeSize<<") is different from ecal seeding ("<<seedConfiguration.getParameter<double>("hOverEConeSize")<<")." ; }
    if (cutsCfg_.maxHOverEBarrel<seedConfiguration.getParameter<double>("maxHOverEBarrel"))
     { edm::LogWarning("GsfElectronAlgo|InconsistentParameters") <<"The max barrel H/E is lower than during ecal seeding." ; }
    if (cutsCfg_.maxHOverEEndcaps<seedConfiguration.getParameter<double>("maxHOverEEndcaps"))
     { edm::LogWarning("GsfElectronAlgo|InconsistentParameters") <<"The max endcaps H/E is lower than during ecal seeding." ; }
   }

  if (cutsCfg_.minSCEtBarrel<seedConfiguration.getParameter<double>("SCEtCut"))
   { edm::LogWarning("GsfElectronAlgo|InconsistentParameters") <<"The minimum super-cluster Et in barrel is lower than during ecal seeding." ; }
  if (cutsCfg_.minSCEtEndcaps<seedConfiguration.getParameter<double>("SCEtCut"))
   { edm::LogWarning("GsfElectronAlgo|InconsistentParameters") <<"The minimum super-cluster Et in endcaps is lower than during ecal seeding." ; }
 }

void GsfElectronBaseProducer::endEvent ( )

protected

Definition at line 437 of file GsfElectronBaseProducer.cc.

References algo_, and GsfElectronAlgo::endEvent().

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

 {
  algo_->endEvent() ;
 }

void GsfElectronBaseProducer::fillDescription ( edm::ParameterSetDescription &  desc )

static

Definition at line 28 of file GsfElectronBaseProducer.cc.

References edm::ParameterSetDescription::add(), HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
  // input collections
  desc.add<edm::InputTag>("previousGsfElectronsTag",edm::InputTag("ecalDrivenGsfElectrons")) ;
  desc.add<edm::InputTag>("pflowGsfElectronsTag",edm::InputTag("pflowGsfElectrons")) ;
  desc.add<edm::InputTag>("gsfElectronCoresTag",edm::InputTag("gsfElectronCores")) ;
  desc.add<edm::InputTag>("hcalTowers",edm::InputTag("towerMaker")) ;
  desc.add<edm::InputTag>("barrelRecHitCollectionTag",edm::InputTag("ecalRecHit","EcalRecHitsEB")) ;
  desc.add<edm::InputTag>("endcapRecHitCollectionTag",edm::InputTag("ecalRecHit","EcalRecHitsEE")) ;
  //desc.add<edm::InputTag>("pfMvaTag",edm::InputTag("pfElectronTranslator:pf")) ;
  desc.add<edm::InputTag>("seedsTag",edm::InputTag("ecalDrivenElectronSeeds")) ;
  desc.add<edm::InputTag>("beamSpotTag",edm::InputTag("offlineBeamSpot")) ;
  desc.add<edm::InputTag>("gsfPfRecTracksTag",edm::InputTag("pfTrackElec")) ;
  //desc.add<std::vector<std::string>>("SoftElecMVAFilesString",std::vector<std::string> ("SoftElecMVAFile"));


  // backward compatibility mechanism for ctf tracks
  desc.add<bool>("ctfTracksCheck",true) ;
  desc.add<edm::InputTag>("ctfTracksTag",edm::InputTag("generalTracks")) ;

  desc.add<bool>("gedElectronMode",true) ;
  desc.add<double>("PreSelectMVA",-0.1) ;
  desc.add<double>("MaxElePtForOnlyMVA",50.0) ;

  // steering
  desc.add<bool>("useGsfPfRecTracks",true) ;
  desc.add<bool>("applyPreselection",false) ;
  desc.add<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization",false) ;
  desc.add<bool>("ecalDrivenEcalErrorFromClassBasedParameterization",false) ;
  desc.add<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization",false) ;
  desc.add<bool>("applyAmbResolution",false) ;
  desc.add<unsigned>("ambSortingStrategy",1) ;
  desc.add<unsigned>("ambClustersOverlapStrategy",1) ;
  //desc.add<bool>("addPflowElectrons",true) ;

//  // preselection parameters (ecal driven electrons)
//  desc.add<bool>("seedFromTEC",true) ;
//  desc.add<double>("minSCEtBarrel",4.0) ;
//  desc.add<double>("minSCEtEndcaps",4.0) ;
//  desc.add<double>("minEOverPBarrel",0.0) ;
//  desc.add<double>("maxEOverPBarrel",999999999.) ;
//  desc.add<double>("minEOverPEndcaps",0.0) ;
//  desc.add<double>("maxEOverPEndcaps",999999999.) ;
//  desc.add<double>("maxDeltaEtaBarrel",0.02) ;
//  desc.add<double>("maxDeltaEtaEndcaps",0.02) ;
//  desc.add<double>("maxDeltaPhiBarrel",0.15) ;
//  desc.add<double>("maxDeltaPhiEndcaps",0.15) ;
//  desc.add<double>("hOverEConeSize",0.15) ;
//  desc.add<double>("hOverEPtMin",0.) ;
//  desc.add<double>("maxHOverEBarrel",0.15) ;
//  desc.add<double>("maxHOverEEndcaps",0.15) ;
//  desc.add<double>("maxHBarrel",0.0) ;
//  desc.add<double>("maxHEndcaps",0.0) ;
//  desc.add<double>("maxSigmaIetaIetaBarrel",999999999.) ;
//  desc.add<double>("maxSigmaIetaIetaEndcaps",999999999.) ;
//  desc.add<double>("maxFbremBarrel",999999999.) ;
//  desc.add<double>("maxFbremEndcaps",999999999.) ;
//  desc.add<bool>("isBarrel",false) ;
//  desc.add<bool>("isEndcaps",false) ;
//  desc.add<bool>("isFiducial",false) ;
//  desc.add<double>("maxTIP",999999999.) ;
//  desc.add<double>("minMVA",-0.4) ;
//
//  // preselection parameters (tracker driven only electrons)
//  desc.add<double>("minSCEtBarrelPflow",0.0) ;
//  desc.add<double>("minSCEtEndcapsPflow",0.0) ;
//  desc.add<double>("minEOverPBarrelPflow",0.0) ;
//  desc.add<double>("maxEOverPBarrelPflow",999999999.) ;
//  desc.add<double>("minEOverPEndcapsPflow",0.0) ;
//  desc.add<double>("maxEOverPEndcapsPflow",999999999.) ;
//  desc.add<double>("maxDeltaEtaBarrelPflow",999999999.) ;
//  desc.add<double>("maxDeltaEtaEndcapsPflow",999999999.) ;
//  desc.add<double>("maxDeltaPhiBarrelPflow",999999999.) ;
//  desc.add<double>("maxDeltaPhiEndcapsPflow",999999999.) ;
//  desc.add<double>("hOverEConeSizePflow",0.15) ;
//  desc.add<double>("hOverEPtMinPflow",0.) ;
//  desc.add<double>("maxHOverEBarrelPflow",999999999.) ;
//  desc.add<double>("maxHOverEEndcapsPflow",999999999.) ;
//  desc.add<double>("maxHBarrelPflow",0.0) ;
//  desc.add<double>("maxHEndcapsPflow",0.0) ;
//  desc.add<double>("maxSigmaIetaIetaBarrelPflow",999999999.) ;
//  desc.add<double>("maxSigmaIetaIetaEndcapsPflow",999999999.) ;
//  desc.add<double>("maxFbremBarrelPflow",999999999.) ;
//  desc.add<double>("maxFbremEndcapsPflow",999999999.) ;
//  desc.add<bool>("isBarrelPflow",false) ;
//  desc.add<bool>("isEndcapsPflow",false) ;
//  desc.add<bool>("isFiducialPflow",false) ;
//  desc.add<double>("maxTIPPflow",999999999.) ;
//  desc.add<double>("minMVAPflow",-0.4) ;

  // Ecal rec hits configuration
  desc.add<std::vector<int> >("recHitFlagsToBeExcludedBarrel") ;
  desc.add<std::vector<int> >("recHitFlagsToBeExcludedEndcaps") ;
  desc.add<std::vector<int> >("recHitSeverityToBeExcludedBarrel") ;
  desc.add<std::vector<int> >("recHitSeverityToBeExcludedEndcaps") ;
  //desc.add<int>("severityLevelCut",4) ;

  // Isolation algos configuration
  desc.add<double>("intRadiusBarrelTk",0.015) ;
  desc.add<double>("intRadiusEndcapTk",0.015) ;
  desc.add<double>("stripBarrelTk",0.015) ;
  desc.add<double>("stripEndcapTk",0.015) ;
  desc.add<double>("ptMinTk",0.7) ;
  desc.add<double>("maxVtxDistTk",0.2) ;
  desc.add<double>("maxDrbTk",999999999.) ;
  desc.add<double>("intRadiusHcal",0.15) ;
  desc.add<double>("etMinHcal",0.0) ;
  desc.add<double>("intRadiusEcalBarrel",3.0) ;
  desc.add<double>("intRadiusEcalEndcaps",3.0) ;
  desc.add<double>("jurassicWidth",1.5) ;
  desc.add<double>("etMinBarrel",0.0) ;
  desc.add<double>("eMinBarrel",0.08) ;
  desc.add<double>("etMinEndcaps",0.1) ;
  desc.add<double>("eMinEndcaps",0.0) ;
  desc.add<bool>("vetoClustered",false) ;
  desc.add<bool>("useNumCrystals",true) ;

  edm::ParameterSetDescription descNested ;
  descNested.add<std::string>("propagatorAlongTISE","PropagatorWithMaterial") ;
  descNested.add<std::string>("propagatorOppositeTISE","PropagatorWithMaterialOpposite") ;
  desc.add<edm::ParameterSetDescription>("TransientInitialStateEstimatorParameters",descNested) ;

  // Corrections
  desc.add<std::string>("superClusterErrorFunction","EcalClusterEnergyUncertaintyObjectSpecific") ;
  desc.add<std::string>("crackCorrectionFunction","EcalClusterCrackCorrection") ;
 }

void GsfElectronBaseProducer::fillEvent ( edm::Event &  event )

protected

Definition at line 414 of file GsfElectronBaseProducer.cc.

References algo_, GsfElectronAlgo::StrategyConfiguration::applyAmbResolution, GsfElectronAlgo::StrategyConfiguration::applyPreselection, GsfElectronAlgo::copyElectrons(), GsfElectronAlgo::displayInternalElectrons(), orphanHandle_, GsfElectronAlgo::removeAmbiguousElectrons(), GsfElectronAlgo::removeNotPreselectedElectrons(), GsfElectronAlgo::setAmbiguityData(), and strategyCfg_.

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

 {
  // all electrons
  algo_->displayInternalElectrons("GsfElectronAlgo Info (before preselection)") ;
  // preselection
  if (strategyCfg_.applyPreselection)
   {
    algo_->removeNotPreselectedElectrons() ;
    algo_->displayInternalElectrons("GsfElectronAlgo Info (after preselection)") ;
   }
  // ambiguity
  algo_->setAmbiguityData() ;
  if (strategyCfg_.applyAmbResolution)
   {
    algo_->removeAmbiguousElectrons() ;
    algo_->displayInternalElectrons("GsfElectronAlgo Info (after amb. solving)") ;
   }
  // final filling
  std::auto_ptr<GsfElectronCollection> finalCollection( new GsfElectronCollection ) ;
  algo_->copyElectrons(*finalCollection) ;
  orphanHandle_ = event.put(finalCollection) ;
}

static void GsfElectronBaseProducer::globalEndJob ( gsfAlgoHelpers::HeavyObjectCache const *  )

inlinestatic

Definition at line 43 of file GsfElectronBaseProducer.h.

                                                                   {
  }

static std::unique_ptr<gsfAlgoHelpers::HeavyObjectCache> GsfElectronBaseProducer::initializeGlobalCache ( const edm::ParameterSet &  conf )

inlinestatic

Definition at line 39 of file GsfElectronBaseProducer.h.

                                                         {
       return std::unique_ptr<gsfAlgoHelpers::HeavyObjectCache>(new gsfAlgoHelpers::HeavyObjectCache(conf));
   }

reco::GsfElectron* GsfElectronBaseProducer::newElectron ( )

inlineprotected

Definition at line 53 of file GsfElectronBaseProducer.h.

{ return 0 ; }

const edm::OrphanHandle<reco::GsfElectronCollection>& GsfElectronBaseProducer::orphanHandle ( ) const

inlineprotected

Definition at line 54 of file GsfElectronBaseProducer.h.

References orphanHandle_.

Referenced by GEDGsfElectronProducer::fillGsfElectronValueMap().

{ return orphanHandle_;}

Member Data Documentation

GsfElectronAlgo* GsfElectronBaseProducer::algo_

protected

Definition at line 48 of file GsfElectronBaseProducer.h.

Referenced by beginEvent(), endEvent(), fillEvent(), GsfElectronBaseProducer(), GsfElectronProducer::produce(), GsfElectronEcalDrivenProducer::produce(), GEDGsfElectronProducer::produce(), and ~GsfElectronBaseProducer().

GsfElectronAlgo::CutsConfiguration GsfElectronBaseProducer::cutsCfg_

protected

Definition at line 59 of file GsfElectronBaseProducer.h.

Referenced by checkEcalSeedingParameters(), GsfElectronProducer::checkPfTranslatorParameters(), and GsfElectronBaseProducer().

GsfElectronAlgo::CutsConfiguration GsfElectronBaseProducer::cutsCfgPflow_

protected

Definition at line 60 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronProducer::checkPfTranslatorParameters(), and GsfElectronBaseProducer().

bool GsfElectronBaseProducer::ecalSeedingParametersChecked_

private

Definition at line 68 of file GsfElectronBaseProducer.h.

Referenced by beginEvent().

ElectronHcalHelper::Configuration GsfElectronBaseProducer::hcalCfg_

protected

Definition at line 61 of file GsfElectronBaseProducer.h.

Referenced by checkEcalSeedingParameters(), and GsfElectronBaseProducer().

ElectronHcalHelper::Configuration GsfElectronBaseProducer::hcalCfgPflow_

protected

Definition at line 62 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronBaseProducer().

GsfElectronAlgo::InputTagsConfiguration GsfElectronBaseProducer::inputCfg_

protected

Definition at line 57 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronProducer::beginEvent(), beginEvent(), and GsfElectronBaseProducer().

ElectronMVAEstimator::Configuration GsfElectronBaseProducer::mva_Iso_Cfg_

protected

Definition at line 64 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronBaseProducer().

SoftElectronMVAEstimator::Configuration GsfElectronBaseProducer::mva_NIso_Cfg_

protected

Definition at line 63 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronBaseProducer().

edm::OrphanHandle<reco::GsfElectronCollection> GsfElectronBaseProducer::orphanHandle_

private

Definition at line 70 of file GsfElectronBaseProducer.h.

Referenced by fillEvent(), and orphanHandle().

GsfElectronAlgo::StrategyConfiguration GsfElectronBaseProducer::strategyCfg_

protected

Definition at line 58 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronProducer::checkPfTranslatorParameters(), fillEvent(), GsfElectronBaseProducer(), and GsfElectronProducer::produce().