GsfElectronBaseProducer Class Reference

#include <GsfElectronBaseProducer.h>

Inheritance diagram for GsfElectronBaseProducer:

Public Member Functions
	GsfElectronBaseProducer (const edm::ParameterSet &, const GsfElectronAlgo::HeavyObjectCache *)
void	produce (edm::Event &event, const edm::EventSetup &setup) override
	~GsfElectronBaseProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< GsfElectronAlgo::HeavyObjectCache > >
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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

Protected Member Functions
void	beginEvent (edm::Event &, const edm::EventSetup &)
void	fillEvent (reco::GsfElectronCollection &electrons, edm::Event &event)
const edm::OrphanHandle< reco::GsfElectronCollection > &	orphanHandle () const

Protected Attributes
std::unique_ptr< GsfElectronAlgo >	algo_
const GsfElectronAlgo::CutsConfiguration	cutsCfg_
const GsfElectronAlgo::CutsConfiguration	cutsCfgPflow_
edm::ParameterSet	edIsoVals_
ElectronHcalHelper::Configuration	hcalCfg_
ElectronHcalHelper::Configuration	hcalCfgPflow_
GsfElectronAlgo::Tokens	inputCfg_
edm::ParameterSet	pfIsoVals_
edm::EDGetTokenT< edm::ValueMap< float > >	pfMVA_
GsfElectronAlgo::StrategyConfiguration	strategyCfg_

Private Member Functions
void	checkEcalSeedingParameters (edm::ParameterSet const &)
bool	isPreselected (reco::GsfElectron const &ele) const
void	setAmbiguityData (reco::GsfElectronCollection &electrons, edm::Event const &event, bool ignoreNotPreselected=true) const

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

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< GsfElectronAlgo::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

Detailed Description

Definition at line 26 of file GsfElectronBaseProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 238 of file GsfElectronBaseProducer.cc.

References GsfElectronAlgo::StrategyConfiguration::addPflowElectrons, algo_, GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::StrategyConfiguration::applyAmbResolution, GsfElectronAlgo::StrategyConfiguration::applyPreselection, GsfElectronAlgo::Tokens::barrelRecHitCollection, GsfElectronAlgo::Tokens::beamSpotTag, ElectronHcalHelper::Configuration::checkHcalStatus, gedGsfElectrons_cfi::combinationRegressionWeightLabels, GsfElectronAlgo::Tokens::conversions, GsfElectronAlgo::Tokens::ctfTracks, GsfElectronAlgo::StrategyConfiguration::ctfTracksCheck, cutsCfg_, cutsCfgPflow_, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalEnergyFromClassBasedParameterization, GsfElectronAlgo::StrategyConfiguration::ecalDrivenEcalErrorFromClassBasedParameterization, RegressionHelper::Configuration::ecalRegressionWeightLabels, edIsoVals_, GsfElectronAlgo::Tokens::endcapRecHitCollection, electronEcalRecHitIsolationLcone_cfi::etMinBarrel, GsfElectronAlgo::StrategyConfiguration::fillConvVtxFitProb, GsfElectronAlgo::StrategyConfiguration::gedElectronMode, timingPdfMaker::get, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNamesForType(), GsfElectronAlgo::Tokens::gsfElectronCores, GsfElectronAlgo::Tokens::gsfPfRecTracksTag, hcalCfg_, hcalCfgPflow_, ElectronHcalHelper::Configuration::hcalTowers, GsfElectronAlgo::Tokens::hcalTowersTag, ElectronHcalHelper::Configuration::hOverEConeSize, ElectronHcalHelper::Configuration::hOverEPtMin, inputCfg_, GsfElectronAlgo::IsolationConfiguration::intRadiusHcal, GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA, Skims_PA_cff::name, pfIsoVals_, GsfElectronAlgo::Tokens::pflowGsfElectronsTag, pfMVA_, GsfElectronAlgo::StrategyConfiguration::PreSelectMVA, GsfElectronAlgo::Tokens::previousGsfElectrons, GsfElectronAlgo::StrategyConfiguration::pureTrackerDrivenEcalErrorFromSimpleParameterization, GsfElectronAlgo::Tokens::seedsTag, strategyCfg_, AlCaHLTBitMon_QueryRunRegistry::string, GsfElectronAlgo::StrategyConfiguration::useCombinationRegression, GsfElectronAlgo::StrategyConfiguration::useEcalRegression, GsfElectronAlgo::StrategyConfiguration::useGsfPfRecTracks, ElectronHcalHelper::Configuration::useTowers, electronEcalRecHitIsolationLcone_cfi::vetoClustered, GsfElectronAlgo::Tokens::vtxCollectionTag, and ~GsfElectronBaseProducer().

    : cutsCfg_(makeCutsConfiguration(cfg.getParameter<edm::ParameterSet>("preselection"))),
      cutsCfgPflow_(makeCutsConfiguration(cfg.getParameter<edm::ParameterSet>("preselectionPflow"))),
      ecalSeedingParametersChecked_(false),
      electronPutToken_(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_.barrelRecHitCollection =
      consumes<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("barrelRecHitCollectionTag"));
  inputCfg_.endcapRecHitCollection =
      consumes<EcalRecHitCollection>(cfg.getParameter<edm::InputTag>("endcapRecHitCollectionTag"));
  pfMVA_ = consumes<edm::ValueMap<float>>(cfg.getParameter<edm::InputTag>("pfMvaTag"));
  inputCfg_.ctfTracks = consumes<reco::TrackCollection>(cfg.getParameter<edm::InputTag>("ctfTracksTag"));
  // used to check config consistency with seeding
  inputCfg_.seedsTag = consumes<reco::ElectronSeedCollection>(cfg.getParameter<edm::InputTag>("seedsTag"));
  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"));
  if (cfg.getParameter<bool>("fillConvVtxFitProb"))
    inputCfg_.conversions = consumes<reco::ConversionCollection>(cfg.getParameter<edm::InputTag>("conversionsTag"));

  if (cfg.getParameter<bool>("useIsolationValues")) {
    pfIsoVals_ = cfg.getParameter<edm::ParameterSet>("pfIsolationValues");
    for (const std::string& name : pfIsoVals_.getParameterNamesForType<edm::InputTag>()) {
      mayConsume<edm::ValueMap<double>>(pfIsoVals_.getParameter<edm::InputTag>(name));
    }

    edIsoVals_ = cfg.getParameter<edm::ParameterSet>("edIsolationValues");
    for (const std::string& name : edIsoVals_.getParameterNamesForType<edm::InputTag>()) {
      mayConsume<edm::ValueMap<double>>(edIsoVals_.getParameter<edm::InputTag>(name));
    }
  }

  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");
  strategyCfg_.fillConvVtxFitProb = cfg.getParameter<bool>("fillConvVtxFitProb");

  // hcal helpers
  auto const& psetPreselection = cfg.getParameter<edm::ParameterSet>("preselection");
  hcalCfg_.hOverEConeSize = psetPreselection.getParameter<double>("hOverEConeSize");
  if (hcalCfg_.hOverEConeSize > 0) {
    hcalCfg_.useTowers = true;
    hcalCfg_.checkHcalStatus = cfg.getParameter<bool>("checkHcalStatus");
    hcalCfg_.hcalTowers = consumes<CaloTowerCollection>(cfg.getParameter<edm::InputTag>("hcalTowers"));
    hcalCfg_.hOverEPtMin = psetPreselection.getParameter<double>("hOverEPtMin");
  }
  auto const& psetPreselectionPflow = cfg.getParameter<edm::ParameterSet>("preselectionPflow");
  hcalCfgPflow_.hOverEConeSize = psetPreselectionPflow.getParameter<double>("hOverEConeSize");
  if (hcalCfgPflow_.hOverEConeSize > 0) {
    hcalCfgPflow_.useTowers = true;
    hcalCfgPflow_.checkHcalStatus = cfg.getParameter<bool>("checkHcalStatus");
    hcalCfgPflow_.hcalTowers = consumes<CaloTowerCollection>(cfg.getParameter<edm::InputTag>("hcalTowers"));
    hcalCfgPflow_.hOverEPtMin = psetPreselectionPflow.getParameter<double>("hOverEPtMin");
  }

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

  // isolation
  const GsfElectronAlgo::IsolationConfiguration isoCfg{
      .intRadiusHcal = cfg.getParameter<double>("intRadiusHcal"),
      .etMinHcal = cfg.getParameter<double>("etMinHcal"),
      .intRadiusEcalBarrel = cfg.getParameter<double>("intRadiusEcalBarrel"),
      .intRadiusEcalEndcaps = cfg.getParameter<double>("intRadiusEcalEndcaps"),
      .jurassicWidth = cfg.getParameter<double>("jurassicWidth"),
      .etMinBarrel = cfg.getParameter<double>("etMinBarrel"),
      .eMinBarrel = cfg.getParameter<double>("eMinBarrel"),
      .etMinEndcaps = cfg.getParameter<double>("etMinEndcaps"),
      .eMinEndcaps = cfg.getParameter<double>("eMinEndcaps"),
      .vetoClustered = cfg.getParameter<bool>("vetoClustered"),
      .useNumCrystals = cfg.getParameter<bool>("useNumCrystals")};

  const RegressionHelper::Configuration regressionCfg{
      .ecalRegressionWeightLabels = cfg.getParameter<std::vector<std::string>>("ecalRefinedRegressionWeightLabels"),
      .ecalWeightsFromDB = cfg.getParameter<bool>("ecalWeightsFromDB"),
      .ecalRegressionWeightFiles = cfg.getParameter<std::vector<std::string>>("ecalRefinedRegressionWeightFiles"),
      .combinationRegressionWeightLabels =
          cfg.getParameter<std::vector<std::string>>("combinationRegressionWeightLabels"),
      .combinationWeightsFromDB = cfg.getParameter<bool>("combinationWeightsFromDB"),
      .combinationRegressionWeightFiles =
          cfg.getParameter<std::vector<std::string>>("combinationRegressionWeightFile")};

  // create algo
  algo_ = std::make_unique<GsfElectronAlgo>(
      inputCfg_,
      strategyCfg_,
      cutsCfg_,
      cutsCfgPflow_,
      hcalCfg_,
      hcalCfgPflow_,
      isoCfg,
      recHitsCfg,
      EcalClusterFunctionFactory::get()->create(cfg.getParameter<std::string>("superClusterErrorFunction"), cfg),
      EcalClusterFunctionFactory::get()->create(cfg.getParameter<std::string>("crackCorrectionFunction"), cfg),
      regressionCfg,
      cfg.getParameter<edm::ParameterSet>("trkIsol03Cfg"),
      cfg.getParameter<edm::ParameterSet>("trkIsol04Cfg"),
      cfg.getParameter<edm::ParameterSet>("trkIsolHEEP03Cfg"),
      cfg.getParameter<edm::ParameterSet>("trkIsolHEEP04Cfg"),
      consumesCollector());
}

GsfElectronBaseProducer::~GsfElectronBaseProducer ( )

overridedefault

Referenced by GsfElectronBaseProducer().

Member Function Documentation

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

protected

Definition at line 375 of file GsfElectronBaseProducer.cc.

References checkEcalSeedingParameters(), ecalSeedingParametersChecked_, inputCfg_, edm::HandleBase::isValid(), edm::parameterSet(), edm::HandleBase::provenance(), and GsfElectronAlgo::Tokens::seedsTag.

Referenced by GsfElectronProducer::beginEvent().

                                                                                    {
  // 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()));
    }
  }
}

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

private

Definition at line 412 of file GsfElectronBaseProducer.cc.

References cutsCfg_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), hcalCfg_, ElectronHcalHelper::Configuration::hOverEConeSize, GsfElectronAlgo::CutsConfiguration::maxHOverEBarrelCone, GsfElectronAlgo::CutsConfiguration::maxHOverEEndcapsCone, GsfElectronAlgo::CutsConfiguration::minSCEtBarrel, and GsfElectronAlgo::CutsConfiguration::minSCEtEndcaps.

Referenced by beginEvent().

                                                                                    {
  if (!pset.exists("SeedConfiguration")) {
    return;
  }
  edm::ParameterSet seedConfiguration = pset.getParameter<edm::ParameterSet>("SeedConfiguration");

  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_.maxHOverEBarrelCone < seedConfiguration.getParameter<double>("maxHOverEBarrel")) {
      edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
          << "The max barrel cone H/E is lower than during ecal seeding.";
    }
    if (cutsCfg_.maxHOverEEndcapsCone < seedConfiguration.getParameter<double>("maxHOverEEndcaps")) {
      edm::LogWarning("GsfElectronAlgo|InconsistentParameters")
          << "The max endcaps cone 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::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 44 of file GsfElectronBaseProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), edm::ParameterSet::getParameter(), HLT_2018_cff::InputTag, gedGsfElectrons_cfi::maxDeltaEtaEndcaps, gedGsfElectrons_cfi::maxDeltaPhiEndcaps, Reconstruction_hiPF_cff::maxEOverPEndcaps, gedGsfElectrons_cfi::maxHOverEEndcapsCone, gedGsfElectrons_cfi::maxHOverEEndcapsTower, gsfElectrons_cfi::minMVA, GsfElectronAlgo::CutsConfiguration::minSCEtBarrel, gedGsfElectrons_cfi::minSCEtEndcaps, muonDTDigis_cfi::pset, EleTkIsolFromCands::pSetDescript(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         {
  edm::ParameterSetDescription desc;
  // input collections
  desc.add<edm::InputTag>("gsfElectronCoresTag", edm::InputTag("gedGsfElectronCores"));
  desc.add<edm::InputTag>("pflowGsfElectronsTag", edm::InputTag(""));
  desc.add<edm::InputTag>("pfMvaTag", edm::InputTag(""));
  desc.add<edm::InputTag>("previousGsfElectronsTag", edm::InputTag(""));
  desc.add<edm::InputTag>("hcalTowers", edm::InputTag("towerMaker"));
  desc.add<edm::InputTag>("vtxTag", edm::InputTag("offlinePrimaryVertices"));
  desc.add<edm::InputTag>("conversionsTag", edm::InputTag("allConversions"));
  desc.add<edm::InputTag>("gsfPfRecTracksTag", edm::InputTag("pfTrackElec"));
  desc.add<edm::InputTag>("barrelRecHitCollectionTag", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
  desc.add<edm::InputTag>("endcapRecHitCollectionTag", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
  desc.add<edm::InputTag>("seedsTag", edm::InputTag("ecalDrivenElectronSeeds"));
  desc.add<edm::InputTag>("beamSpotTag", edm::InputTag("offlineBeamSpot"));
  desc.add<edm::InputTag>("egmPFCandidatesTag", edm::InputTag("particleFlowEGamma"));
  desc.add<bool>("checkHcalStatus", true);

  // steering
  desc.add<bool>("gedElectronMode", true);
  desc.add<bool>("useCombinationRegression", true);
  desc.add<bool>("ecalDrivenEcalEnergyFromClassBasedParameterization", false);
  desc.add<bool>("ecalDrivenEcalErrorFromClassBasedParameterization", false);
  desc.add<bool>("applyPreselection", true);
  desc.add<bool>("useEcalRegression", true);
  desc.add<bool>("applyAmbResolution", false);
  desc.add<bool>("useGsfPfRecTracks", true);
  desc.add<bool>("pureTrackerDrivenEcalErrorFromSimpleParameterization", true);
  desc.add<unsigned int>("ambSortingStrategy", 1);
  desc.add<unsigned int>("ambClustersOverlapStrategy", 1);
  desc.add<bool>("addPflowElectrons", true);  // this one should be transfered to the "core" level
  desc.add<bool>("fillConvVtxFitProb", true);

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

  // Isolation algos configuration
  desc.add("trkIsol03Cfg", EleTkIsolFromCands::pSetDescript());
  desc.add("trkIsol04Cfg", EleTkIsolFromCands::pSetDescript());
  desc.add("trkIsolHEEP03Cfg", EleTkIsolFromCands::pSetDescript());
  desc.add("trkIsolHEEP04Cfg", EleTkIsolFromCands::pSetDescript());
  desc.add<bool>("useNumCrystals", true);
  desc.add<double>("etMinBarrel", 0.0);
  desc.add<double>("etMinEndcaps", 0.11);
  desc.add<double>("etMinHcal", 0.0);
  desc.add<double>("eMinBarrel", 0.095);
  desc.add<double>("eMinEndcaps", 0.0);
  desc.add<double>("intRadiusEcalBarrel", 3.0);
  desc.add<double>("intRadiusEcalEndcaps", 3.0);
  desc.add<double>("intRadiusHcal", 0.15);
  desc.add<double>("jurassicWidth", 1.5);
  desc.add<bool>("vetoClustered", false);
  {
    edm::ParameterSetDescription psd0;
    psd0.add<std::string>("propagatorAlongTISE", "PropagatorWithMaterial");
    psd0.add<std::string>("propagatorOppositeTISE", "PropagatorWithMaterialOpposite");
    desc.add<edm::ParameterSetDescription>("TransientInitialStateEstimatorParameters", psd0);
  }

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

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

  {
    edm::ParameterSetDescription psd0;
    psd0.add<double>("minSCEtBarrel", 0.0);
    psd0.add<double>("minSCEtEndcaps", 0.0);
    psd0.add<double>("minEOverPBarrel", 0.0);
    psd0.add<double>("minEOverPEndcaps", 0.0);
    psd0.add<double>("maxEOverPBarrel", 999999999.0);
    psd0.add<double>("maxEOverPEndcaps", 999999999.0);
    psd0.add<double>("maxDeltaEtaBarrel", 999999999.0);
    psd0.add<double>("maxDeltaEtaEndcaps", 999999999.0);
    psd0.add<double>("maxDeltaPhiBarrel", 999999999.0);
    psd0.add<double>("maxDeltaPhiEndcaps", 999999999.0);
    psd0.add<double>("hOverEConeSize", 0.15);
    psd0.add<double>("hOverEPtMin", 0.0);
    psd0.add<double>("maxHOverEBarrelCone", 999999999.0);
    psd0.add<double>("maxHOverEEndcapsCone", 999999999.0);
    psd0.add<double>("maxHBarrelCone", 0.0);
    psd0.add<double>("maxHEndcapsCone", 0.0);
    psd0.add<double>("maxHOverEBarrelTower", 999999999.0);
    psd0.add<double>("maxHOverEEndcapsTower", 999999999.0);
    psd0.add<double>("maxHBarrelTower", 0.0);
    psd0.add<double>("maxHEndcapsTower", 0.0);
    psd0.add<double>("maxSigmaIetaIetaBarrel", 999999999.0);
    psd0.add<double>("maxSigmaIetaIetaEndcaps", 999999999.0);
    psd0.add<double>("maxFbremBarrel", 999999999.0);
    psd0.add<double>("maxFbremEndcaps", 999999999.0);
    psd0.add<bool>("isBarrel", false);
    psd0.add<bool>("isEndcaps", false);
    psd0.add<bool>("isFiducial", false);
    psd0.add<bool>("seedFromTEC", true);
    psd0.add<double>("maxTIP", 999999999.0);
    psd0.add<double>("minMVA", -0.4);
    psd0.add<double>("minMvaByPassForIsolated", -0.4);
    // preselection parameters (ecal driven electrons)
    desc.add<edm::ParameterSetDescription>("preselection", psd0);
    // preselection parameters (tracker driven only electrons)
    desc.add<edm::ParameterSetDescription>("preselectionPflow", psd0);
  }

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

  desc.add<bool>("ecalWeightsFromDB", true);
  desc.add<std::vector<std::string>>("ecalRefinedRegressionWeightFiles", {})
      ->setComment("if not from DB. Otherwise, keep empty");
  desc.add<bool>("combinationWeightsFromDB", true);
  desc.add<std::vector<std::string>>("combinationRegressionWeightFile", {})
      ->setComment("if not from DB. Otherwise, keep empty");

  // regression. The labels are needed in all cases.
  desc.add<std::vector<std::string>>("ecalRefinedRegressionWeightLabels", {});
  desc.add<std::vector<std::string>>("combinationRegressionWeightLabels", {});

  // Iso values
  desc.add<bool>("useIsolationValues", false);

  {
    edm::ParameterSetDescription psd0;
    psd0.add<edm::InputTag>("edSumPhotonEt", edm::InputTag("elEDIsoValueGamma04"));
    psd0.add<edm::InputTag>("edSumNeutralHadronEt", edm::InputTag("elEDIsoValueNeutral04"));
    psd0.add<edm::InputTag>("edSumChargedHadronPt", edm::InputTag("elEDIsoValueCharged04"));
    desc.add<edm::ParameterSetDescription>("edIsolationValues", psd0);
  }
  {
    edm::ParameterSetDescription psd0;
    psd0.add<edm::InputTag>("pfSumNeutralHadronEt", edm::InputTag("elPFIsoValueNeutral04"));
    psd0.add<edm::InputTag>("pfSumChargedHadronPt", edm::InputTag("elPFIsoValueCharged04"));
    psd0.add<edm::InputTag>("pfSumPhotonEt", edm::InputTag("elPFIsoValueGamma04"));
    desc.add<edm::ParameterSetDescription>("pfIsolationValues", psd0);
  }

  desc.add<std::vector<std::string>>(
      "ElecMVAFilesString",
      {
          "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_10_17Feb2011.weights.xml",
          "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_12_17Feb2011.weights.xml",
          "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_20_17Feb2011.weights.xml",
          "RecoEgamma/ElectronIdentification/data/TMVA_Category_BDTSimpleCat_22_17Feb2011.weights.xml",
      });
  desc.add<std::vector<std::string>>(
      "SoftElecMVAFilesString",
      {
          "RecoEgamma/ElectronIdentification/data/TMVA_BDTSoftElectrons_7Feb2014.weights.xml",
      });

  descriptions.addDefault(desc);
}

void GsfElectronBaseProducer::fillEvent ( reco::GsfElectronCollection &  electrons, edm::Event &  event  )

protected

Definition at line 391 of file GsfElectronBaseProducer.cc.

References reco::GsfElectron::ambiguous(), GsfElectronAlgo::StrategyConfiguration::applyAmbResolution, GsfElectronAlgo::StrategyConfiguration::applyPreselection, electronPutToken_, isPreselected(), eostools::move(), orphanHandle_, setAmbiguityData(), and strategyCfg_.

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

                                                                                             {
  // all electrons
  logElectrons(electrons, event, "GsfElectronAlgo Info (before preselection)");
  // preselection
  if (strategyCfg_.applyPreselection) {
    electrons.erase(
        std::remove_if(electrons.begin(), electrons.end(), [this](auto const& ele) { return !isPreselected(ele); }),
        electrons.end());
    logElectrons(electrons, event, "GsfElectronAlgo Info (after preselection)");
  }
  // ambiguity
  setAmbiguityData(electrons, event);
  if (strategyCfg_.applyAmbResolution) {
    electrons.erase(std::remove_if(electrons.begin(), electrons.end(), std::mem_fn(&reco::GsfElectron::ambiguous)),
                    electrons.end());
    logElectrons(electrons, event, "GsfElectronAlgo Info (after amb. solving)");
  }
  // final filling
  orphanHandle_ = event.emplace(electronPutToken_, std::move(electrons));
}

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

inlinestatic

Definition at line 37 of file GsfElectronBaseProducer.h.

{}

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

inlinestatic

Definition at line 33 of file GsfElectronBaseProducer.h.

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

bool GsfElectronBaseProducer::isPreselected ( reco::GsfElectron const &  ele ) const

private

Definition at line 547 of file GsfElectronBaseProducer.cc.

References DEFINE_FWK_MODULE, reco::GsfElectron::ecalDrivenSeed(), GsfElectronAlgo::StrategyConfiguration::gedElectronMode, GsfElectronAlgo::StrategyConfiguration::MaxElePtForOnlyMVA, reco::GsfElectron::passingCutBasedPreselection(), reco::GsfElectron::passingMvaPreselection(), reco::GsfElectron::passingPflowPreselection(), reco::LeafCandidate::pt(), and strategyCfg_.

Referenced by fillEvent(), and setAmbiguityData().

                                                                        {
  bool passCutBased = ele.passingCutBasedPreselection();
  bool passPF = ele.passingPflowPreselection();
  // it is worth nothing for gedGsfElectrons, this does nothing as its not set
  // till GedGsfElectron finaliser, this is always false
  if (strategyCfg_.gedElectronMode) {
    bool passmva = ele.passingMvaPreselection();
    if (!ele.ecalDrivenSeed()) {
      if (ele.pt() > strategyCfg_.MaxElePtForOnlyMVA)
        return passmva && passCutBased;
      else
        return passmva;
    } else
      return (passCutBased || passPF || passmva);
  } else {
    return passCutBased || passPF;
  }

  return true;
}

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

inlineprotected

Definition at line 51 of file GsfElectronBaseProducer.h.

Referenced by GEDGsfElectronProducer::fillGsfElectronValueMap().

{ return orphanHandle_; }

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

inlineoverride

Definition at line 40 of file GsfElectronBaseProducer.h.

References pwdgSkimBPark_cfi::electrons, and ntuple::fillEvent().

                                                                     {
    reco::GsfElectronCollection electrons;
    algo_->completeElectrons(electrons, event, setup, globalCache());
    fillEvent(electrons, event);
  }

void GsfElectronBaseProducer::setAmbiguityData ( reco::GsfElectronCollection &  electrons, edm::Event const &  event, bool  ignoreNotPreselected = true  ) const

private

Definition at line 449 of file GsfElectronBaseProducer.cc.

References GsfElectronAlgo::StrategyConfiguration::ambClustersOverlapStrategy, GsfElectronAlgo::StrategyConfiguration::ambSortingStrategy, GsfElectronAlgo::Tokens::barrelRecHitCollection, HLT_2018_cff::barrelRecHits, GsfElectronAlgo::Tokens::beamSpotTag, StorageManager_cfg::e1, metsig::electron, photonAnalyzer_cfi::eMin, GsfElectronAlgo::Tokens::endcapRecHitCollection, HLT_2018_cff::endcapRecHits, PVValHelper::eta, Exception, newFWLiteAna::found, edm::Ref< C, T, F >::get(), uncleanedOnlyElectronSequence_cff::gsfPfRecTracks, GsfElectronAlgo::Tokens::gsfPfRecTracksTag, inputCfg_, egamma::isBetterElectron(), egamma::isInnermostElectron(), isPreselected(), LogDebug, egamma::sharedEnergy(), strategyCfg_, MessageLogger_cff::threshold, and GsfElectronAlgo::StrategyConfiguration::useGsfPfRecTracks.

Referenced by fillEvent().

                                                                                {
  // Getting required event data
  auto const& beamspot = event.get(inputCfg_.beamSpotTag);
  auto gsfPfRecTracks = strategyCfg_.useGsfPfRecTracks ? event.getHandle(inputCfg_.gsfPfRecTracksTag)
                                                       : edm::Handle<reco::GsfPFRecTrackCollection>{};
  auto const& barrelRecHits = event.get(inputCfg_.barrelRecHitCollection);
  auto const& endcapRecHits = event.get(inputCfg_.endcapRecHitCollection);

  if (strategyCfg_.ambSortingStrategy == 0) {
    std::sort(electrons.begin(), electrons.end(), egamma::isBetterElectron);
  } else if (strategyCfg_.ambSortingStrategy == 1) {
    std::sort(electrons.begin(), electrons.end(), egamma::isInnermostElectron);
  } else {
    throw cms::Exception("GsfElectronAlgo|UnknownAmbiguitySortingStrategy")
        << "value of strategyCfg_.ambSortingStrategy is : " << strategyCfg_.ambSortingStrategy;
  }

  // init
  for (auto& electron : electrons) {
    electron.clearAmbiguousGsfTracks();
    electron.setAmbiguous(false);
  }

  // get ambiguous from GsfPfRecTracks
  if (strategyCfg_.useGsfPfRecTracks) {
    for (auto& e1 : electrons) {
      bool found = false;
      for (auto const& gsfPfRecTrack : *gsfPfRecTracks.product()) {
        if (gsfPfRecTrack.gsfTrackRef() == e1.gsfTrack()) {
          if (found) {
            edm::LogWarning("GsfElectronAlgo") << "associated gsfPfRecTrack already found";
          } else {
            found = true;
            for (auto const& duplicate : gsfPfRecTrack.convBremGsfPFRecTrackRef()) {
              e1.addAmbiguousGsfTrack(duplicate->gsfTrackRef());
            }
          }
        }
      }
    }
  }
  // or search overlapping clusters
  else {
    for (auto e1 = electrons.begin(); e1 != electrons.end(); ++e1) {
      if (e1->ambiguous())
        continue;
      if (ignoreNotPreselected && !isPreselected(*e1))
        continue;

      SuperClusterRef scRef1 = e1->superCluster();
      CaloClusterPtr eleClu1 = e1->electronCluster();
      LogDebug("GsfElectronAlgo") << "Blessing electron with E/P " << e1->eSuperClusterOverP() << ", cluster "
                                  << scRef1.get() << " & track " << e1->gsfTrack().get();

      for (auto e2 = e1 + 1; e2 != electrons.end(); ++e2) {
        if (e2->ambiguous())
          continue;
        if (ignoreNotPreselected && !isPreselected(*e2))
          continue;

        SuperClusterRef scRef2 = e2->superCluster();
        CaloClusterPtr eleClu2 = e2->electronCluster();

        // search if same cluster
        bool sameCluster = false;
        if (strategyCfg_.ambClustersOverlapStrategy == 0) {
          sameCluster = (scRef1 == scRef2);
        } else if (strategyCfg_.ambClustersOverlapStrategy == 1) {
          float eMin = 1.;
          float threshold = eMin * cosh(EleRelPoint(scRef1->position(), beamspot.position()).eta());
          using egamma::sharedEnergy;
          sameCluster = ((sharedEnergy(*eleClu1, *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
                         (sharedEnergy(*scRef1->seed(), *eleClu2, barrelRecHits, endcapRecHits) >= threshold) ||
                         (sharedEnergy(*eleClu1, *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold) ||
                         (sharedEnergy(*scRef1->seed(), *scRef2->seed(), barrelRecHits, endcapRecHits) >= threshold));
        } else {
          throw cms::Exception("GsfElectronAlgo|UnknownAmbiguityClustersOverlapStrategy")
              << "value of strategyCfg_.ambClustersOverlapStrategy is : " << strategyCfg_.ambClustersOverlapStrategy;
        }

        // main instructions
        if (sameCluster) {
          LogDebug("GsfElectronAlgo") << "Discarding electron with E/P " << e2->eSuperClusterOverP() << ", cluster "
                                      << scRef2.get() << " and track " << e2->gsfTrack().get();
          e1->addAmbiguousGsfTrack(e2->gsfTrack());
          e2->setAmbiguous(true);
        } else if (e1->gsfTrack() == e2->gsfTrack()) {
          edm::LogWarning("GsfElectronAlgo") << "Forgetting electron with E/P " << e2->eSuperClusterOverP()
                                             << ", cluster " << scRef2.get() << " and track " << e2->gsfTrack().get();
          e2->setAmbiguous(true);
        }
      }
    }
  }
}

Member Data Documentation

std::unique_ptr<GsfElectronAlgo> GsfElectronBaseProducer::algo_

protected

Definition at line 47 of file GsfElectronBaseProducer.h.

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

const GsfElectronAlgo::CutsConfiguration GsfElectronBaseProducer::cutsCfg_

protected

Definition at line 56 of file GsfElectronBaseProducer.h.

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

const GsfElectronAlgo::CutsConfiguration GsfElectronBaseProducer::cutsCfgPflow_

protected

Definition at line 57 of file GsfElectronBaseProducer.h.

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

bool GsfElectronBaseProducer::ecalSeedingParametersChecked_

private

Definition at line 75 of file GsfElectronBaseProducer.h.

Referenced by beginEvent().

edm::ParameterSet GsfElectronBaseProducer::edIsoVals_

protected

Definition at line 66 of file GsfElectronBaseProducer.h.

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

const edm::EDPutTokenT<reco::GsfElectronCollection> GsfElectronBaseProducer::electronPutToken_

private

Definition at line 79 of file GsfElectronBaseProducer.h.

Referenced by fillEvent().

ElectronHcalHelper::Configuration GsfElectronBaseProducer::hcalCfg_

protected

Definition at line 58 of file GsfElectronBaseProducer.h.

Referenced by checkEcalSeedingParameters(), and GsfElectronBaseProducer().

ElectronHcalHelper::Configuration GsfElectronBaseProducer::hcalCfgPflow_

protected

Definition at line 59 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronBaseProducer().

GsfElectronAlgo::Tokens GsfElectronBaseProducer::inputCfg_

protected

Definition at line 54 of file GsfElectronBaseProducer.h.

Referenced by GsfElectronProducer::addPflowInfo(), beginEvent(), GsfElectronProducer::clonePreviousElectrons(), GsfElectronBaseProducer(), GEDGsfElectronProducer::produce(), and setAmbiguityData().

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

private

Definition at line 77 of file GsfElectronBaseProducer.h.

Referenced by fillEvent().

edm::ParameterSet GsfElectronBaseProducer::pfIsoVals_

protected

Definition at line 65 of file GsfElectronBaseProducer.h.

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

edm::EDGetTokenT<edm::ValueMap<float> > GsfElectronBaseProducer::pfMVA_

protected

Definition at line 62 of file GsfElectronBaseProducer.h.

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

GsfElectronAlgo::StrategyConfiguration GsfElectronBaseProducer::strategyCfg_

protected

Definition at line 55 of file GsfElectronBaseProducer.h.

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