PFElectronTranslator Class Reference

Inheritance diagram for PFElectronTranslator:

Public Types
typedef std::vector< edm::Handle< edm::ValueMap< double > > >	IsolationValueMaps
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Member Functions
	PFElectronTranslator (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~PFElectronTranslator () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
const reco::PFCandidate &	correspondingDaughterCandidate (const reco::PFCandidate &cand, const reco::PFBlockElement &pfbe) const
void	createBasicCluster (const reco::PFBlockElement &, reco::BasicClusterCollection &basicClusters, std::vector< const reco::PFCluster * > &, const reco::PFCandidate &coCandidate) const
void	createBasicClusterPtrs (const edm::OrphanHandle< reco::BasicClusterCollection > &basicClustersHandle)
void	createGsfElectronCoreRefs (const edm::OrphanHandle< reco::GsfElectronCoreCollection > &gsfElectronCoreHandle)
void	createGsfElectronCores (reco::GsfElectronCoreCollection &) const
void	createGsfElectrons (const reco::PFCandidateCollection &, const IsolationValueMaps &isolationValues, reco::GsfElectronCollection &)
void	createPreshowerCluster (const reco::PFBlockElement &PFBE, reco::PreshowerClusterCollection &preshowerClusters, unsigned plane) const
void	createPreshowerClusterPtrs (const edm::OrphanHandle< reco::PreshowerClusterCollection > &preshowerClustersHandle)
void	createSuperClusterGsfMapRefs (const edm::OrphanHandle< reco::SuperClusterCollection > &superClustersHandle)
void	createSuperClusters (const reco::PFCandidateCollection &, reco::SuperClusterCollection &superClusters) const
bool	fetchCandidateCollection (edm::Handle< reco::PFCandidateCollection > &c, const edm::InputTag &tag, const edm::Event &iEvent) const
void	fetchGsfCollection (edm::Handle< reco::GsfTrackCollection > &c, const edm::InputTag &tag, const edm::Event &iEvent) const
void	fillMVAValueMap (edm::Event &iEvent, edm::ValueMap< float >::Filler &filler)
void	fillSCRefValueMap (edm::Event &iEvent, edm::ValueMap< reco::SuperClusterRef >::Filler &filler) const
void	fillValueMap (edm::Event &iEvent, edm::ValueMap< float >::Filler &filler) const
void	getAmbiguousGsfTracks (const reco::PFBlockElement &PFBE, std::vector< reco::GsfTrackRef > &) const

Private Attributes
std::vector< std::vector< reco::GsfTrackRef > >	ambiguousGsfTracks_
std::vector< reco::CaloClusterPtrVector >	basicClusterPtr_
std::vector< reco::BasicClusterCollection >	basicClusters_
std::vector< reco::CandidatePtr >	CandidatePtr_
bool	checkStatusFlag_
bool	emptyIsOk_
std::string	GsfElectronCollection_
std::string	GsfElectronCoreCollection_
std::vector< reco::GsfElectronCoreRef >	gsfElectronCoreRefs_
std::map< reco::GsfTrackRef, float >	gsfMvaMap_
std::vector< int >	gsfPFCandidateIndex_
std::vector< reco::GsfTrackRef >	GsfTrackRef_
edm::InputTag	inputTagGSFTracks_
std::vector< edm::InputTag >	inputTagIsoVals_
edm::InputTag	inputTagPFCandidateElectrons_
edm::InputTag	inputTagPFCandidates_
std::vector< reco::TrackRef >	kfTrackRef_
double	MVACut_
std::string	PFBasicClusterCollection_
std::vector< std::vector< const reco::PFCluster * > >	pfClusters_
std::string	PFMVAValueMap_
std::string	PFPreshowerClusterCollection_
std::string	PFSCValueMap_
std::string	PFSuperClusterCollection_
std::vector< reco::CaloClusterPtrVector >	preshowerClusterPtr_
std::vector< reco::PreshowerClusterCollection >	preshowerClusters_
std::map< reco::GsfTrackRef, reco::SuperClusterRef >	scMap_
std::vector< reco::SuperClusterCollection >	superClusters_

Detailed Description

Definition at line 34 of file PFElectronTranslator.cc.

Member Typedef Documentation

typedef std::vector<edm::Handle<edm::ValueMap<double> > > PFElectronTranslator::IsolationValueMaps

Definition at line 41 of file PFElectronTranslator.cc.

Constructor & Destructor Documentation

PFElectronTranslator::PFElectronTranslator ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 145 of file PFElectronTranslator.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, and gedGsfElectrons_cfi::useIsolationValues.

                                                                         {
  inputTagPFCandidates_ = iConfig.getParameter<edm::InputTag>("PFCandidate");
  inputTagPFCandidateElectrons_ = iConfig.getParameter<edm::InputTag>("PFCandidateElectron");
  inputTagGSFTracks_ = iConfig.getParameter<edm::InputTag>("GSFTracks");

  bool useIsolationValues = iConfig.getParameter<bool>("useIsolationValues");
  if (useIsolationValues) {
    if (!iConfig.exists("isolationValues"))
      throw cms::Exception("PFElectronTranslator|InternalError") << "Missing ParameterSet isolationValues";
    else {
      edm::ParameterSet isoVals = iConfig.getParameter<edm::ParameterSet>("isolationValues");
      inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumChargedHadronPt"));
      inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumPhotonEt"));
      inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumNeutralHadronEt"));
      inputTagIsoVals_.push_back(isoVals.getParameter<edm::InputTag>("pfSumPUPt"));
    }
  }

  PFBasicClusterCollection_ = iConfig.getParameter<std::string>("PFBasicClusters");
  PFPreshowerClusterCollection_ = iConfig.getParameter<std::string>("PFPreshowerClusters");
  PFSuperClusterCollection_ = iConfig.getParameter<std::string>("PFSuperClusters");
  GsfElectronCoreCollection_ = iConfig.getParameter<std::string>("PFGsfElectronCore");
  GsfElectronCollection_ = iConfig.getParameter<std::string>("PFGsfElectron");

  PFMVAValueMap_ = iConfig.getParameter<std::string>("ElectronMVA");
  PFSCValueMap_ = iConfig.getParameter<std::string>("ElectronSC");
  MVACut_ = (iConfig.getParameter<edm::ParameterSet>("MVACutBlock")).getParameter<double>("MVACut");
  checkStatusFlag_ = iConfig.getParameter<bool>("CheckStatusFlag");

  if (iConfig.exists("emptyIsOk"))
    emptyIsOk_ = iConfig.getParameter<bool>("emptyIsOk");
  else
    emptyIsOk_ = false;

  produces<reco::BasicClusterCollection>(PFBasicClusterCollection_);
  produces<reco::PreshowerClusterCollection>(PFPreshowerClusterCollection_);
  produces<reco::SuperClusterCollection>(PFSuperClusterCollection_);
  produces<reco::GsfElectronCoreCollection>(GsfElectronCoreCollection_);
  produces<reco::GsfElectronCollection>(GsfElectronCollection_);
  produces<edm::ValueMap<float>>(PFMVAValueMap_);
  produces<edm::ValueMap<reco::SuperClusterRef>>(PFSCValueMap_);
}

PFElectronTranslator::~PFElectronTranslator ( )

override

Definition at line 188 of file PFElectronTranslator.cc.

{}

Member Function Documentation

const reco::PFCandidate & PFElectronTranslator::correspondingDaughterCandidate ( const reco::PFCandidate &  cand, const reco::PFBlockElement &  pfbe  ) const

private

Definition at line 596 of file PFElectronTranslator.cc.

References reco::Candidate::begin(), reco::PFCandidate::elementsInBlocks(), reco::Candidate::end(), and reco::PFBlockElement::index().

                                                                                                                    {
  unsigned refindex = pfbe.index();
  //  std::cout << " N daughters " << cand.numberOfDaughters() << std::endl;
  reco::PFCandidate::const_iterator myDaughterCandidate = cand.begin();
  reco::PFCandidate::const_iterator itend = cand.end();

  for (; myDaughterCandidate != itend; ++myDaughterCandidate) {
    const reco::PFCandidate* myPFCandidate = (const reco::PFCandidate*)&*myDaughterCandidate;
    if (myPFCandidate->elementsInBlocks().size() != 1) {
      //      std::cout << " Daughter with " << myPFCandidate.elementsInBlocks().size()<< " element in block " << std::endl;
      return cand;
    }
    if (myPFCandidate->elementsInBlocks()[0].second == refindex) {
      //      std::cout << " Found it " << cand << std::endl;
      return *myPFCandidate;
    }
  }
  return cand;
}

void PFElectronTranslator::createBasicCluster ( const reco::PFBlockElement &  PFBE, reco::BasicClusterCollection &  basicClusters, std::vector< const reco::PFCluster * > &  pfClusters, const reco::PFCandidate &  coCandidate  ) const

private

Definition at line 385 of file PFElectronTranslator.cc.

References reco::CaloCluster::algo(), reco::CaloCluster::caloID(), reco::PFBlockElement::clusterRef(), reco::CaloCluster::hitsAndFractions(), edm::Ref< C, T, F >::isNull(), reco::CaloCluster::position(), reco::PFCandidate::rawEcalEnergy(), and reco::CaloCluster::seed().

                                                                                        {
  const reco::PFClusterRef& myPFClusterRef = PFBE.clusterRef();
  if (myPFClusterRef.isNull())
    return;

  const reco::PFCluster& myPFCluster(*myPFClusterRef);
  pfClusters.push_back(&myPFCluster);
  //  std::cout << " Creating BC " << myPFCluster.energy() << " " << coCandidate.ecalEnergy() <<" "<<  coCandidate.rawEcalEnergy() <<std::endl;
  //  std::cout << " # hits " << myPFCluster.hitsAndFractions().size() << std::endl;

  //  basicClusters.push_back(reco::CaloCluster(myPFCluster.energy(),
  basicClusters.push_back(reco::CaloCluster(
      //        myPFCluster.energy(),
      coCandidate.rawEcalEnergy(),
      myPFCluster.position(),
      myPFCluster.caloID(),
      myPFCluster.hitsAndFractions(),
      myPFCluster.algo(),
      myPFCluster.seed()));
}

void PFElectronTranslator::createBasicClusterPtrs ( const edm::OrphanHandle< reco::BasicClusterCollection > &  basicClustersHandle )

private

Definition at line 417 of file PFElectronTranslator.cc.

References findQualityFiles::size.

                                                                            {
  unsigned size = GsfTrackRef_.size();
  unsigned basicClusterCounter = 0;
  basicClusterPtr_.resize(size);

  for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
  {
    unsigned nbc = basicClusters_[iGSF].size();
    for (unsigned ibc = 0; ibc < nbc; ++ibc)  // loop on basic clusters
    {
      //      std::cout <<  "Track "<< iGSF << " ref " << basicClusterCounter << std::endl;
      reco::CaloClusterPtr bcPtr(basicClustersHandle, basicClusterCounter);
      basicClusterPtr_[iGSF].push_back(bcPtr);
      ++basicClusterCounter;
    }
  }
}

void PFElectronTranslator::createGsfElectronCoreRefs ( const edm::OrphanHandle< reco::GsfElectronCoreCollection > &  gsfElectronCoreHandle )

private

Definition at line 629 of file PFElectronTranslator.cc.

References findQualityFiles::size.

                                                                                 {
  unsigned size = GsfTrackRef_.size();

  for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
  {
    edm::Ref<reco::GsfElectronCoreCollection> elecCoreRef(gsfElectronCoreHandle, iGSF);
    gsfElectronCoreRefs_.push_back(elecCoreRef);
  }
}

void PFElectronTranslator::createGsfElectronCores ( reco::GsfElectronCoreCollection &  gsfElectronCores ) const

private

Definition at line 617 of file PFElectronTranslator.cc.

References reco::GsfElectronCore::setCtfTrack(), and reco::GsfElectronCore::setParentSuperCluster().

                                                                                                       {
  unsigned nGSF = GsfTrackRef_.size();
  for (unsigned iGSF = 0; iGSF < nGSF; ++iGSF) {
    reco::GsfElectronCore myElectronCore(GsfTrackRef_[iGSF]);
    myElectronCore.setCtfTrack(kfTrackRef_[iGSF], -1.);
    std::map<reco::GsfTrackRef, reco::SuperClusterRef>::const_iterator itcheck = scMap_.find(GsfTrackRef_[iGSF]);
    if (itcheck != scMap_.end())
      myElectronCore.setParentSuperCluster(itcheck->second);
    gsfElectronCores.push_back(myElectronCore);
  }
}

void PFElectronTranslator::createGsfElectrons ( const reco::PFCandidateCollection &  pfcand, const IsolationValueMaps &  isolationValues, reco::GsfElectronCollection &  gsfelectrons  )

private

Definition at line 652 of file PFElectronTranslator.cc.

References reco::GsfElectron::addAmbiguousGsfTrack(), reco::GsfElectron::MvaInput::deltaEta, reco::PFCandidate::deltaP(), reco::GsfElectron::MvaInput::earlyBrem, reco::PFCandidate::electronExtraRef(), reco::GsfElectron::MvaInput::etOutsideMustache, reco::GsfElectron::MvaInput::hadEnergy, reco::GsfElectron::MvaInput::lateBrem, reco::Mustache::MustacheID(), reco::PFCandidateElectronExtra::MVA_DeltaEtaTrackCluster, reco::PFCandidate::mva_e_pi(), reco::GsfElectron::MvaOutput::mva_e_pi, reco::PFCandidateElectronExtra::MVA_FirstBrem, reco::PFCandidateElectronExtra::MVA_LateBrem, reco::GsfElectron::MvaInput::nClusterOutsideMustache, reco::LeafCandidate::p4(), reco::GsfElectron::P4_PFLOW_COMBINATION, reco::GsfElectron::parentSuperCluster(), reco::GsfElectron::setMvaInput(), reco::GsfElectron::setMvaOutput(), reco::GsfElectron::setP4(), reco::GsfElectron::setPfIsolationVariables(), reco::GsfElectron::MvaInput::sigmaEtaEta, findQualityFiles::size, reco::GsfElectron::MvaOutput::status, reco::GsfElectron::PflowIsolationVariables::sumChargedHadronPt, reco::GsfElectron::PflowIsolationVariables::sumNeutralHadronEt, reco::GsfElectron::PflowIsolationVariables::sumPhotonEt, and reco::GsfElectron::PflowIsolationVariables::sumPUPt.

                                                                                       {
  unsigned size = GsfTrackRef_.size();

  for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
  {
    const reco::PFCandidate& pfCandidate(pfcand[gsfPFCandidateIndex_[iGSF]]);
    // Electron
    reco::GsfElectron myElectron(gsfElectronCoreRefs_[iGSF]);
    // Warning set p4 error !
    myElectron.setP4(reco::GsfElectron::P4_PFLOW_COMBINATION, pfCandidate.p4(), pfCandidate.deltaP(), true);

    // MVA inputs
    reco::GsfElectron::MvaInput myMvaInput;
    myMvaInput.earlyBrem = pfCandidate.electronExtraRef()->mvaVariable(reco::PFCandidateElectronExtra::MVA_FirstBrem);
    myMvaInput.lateBrem = pfCandidate.electronExtraRef()->mvaVariable(reco::PFCandidateElectronExtra::MVA_LateBrem);
    myMvaInput.deltaEta =
        pfCandidate.electronExtraRef()->mvaVariable(reco::PFCandidateElectronExtra::MVA_DeltaEtaTrackCluster);
    myMvaInput.sigmaEtaEta = pfCandidate.electronExtraRef()->sigmaEtaEta();
    myMvaInput.hadEnergy = pfCandidate.electronExtraRef()->hadEnergy();

    // Mustache
    reco::Mustache myMustache;
    myMustache.MustacheID(
        *(myElectron.parentSuperCluster()), myMvaInput.nClusterOutsideMustache, myMvaInput.etOutsideMustache);

    myElectron.setMvaInput(myMvaInput);

    // MVA output
    reco::GsfElectron::MvaOutput myMvaOutput;
    myMvaOutput.status = pfCandidate.electronExtraRef()->electronStatus();
    myMvaOutput.mva_e_pi = pfCandidate.mva_e_pi();
    myElectron.setMvaOutput(myMvaOutput);

    // ambiguous tracks
    unsigned ntracks = ambiguousGsfTracks_[iGSF].size();
    for (unsigned it = 0; it < ntracks; ++it) {
      myElectron.addAmbiguousGsfTrack(ambiguousGsfTracks_[iGSF][it]);
    }

    // isolation
    if (!isolationValues.empty()) {
      reco::GsfElectron::PflowIsolationVariables myPFIso;
      myPFIso.sumChargedHadronPt = (*isolationValues[0])[CandidatePtr_[iGSF]];
      myPFIso.sumPhotonEt = (*isolationValues[1])[CandidatePtr_[iGSF]];
      myPFIso.sumNeutralHadronEt = (*isolationValues[2])[CandidatePtr_[iGSF]];
      myPFIso.sumPUPt = (*isolationValues[3])[CandidatePtr_[iGSF]];
      myElectron.setPfIsolationVariables(myPFIso);
    }

    gsfelectrons.push_back(myElectron);
  }
}

void PFElectronTranslator::createPreshowerCluster ( const reco::PFBlockElement &  PFBE, reco::PreshowerClusterCollection &  preshowerClusters, unsigned  plane  ) const

private

Definition at line 409 of file PFElectronTranslator.cc.

References reco::PFBlockElement::clusterRef().

                                                                        {
  const reco::PFClusterRef& myPFClusterRef = PFBE.clusterRef();
  preshowerClusters.push_back(reco::PreshowerCluster(
      myPFClusterRef->energy(), myPFClusterRef->position(), myPFClusterRef->hitsAndFractions(), plane));
}

void PFElectronTranslator::createPreshowerClusterPtrs ( const edm::OrphanHandle< reco::PreshowerClusterCollection > &  preshowerClustersHandle )

private

Definition at line 436 of file PFElectronTranslator.cc.

References findQualityFiles::size.

                                                                                    {
  unsigned size = GsfTrackRef_.size();
  unsigned psClusterCounter = 0;
  preshowerClusterPtr_.resize(size);

  for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
  {
    unsigned nbc = preshowerClusters_[iGSF].size();
    for (unsigned ibc = 0; ibc < nbc; ++ibc)  // loop on basic clusters
    {
      //      std::cout <<  "Track "<< iGSF << " ref " << basicClusterCounter << std::endl;
      reco::CaloClusterPtr psPtr(preshowerClustersHandle, psClusterCounter);
      preshowerClusterPtr_[iGSF].push_back(psPtr);
      ++psClusterCounter;
    }
  }
}

void PFElectronTranslator::createSuperClusterGsfMapRefs ( const edm::OrphanHandle< reco::SuperClusterCollection > &  superClustersHandle )

private

Definition at line 455 of file PFElectronTranslator.cc.

References findQualityFiles::size.

                                                                            {
  unsigned size = GsfTrackRef_.size();

  for (unsigned iGSF = 0; iGSF < size; ++iGSF)  // loop on tracks
  {
    edm::Ref<reco::SuperClusterCollection> scRef(superClustersHandle, iGSF);
    scMap_[GsfTrackRef_[iGSF]] = scRef;
  }
}

void PFElectronTranslator::createSuperClusters ( const reco::PFCandidateCollection &  pfCand, reco::SuperClusterCollection &  superClusters  ) const

private

Definition at line 520 of file PFElectronTranslator.cc.

References reco::SuperCluster::addCluster(), reco::CaloCluster::addHitAndFraction(), reco::SuperCluster::addPreshowerCluster(), MillePedeFileConverter_cfg::e, PFClusterWidthAlgo::pflowEtaWidth(), PFClusterWidthAlgo::pflowPhiWidth(), RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, reco::SuperCluster::rawEnergy(), reco::SuperCluster::setEtaWidth(), reco::SuperCluster::setPhiWidth(), reco::SuperCluster::setPreshowerEnergy(), and reco::SuperCluster::setSeed().

                                                                                                {
  unsigned nGSF = GsfTrackRef_.size();
  for (unsigned iGSF = 0; iGSF < nGSF; ++iGSF) {
    // Computes energy position a la e/gamma
    double sclusterE = 0;
    double posX = 0.;
    double posY = 0.;
    double posZ = 0.;

    unsigned nbasics = basicClusters_[iGSF].size();
    for (unsigned ibc = 0; ibc < nbasics; ++ibc) {
      double e = basicClusters_[iGSF][ibc].energy();
      sclusterE += e;
      posX += e * basicClusters_[iGSF][ibc].position().X();
      posY += e * basicClusters_[iGSF][ibc].position().Y();
      posZ += e * basicClusters_[iGSF][ibc].position().Z();
    }
    posX /= sclusterE;
    posY /= sclusterE;
    posZ /= sclusterE;

    if (pfCand[gsfPFCandidateIndex_[iGSF]].gsfTrackRef() != GsfTrackRef_[iGSF]) {
      edm::LogError("PFElectronTranslator") << " Major problem in PFElectron Translator" << std::endl;
    }

    // compute the width
    PFClusterWidthAlgo pfwidth(pfClusters_[iGSF]);

    double correctedEnergy = pfCand[gsfPFCandidateIndex_[iGSF]].ecalEnergy();
    reco::SuperCluster mySuperCluster(correctedEnergy, math::XYZPoint(posX, posY, posZ));
    // protection against empty basic cluster collection ; the value is -2 in this case
    if (nbasics) {
      //      std::cout << "SuperCluster creation; energy " << pfCand[gsfPFCandidateIndex_[iGSF]].ecalEnergy();
      //      std::cout << " " <<   pfCand[gsfPFCandidateIndex_[iGSF]].rawEcalEnergy() << std::endl;
      //      std::cout << "Seed energy from basic " << basicClusters_[iGSF][0].energy() << std::endl;
      mySuperCluster.setSeed(basicClusterPtr_[iGSF][0]);
    } else {
      //      std::cout << "SuperCluster creation ; seed energy " << 0 << std::endl;
      //      std::cout << "SuperCluster creation ; energy " << pfCand[gsfPFCandidateIndex_[iGSF]].ecalEnergy();
      //      std::cout << " " <<   pfCand[gsfPFCandidateIndex_[iGSF]].rawEcalEnergy() << std::endl;
      //      std::cout << " No seed found " << 0 << std::endl;
      //      std::cout << " MVA " << pfCand[gsfPFCandidateIndex_[iGSF]].mva_e_pi() << std::endl;
      mySuperCluster.setSeed(reco::CaloClusterPtr());
    }
    // the seed should be the first basic cluster

    for (unsigned ibc = 0; ibc < nbasics; ++ibc) {
      mySuperCluster.addCluster(basicClusterPtr_[iGSF][ibc]);
      //      std::cout <<"Adding Ref to SC " << basicClusterPtr_[iGSF][ibc].index() << std::endl;
      const std::vector<std::pair<DetId, float>>& v1 = basicClusters_[iGSF][ibc].hitsAndFractions();
      //      std::cout << " Number of cells " << v1.size() << std::endl;
      for (std::vector<std::pair<DetId, float>>::const_iterator diIt = v1.begin(); diIt != v1.end(); ++diIt) {
        //      std::cout << " Adding DetId " << (diIt->first).rawId() << " " << diIt->second << std::endl;
        mySuperCluster.addHitAndFraction(diIt->first, diIt->second);
      }  // loop over rechits
    }

    unsigned nps = preshowerClusterPtr_[iGSF].size();
    for (unsigned ips = 0; ips < nps; ++ips) {
      mySuperCluster.addPreshowerCluster(preshowerClusterPtr_[iGSF][ips]);
    }

    // Set the preshower energy
    mySuperCluster.setPreshowerEnergy(pfCand[gsfPFCandidateIndex_[iGSF]].pS1Energy() +
                                      pfCand[gsfPFCandidateIndex_[iGSF]].pS2Energy());

    // Set the cluster width
    mySuperCluster.setEtaWidth(pfwidth.pflowEtaWidth());
    mySuperCluster.setPhiWidth(pfwidth.pflowPhiWidth());
    // Force the computation of rawEnergy_ of the reco::SuperCluster
    mySuperCluster.rawEnergy();
    superClusters.push_back(mySuperCluster);
  }
}

bool PFElectronTranslator::fetchCandidateCollection ( edm::Handle< reco::PFCandidateCollection > &  c, const edm::InputTag &  tag, const edm::Event &  iEvent  ) const

private

Definition at line 356 of file PFElectronTranslator.cc.

References runTheMatrix::err, newFWLiteAna::found, and edm::Event::getByLabel().

                                                                                  {
  bool found = iEvent.getByLabel(tag, c);

  if (!found && !emptyIsOk_) {
    std::ostringstream err;
    err << " cannot get PFCandidates: " << tag << std::endl;
    edm::LogError("PFElectronTranslator") << err.str();
  }
  return found;
}

void PFElectronTranslator::fetchGsfCollection ( edm::Handle< reco::GsfTrackCollection > &  c, const edm::InputTag &  tag, const edm::Event &  iEvent  ) const

private

Definition at line 369 of file PFElectronTranslator.cc.

References runTheMatrix::err, Exception, newFWLiteAna::found, and edm::Event::getByLabel().

                                                                            {
  bool found = iEvent.getByLabel(tag, c);

  if (!found) {
    std::ostringstream err;
    err << " cannot get GSFTracks: " << tag << std::endl;
    edm::LogError("PFElectronTranslator") << err.str();
    throw cms::Exception("MissingProduct", err.str());
  }
}

void PFElectronTranslator::fillMVAValueMap ( edm::Event &  iEvent, edm::ValueMap< float >::Filler &  filler  )

private

Definition at line 466 of file PFElectronTranslator.cc.

References reco::PFCandidate::e, reco::PFCandidate::gsfTrackRef(), ecalDrivenGsfElectronCoresFromMultiCl_cff::gsfTracks, mps_fire::i, edm::helper::Filler< Map >::insert(), edm::Ref< C, T, F >::isNull(), reco::PFCandidate::mva_e_pi(), reco::PFCandidate::particleId(), zmumugammaAnalyzer_cfi::pfCandidates, mps_update::status, and contentValuesCheck::values.

                                                                                             {
  gsfMvaMap_.clear();
  edm::Handle<reco::PFCandidateCollection> pfCandidates;
  bool status = fetchCandidateCollection(pfCandidates, inputTagPFCandidateElectrons_, iEvent);

  unsigned ncand = (status) ? pfCandidates->size() : 0;
  for (unsigned i = 0; i < ncand; ++i) {
    const reco::PFCandidate& cand = (*pfCandidates)[i];
    if (cand.particleId() != reco::PFCandidate::e)
      continue;
    if (cand.gsfTrackRef().isNull())
      continue;
    // Fill the MVA map
    gsfMvaMap_[cand.gsfTrackRef()] = cand.mva_e_pi();
  }

  edm::Handle<reco::GsfTrackCollection> gsfTracks;
  fetchGsfCollection(gsfTracks, inputTagGSFTracks_, iEvent);
  unsigned ngsf = gsfTracks->size();
  std::vector<float> values;
  for (unsigned igsf = 0; igsf < ngsf; ++igsf) {
    reco::GsfTrackRef theTrackRef(gsfTracks, igsf);
    std::map<reco::GsfTrackRef, float>::const_iterator itcheck = gsfMvaMap_.find(theTrackRef);
    if (itcheck == gsfMvaMap_.end()) {
      //      edm::LogWarning("PFElectronTranslator") << "MVA Map, missing GSF track ref " << std::endl;
      values.push_back(-99.);
      //      std::cout << " Push_back -99. " << std::endl;
    } else {
      //      std::cout <<  " Value " << itcheck->second << std::endl;
      values.push_back(itcheck->second);
    }
  }
  filler.insert(gsfTracks, values.begin(), values.end());
}

void PFElectronTranslator::fillSCRefValueMap ( edm::Event &  iEvent, edm::ValueMap< reco::SuperClusterRef >::Filler &  filler  ) const

private

Definition at line 501 of file PFElectronTranslator.cc.

References ecalDrivenGsfElectronCoresFromMultiCl_cff::gsfTracks, edm::helper::Filler< Map >::insert(), and contentValuesCheck::values.

                                                                                                   {
  edm::Handle<reco::GsfTrackCollection> gsfTracks;
  fetchGsfCollection(gsfTracks, inputTagGSFTracks_, iEvent);
  unsigned ngsf = gsfTracks->size();
  std::vector<reco::SuperClusterRef> values;
  for (unsigned igsf = 0; igsf < ngsf; ++igsf) {
    reco::GsfTrackRef theTrackRef(gsfTracks, igsf);
    std::map<reco::GsfTrackRef, reco::SuperClusterRef>::const_iterator itcheck = scMap_.find(theTrackRef);
    if (itcheck == scMap_.end()) {
      //      edm::LogWarning("PFElectronTranslator") << "SCRef Map, missing GSF track ref" << std::endl;
      values.push_back(reco::SuperClusterRef());
    } else {
      values.push_back(itcheck->second);
    }
  }
  filler.insert(gsfTracks, values.begin(), values.end());
}

void PFElectronTranslator::fillValueMap ( edm::Event &  iEvent, edm::ValueMap< float >::Filler &  filler  ) const

private

void PFElectronTranslator::getAmbiguousGsfTracks ( const reco::PFBlockElement &  PFBE, std::vector< reco::GsfTrackRef > &  tracks  ) const

private

Definition at line 640 of file PFElectronTranslator.cc.

References reco::PFBlockElementGsfTrack::GsftrackRefPF().

                                                                                           {
  const reco::PFBlockElementGsfTrack* GsfEl = dynamic_cast<const reco::PFBlockElementGsfTrack*>(&PFBE);
  if (GsfEl == nullptr)
    return;
  const std::vector<reco::GsfPFRecTrackRef>& ambPFRecTracks(GsfEl->GsftrackRefPF()->convBremGsfPFRecTrackRef());
  unsigned ntracks = ambPFRecTracks.size();
  for (unsigned it = 0; it < ntracks; ++it) {
    tracks.push_back(ambPFRecTracks[it]->gsfTrackRef());
  }
}

void PFElectronTranslator::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

override

Definition at line 190 of file PFElectronTranslator.cc.

References reco::PFCandidate::e, reco::PFBlockElement::ECAL, reco::PFCandidate::electronExtraRef(), bookConverter::elements, reco::PFCandidate::elementsInBlocks(), edm::Event::getByLabel(), reco::PFBlockElement::GSF, reco::PFCandidate::gsfTrackRef(), mps_fire::i, edm::Ref< C, T, F >::isNull(), electronProducer_cff::isolationValues, dqmiolumiharvest::j, eostools::move(), reco::PFCandidate::mva_e_pi(), reco::PFCandidate::particleId(), zmumugammaAnalyzer_cfi::pfCandidates, reco::PFBlockElement::PS1, reco::PFBlockElement::PS2, edm::Event::put(), reco::PFCandidateElectronExtra::Selected, mps_update::status, reco::PFCandidate::trackRef(), and reco::PFBlockElement::type().

                                                                                {
  auto gsfElectronCores_p = std::make_unique<reco::GsfElectronCoreCollection>();

  auto gsfElectrons_p = std::make_unique<reco::GsfElectronCollection>();

  auto superClusters_p = std::make_unique<reco::SuperClusterCollection>();

  auto basicClusters_p = std::make_unique<reco::BasicClusterCollection>();

  auto psClusters_p = std::make_unique<reco::PreshowerClusterCollection>();

  auto mvaMap_p = std::make_unique<edm::ValueMap<float>>();
  edm::ValueMap<float>::Filler mvaFiller(*mvaMap_p);

  auto scMap_p = std::make_unique<edm::ValueMap<reco::SuperClusterRef>>();
  edm::ValueMap<reco::SuperClusterRef>::Filler scRefFiller(*scMap_p);

  edm::Handle<reco::PFCandidateCollection> pfCandidates;
  bool status = fetchCandidateCollection(pfCandidates, inputTagPFCandidates_, iEvent);

  IsolationValueMaps isolationValues(inputTagIsoVals_.size());
  for (size_t j = 0; j < inputTagIsoVals_.size(); ++j) {
    iEvent.getByLabel(inputTagIsoVals_[j], isolationValues[j]);
  }

  // clear the vectors
  GsfTrackRef_.clear();
  CandidatePtr_.clear();
  ambiguousGsfTracks_.clear();
  kfTrackRef_.clear();
  basicClusters_.clear();
  pfClusters_.clear();
  preshowerClusters_.clear();
  superClusters_.clear();
  basicClusterPtr_.clear();
  preshowerClusterPtr_.clear();
  gsfPFCandidateIndex_.clear();
  gsfElectronCoreRefs_.clear();
  scMap_.clear();

  // loop on the candidates
  //CC@@
  // we need first to create AND put the SuperCluster,
  // basic clusters and presh clusters collection
  // in order to get a working Handle
  unsigned ncand = (status) ? pfCandidates->size() : 0;
  unsigned iGSF = 0;
  for (unsigned i = 0; i < ncand; ++i) {
    const reco::PFCandidate& cand = (*pfCandidates)[i];
    if (cand.particleId() != reco::PFCandidate::e)
      continue;
    if (cand.gsfTrackRef().isNull())
      continue;
    // Note that -1 will still cut some total garbage candidates
    // Fill the MVA map
    if (cand.mva_e_pi() < MVACut_)
      continue;

    // Check the status flag
    if (checkStatusFlag_ && !cand.electronExtraRef()->electronStatus(reco::PFCandidateElectronExtra::Selected)) {
      continue;
    }

    GsfTrackRef_.push_back(cand.gsfTrackRef());
    kfTrackRef_.push_back(cand.trackRef());
    gsfPFCandidateIndex_.push_back(i);

    reco::PFCandidatePtr ptrToPFElectron(pfCandidates, i);
    //CandidatePtr_.push_back(ptrToPFElectron->sourceCandidatePtr(0));
    CandidatePtr_.push_back(ptrToPFElectron);

    basicClusters_.push_back(reco::BasicClusterCollection());
    pfClusters_.push_back(std::vector<const reco::PFCluster*>());
    preshowerClusters_.push_back(reco::PreshowerClusterCollection());
    ambiguousGsfTracks_.push_back(std::vector<reco::GsfTrackRef>());

    for (unsigned iele = 0; iele < cand.elementsInBlocks().size(); ++iele) {
      // first get the block
      reco::PFBlockRef blockRef = cand.elementsInBlocks()[iele].first;
      //
      unsigned elementIndex = cand.elementsInBlocks()[iele].second;
      // check it actually exists
      if (blockRef.isNull())
        continue;

      // then get the elements of the block
      const edm::OwnVector<reco::PFBlockElement>& elements = (*blockRef).elements();

      const reco::PFBlockElement& pfbe(elements[elementIndex]);
      // The first ECAL element should be the cluster associated to the GSF; defined as the seed
      if (pfbe.type() == reco::PFBlockElement::ECAL) {
        //    const reco::PFCandidate * coCandidate = &cand;
        // the Brem photons are saved as daughter PFCandidate; this
        // is convenient to access the corrected energy
        //    std::cout << " Found candidate "  << correspondingDaughterCandidate(coCandidate,pfbe) << " " << coCandidate << std::endl;
        createBasicCluster(pfbe, basicClusters_[iGSF], pfClusters_[iGSF], correspondingDaughterCandidate(cand, pfbe));
      }
      if (pfbe.type() == reco::PFBlockElement::PS1) {
        createPreshowerCluster(pfbe, preshowerClusters_[iGSF], 1);
      }
      if (pfbe.type() == reco::PFBlockElement::PS2) {
        createPreshowerCluster(pfbe, preshowerClusters_[iGSF], 2);
      }
      if (pfbe.type() == reco::PFBlockElement::GSF) {
        getAmbiguousGsfTracks(pfbe, ambiguousGsfTracks_[iGSF]);
      }

    }  // loop on the elements

    // save the basic clusters
    basicClusters_p->insert(basicClusters_p->end(), basicClusters_[iGSF].begin(), basicClusters_[iGSF].end());
    // save the preshower clusters
    psClusters_p->insert(psClusters_p->end(), preshowerClusters_[iGSF].begin(), preshowerClusters_[iGSF].end());

    ++iGSF;
  }  // loop on PFCandidates

  //Save the basic clusters and get an handle as to be able to create valid Refs (thanks to Claude)
  //  std::cout << " Number of basic clusters " << basicClusters_p->size() << std::endl;
  const edm::OrphanHandle<reco::BasicClusterCollection> bcRefProd =
      iEvent.put(std::move(basicClusters_p), PFBasicClusterCollection_);

  //preshower clusters
  const edm::OrphanHandle<reco::PreshowerClusterCollection> psRefProd =
      iEvent.put(std::move(psClusters_p), PFPreshowerClusterCollection_);

  // now that the Basic clusters are in the event, the Ref can be created
  createBasicClusterPtrs(bcRefProd);
  // now that the preshower clusters are in the event, the Ref can be created
  createPreshowerClusterPtrs(psRefProd);

  // and now the Super cluster can be created with valid references
  if (status)
    createSuperClusters(*pfCandidates, *superClusters_p);

  // Let's put the super clusters in the event
  const edm::OrphanHandle<reco::SuperClusterCollection> scRefProd =
      iEvent.put(std::move(superClusters_p), PFSuperClusterCollection_);
  // create the super cluster Ref
  createSuperClusterGsfMapRefs(scRefProd);

  // Now create the GsfElectronCoers
  createGsfElectronCores(*gsfElectronCores_p);
  // Put them in the as to get to be able to build a Ref
  const edm::OrphanHandle<reco::GsfElectronCoreCollection> gsfElectronCoreRefProd =
      iEvent.put(std::move(gsfElectronCores_p), GsfElectronCoreCollection_);

  // now create the Refs
  createGsfElectronCoreRefs(gsfElectronCoreRefProd);

  // now make the GsfElectron
  createGsfElectrons(*pfCandidates, isolationValues, *gsfElectrons_p);
  iEvent.put(std::move(gsfElectrons_p), GsfElectronCollection_);

  fillMVAValueMap(iEvent, mvaFiller);
  mvaFiller.fill();

  fillSCRefValueMap(iEvent, scRefFiller);
  scRefFiller.fill();

  // MVA map
  iEvent.put(std::move(mvaMap_p), PFMVAValueMap_);
  // Gsf-SC map
  iEvent.put(std::move(scMap_p), PFSCValueMap_);
}

Member Data Documentation

std::vector<std::vector<reco::GsfTrackRef> > PFElectronTranslator::ambiguousGsfTracks_

private

Definition at line 119 of file PFElectronTranslator.cc.

std::vector<reco::CaloClusterPtrVector> PFElectronTranslator::basicClusterPtr_

private

Definition at line 129 of file PFElectronTranslator.cc.

std::vector<reco::BasicClusterCollection> PFElectronTranslator::basicClusters_

private

Definition at line 121 of file PFElectronTranslator.cc.

std::vector<reco::CandidatePtr> PFElectronTranslator::CandidatePtr_

private

Definition at line 115 of file PFElectronTranslator.cc.

bool PFElectronTranslator::checkStatusFlag_

private

Definition at line 109 of file PFElectronTranslator.cc.

bool PFElectronTranslator::emptyIsOk_

private

Definition at line 140 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::GsfElectronCollection_

private

Definition at line 107 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::GsfElectronCoreCollection_

private

Definition at line 106 of file PFElectronTranslator.cc.

std::vector<reco::GsfElectronCoreRef> PFElectronTranslator::gsfElectronCoreRefs_

private

Definition at line 133 of file PFElectronTranslator.cc.

std::map<reco::GsfTrackRef, float> PFElectronTranslator::gsfMvaMap_

private

Definition at line 138 of file PFElectronTranslator.cc.

std::vector<int> PFElectronTranslator::gsfPFCandidateIndex_

private

Definition at line 135 of file PFElectronTranslator.cc.

std::vector<reco::GsfTrackRef> PFElectronTranslator::GsfTrackRef_

private

Definition at line 113 of file PFElectronTranslator.cc.

edm::InputTag PFElectronTranslator::inputTagGSFTracks_

private

Definition at line 99 of file PFElectronTranslator.cc.

std::vector<edm::InputTag> PFElectronTranslator::inputTagIsoVals_

private

Definition at line 100 of file PFElectronTranslator.cc.

edm::InputTag PFElectronTranslator::inputTagPFCandidateElectrons_

private

Definition at line 98 of file PFElectronTranslator.cc.

edm::InputTag PFElectronTranslator::inputTagPFCandidates_

private

Definition at line 97 of file PFElectronTranslator.cc.

std::vector<reco::TrackRef> PFElectronTranslator::kfTrackRef_

private

Definition at line 117 of file PFElectronTranslator.cc.

double PFElectronTranslator::MVACut_

private

Definition at line 108 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::PFBasicClusterCollection_

private

Definition at line 101 of file PFElectronTranslator.cc.

std::vector<std::vector<const reco::PFCluster*> > PFElectronTranslator::pfClusters_

private

Definition at line 123 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::PFMVAValueMap_

private

Definition at line 104 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::PFPreshowerClusterCollection_

private

Definition at line 102 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::PFSCValueMap_

private

Definition at line 105 of file PFElectronTranslator.cc.

std::string PFElectronTranslator::PFSuperClusterCollection_

private

Definition at line 103 of file PFElectronTranslator.cc.

std::vector<reco::CaloClusterPtrVector> PFElectronTranslator::preshowerClusterPtr_

private

Definition at line 131 of file PFElectronTranslator.cc.

std::vector<reco::PreshowerClusterCollection> PFElectronTranslator::preshowerClusters_

private

Definition at line 125 of file PFElectronTranslator.cc.

std::map<reco::GsfTrackRef, reco::SuperClusterRef> PFElectronTranslator::scMap_

private

Definition at line 137 of file PFElectronTranslator.cc.

std::vector<reco::SuperClusterCollection> PFElectronTranslator::superClusters_

private

Definition at line 127 of file PFElectronTranslator.cc.