PFCandConnector Class Reference

Based on a class from : V. Roberfroid, February 2008. More...

#include <PFCandConnector.h>

Public Member Functions
reco::PFCandidateCollection	connect (reco::PFCandidateCollection &pfCand) const
	PFCandConnector ()
void	setParameters (bool bCorrect, bool bCalibPrimary, double dptRel_PrimaryTrack, double dptRel_MergedTrack, double ptErrorSecondary, const std::vector< double > &nuclCalibFactors)
void	setParameters (const edm::ParameterSet &iCfgCandConnector)

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

Private Member Functions
void	analyseNuclearWPrim (reco::PFCandidateCollection &, std::vector< bool > &, unsigned int) const
	Analyse nuclear interactions where a primary or merged track is present. More...
void	analyseNuclearWSec (reco::PFCandidateCollection &, std::vector< bool > &, unsigned int) const
	Analyse nuclear interactions where a secondary track is present. More...
bool	isPrimaryNucl (const reco::PFCandidate &pf) const
bool	isSecondaryNucl (const reco::PFCandidate &pf) const
double	rescaleFactor (const double pt, const double cFrac) const
	Return a calibration factor for a reconstructed nuclear interaction. More...

Private Attributes
bool	bCalibPrimary_
	Calibration parameters for the reconstructed nuclear interactions. More...
bool	bCorrect_
	Parameters. More...
double	dptRel_MergedTrack_
double	dptRel_PrimaryTrack_
std::vector< double >	fConst_
std::vector< double >	fExp_
std::vector< double >	fNorm_
double	ptErrorSecondary_

Static Private Attributes
static const reco::PFCandidate::Flags	fT_FROM_DISP_ = PFCandidate::T_FROM_DISP
static const reco::PFCandidate::Flags	fT_TO_DISP_ = PFCandidate::T_TO_DISP
static const double	pion_mass2 = 0.0194
	Useful constants. More...

Detailed Description

Based on a class from : V. Roberfroid, February 2008.

Definition at line 15 of file PFCandConnector.h.

Constructor & Destructor Documentation

PFCandConnector()

PFCandConnector::PFCandConnector ( )

inline

Definition at line 17 of file PFCandConnector.h.

                    {
    bCorrect_ = false;
    bCalibPrimary_ = false;
 
    fConst_.push_back(1), fConst_.push_back(0);
    fNorm_.push_back(0), fNorm_.push_back(0);
    fExp_.push_back(0);
 
    dptRel_PrimaryTrack_ = 0.;
    dptRel_MergedTrack_ = 0.;
    ptErrorSecondary_ = 0.;
  }

References bCalibPrimary_, bCorrect_, dptRel_MergedTrack_, dptRel_PrimaryTrack_, fConst_, fExp_, fNorm_, and ptErrorSecondary_.

Member Function Documentation

analyseNuclearWPrim()

void PFCandConnector::analyseNuclearWPrim ( reco::PFCandidateCollection &  pfCand, std::vector< bool > &  bMask, unsigned int  ce1  ) const

private

Analyse nuclear interactions where a primary or merged track is present.

Definition at line 148 of file PFCandConnector.cc.

                                                                  {
  PFDisplacedVertexRef ref1, ref2, ref1_bis;
 
  PFCandidate primaryCand = pfCand.at(ce1);
 
  // ------- look for the little friends -------- //
 
  const math::XYZTLorentzVectorD& momentumPrim = primaryCand.p4();
 
  math::XYZTLorentzVectorD momentumSec;
 
  momentumSec = momentumPrim / momentumPrim.E() * (primaryCand.ecalEnergy() + primaryCand.hcalEnergy());
 
  map<double, math::XYZTLorentzVectorD> candidatesWithTrackExcess;
  map<double, math::XYZTLorentzVectorD> candidatesWithoutCalo;
 
  ref1 = primaryCand.displacedVertexRef(fT_TO_DISP_);
 
  for (unsigned int ce2 = 0; ce2 < pfCand.size(); ++ce2) {
    if (ce2 != ce1 && isSecondaryNucl(pfCand.at(ce2))) {
      ref2 = (pfCand.at(ce2)).displacedVertexRef(fT_FROM_DISP_);
 
      if (ref1 == ref2) {
        LogTrace("PFCandConnector|analyseNuclearWPrim")
            << "\t here is a Secondary Candidate " << ce2 << " " << pfCand.at(ce2) << endl
            << "\t based on the Track " << pfCand.at(ce2).trackRef().key()
            << " w p = " << pfCand.at(ce2).trackRef()->p() << " w pT = " << pfCand.at(ce2).trackRef()->pt() << " #pm "
            << pfCand.at(ce2).trackRef()->ptError() << " %"
            << " ECAL = " << pfCand.at(ce2).ecalEnergy() << " HCAL = " << pfCand.at(ce2).hcalEnergy()
            << " dE(Trk-CALO) = "
            << pfCand.at(ce2).trackRef()->p() - pfCand.at(ce2).ecalEnergy() - pfCand.at(ce2).hcalEnergy()
            << " Nmissing hits = "
            << pfCand.at(ce2).trackRef()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS) << endl;
 
        if (isPrimaryNucl(pfCand.at(ce2))) {
          LogTrace("PFCandConnector|analyseNuclearWPrim") << "\t\t but it is also a Primary Candidate " << ce2 << endl;
 
          ref1_bis = (pfCand.at(ce2)).displacedVertexRef(fT_TO_DISP_);
          if (ref1_bis.isNonnull())
            analyseNuclearWPrim(pfCand, bMask, ce2);
        }
 
        // Take now the parameters of the secondary track that are relevant and use them to construct the NI candidate
 
        PFCandidate::ElementsInBlocks elementsInBlocks = pfCand.at(ce2).elementsInBlocks();
        PFCandidate::ElementsInBlocks elementsAlreadyInBlocks = pfCand.at(ce1).elementsInBlocks();
        for (unsigned blockElem = 0; blockElem < elementsInBlocks.size(); blockElem++) {
          bool isAlreadyHere = false;
          for (unsigned alreadyBlock = 0; alreadyBlock < elementsAlreadyInBlocks.size(); alreadyBlock++) {
            if (elementsAlreadyInBlocks[alreadyBlock].second == elementsInBlocks[blockElem].second)
              isAlreadyHere = true;
          }
          if (!isAlreadyHere)
            pfCand.at(ce1).addElementInBlock(elementsInBlocks[blockElem].first, elementsInBlocks[blockElem].second);
        }
 
        double caloEn = pfCand.at(ce2).ecalEnergy() + pfCand.at(ce2).hcalEnergy();
        double deltaEn = pfCand.at(ce2).p4().E() - caloEn;
        int nMissOuterHits =
            pfCand.at(ce2).trackRef()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS);
 
        // Check if the difference Track Calo is not too large and if we can trust the track, ie it doesn't miss too much hits.
        if (deltaEn > 1 && nMissOuterHits > 1) {
          math::XYZTLorentzVectorD momentumToAdd = pfCand.at(ce2).p4() * caloEn / pfCand.at(ce2).p4().E();
          momentumSec += momentumToAdd;
          LogTrace("PFCandConnector|analyseNuclearWPrim")
              << "The difference track-calo s really large and the track miss at least 2 hits. A secondary NI may "
                 "have happened. Let's trust the calo energy"
              << endl
              << "add " << momentumToAdd << endl;
 
        } else {
          // Check if the difference Track Calo is not too large and if we can trust the track, ie it doesn't miss too much hits.
          if (caloEn > 0.01 && deltaEn > 1 && nMissOuterHits > 0) {
            math::XYZTLorentzVectorD momentumExcess = pfCand.at(ce2).p4() * deltaEn / pfCand.at(ce2).p4().E();
            candidatesWithTrackExcess[pfCand.at(ce2).trackRef()->pt() / pfCand.at(ce2).trackRef()->ptError()] =
                momentumExcess;
          } else if (caloEn < 0.01)
            candidatesWithoutCalo[pfCand.at(ce2).trackRef()->pt() / pfCand.at(ce2).trackRef()->ptError()] =
                pfCand.at(ce2).p4();
          momentumSec += (pfCand.at(ce2)).p4();
        }
 
        bMask[ce2] = true;
      }
    }
  }
 
  // We have more primary energy than secondary: reject all secondary tracks which have no calo energy attached.
 
  if (momentumPrim.E() < momentumSec.E()) {
    LogTrace("PFCandConnector|analyseNuclearWPrim")
        << "Size of 0 calo Energy secondary candidates" << candidatesWithoutCalo.size() << endl;
    for (map<double, math::XYZTLorentzVectorD>::iterator iter = candidatesWithoutCalo.begin();
         iter != candidatesWithoutCalo.end() && momentumPrim.E() < momentumSec.E();
         iter++)
      if (momentumSec.E() > iter->second.E() + 0.1) {
        momentumSec -= iter->second;
 
        LogTrace("PFCandConnector|analyseNuclearWPrim")
            << "\t Remove a SecondaryCandidate with 0 calo energy " << iter->second << endl;
        LogTrace("PFCandConnector|analyseNuclearWPrim")
            << "momentumPrim.E() = " << momentumPrim.E() << " and momentumSec.E() = " << momentumSec.E() << endl;
      }
  }
 
  if (momentumPrim.E() < momentumSec.E()) {
    LogTrace("PFCandConnector|analyseNuclearWPrim")
        << "0 Calo Energy rejected but still not sufficient. Size of not enough calo Energy secondary candidates"
        << candidatesWithTrackExcess.size() << endl;
    for (map<double, math::XYZTLorentzVectorD>::iterator iter = candidatesWithTrackExcess.begin();
         iter != candidatesWithTrackExcess.end() && momentumPrim.E() < momentumSec.E();
         iter++)
      if (momentumSec.E() > iter->second.E() + 0.1)
        momentumSec -= iter->second;
  }
 
  double dpt = pfCand.at(ce1).trackRef()->ptError() / pfCand.at(ce1).trackRef()->pt() * 100;
 
  if (momentumSec.E() < 0.1) {
    bMask[ce1] = true;
    return;
  }
 
  // Rescale the secondary candidates to account for the loss of energy, but only if we can trust the primary track:
  // if it has more energy than secondaries and is precise enough and secondary exist and was not eaten or rejected during the PFAlgo step.
 
  if (((ref1->isTherePrimaryTracks() && dpt < dptRel_PrimaryTrack_) ||
       (ref1->isThereMergedTracks() && dpt < dptRel_MergedTrack_)) &&
      momentumPrim.E() > momentumSec.E() && momentumSec.E() > 0.1) {
    if (bCalibPrimary_) {
      double factor = rescaleFactor(momentumPrim.Pt(), momentumSec.E() / momentumPrim.E());
      LogTrace("PFCandConnector|analyseNuclearWPrim") << "factor = " << factor << endl;
      if (factor * momentumPrim.Pt() < momentumSec.Pt())
        momentumSec = momentumPrim;
      else
        momentumSec += (1 - factor) * momentumPrim;
    }
 
    double px = momentumPrim.Px() * momentumSec.P() / momentumPrim.P();
    double py = momentumPrim.Py() * momentumSec.P() / momentumPrim.P();
    double pz = momentumPrim.Pz() * momentumSec.P() / momentumPrim.P();
    double E = sqrt(px * px + py * py + pz * pz + pion_mass2);
    math::XYZTLorentzVectorD momentum(px, py, pz, E);
    pfCand.at(ce1).setP4(momentum);
 
    return;
 
  } else {
    math::XYZVector primDir = ref1->primaryDirection();
 
    if (primDir.Mag2() < 0.1) {
      // It might be 0 but this situation should never happend. Throw a warning if it happens.
      edm::LogWarning("PFCandConnector") << "A Nuclear Interaction do not have primary direction" << std::endl;
      pfCand.at(ce1).setP4(momentumSec);
      return;
    } else {
      // rescale the primary direction to the optimal momentum. But take care of the factthat it shall not be completly 0 to avoid a warning if Jet Area.
      double momentumS = momentumSec.P();
      if (momentumS < 1e-4)
        momentumS = 1e-4;
      double px = momentumS * primDir.x();
      double py = momentumS * primDir.y();
      double pz = momentumS * primDir.z();
      double E = sqrt(px * px + py * py + pz * pz + pion_mass2);
 
      math::XYZTLorentzVectorD momentum(px, py, pz, E);
      pfCand.at(ce1).setP4(momentum);
      return;
    }
  }
}

References reco::PFCandidate::displacedVertexRef(), MillePedeFileConverter_cfg::e, reco::PFCandidate::ecalEnergy(), DQMScaleToClient_cfi::factor, dqmdumpme::first, reco::PFCandidate::hcalEnergy(), edm::Ref< C, T, F >::isNonnull(), LogTrace, reco::HitPattern::MISSING_OUTER_HITS, p4, reco::LeafCandidate::p4(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, edm::second(), and mathSSE::sqrt().

analyseNuclearWSec()

void PFCandConnector::analyseNuclearWSec ( reco::PFCandidateCollection &  pfCand, std::vector< bool > &  bMask, unsigned int  ce1  ) const

private

Analyse nuclear interactions where a secondary track is present.

Definition at line 323 of file PFCandConnector.cc.

                                                                 {
  PFDisplacedVertexRef ref1, ref2;
 
  // Check if the track excess was not too large and track may miss some outer hits. This may point to a secondary NI.
 
  double caloEn = pfCand.at(ce1).ecalEnergy() + pfCand.at(ce1).hcalEnergy();
  double deltaEn = pfCand.at(ce1).p4().E() - caloEn;
  int nMissOuterHits = pfCand.at(ce1).trackRef()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS);
 
  ref1 = pfCand.at(ce1).displacedVertexRef(fT_FROM_DISP_);
 
  // ------- check if an electron or a muon vas spotted as incoming track -------- //
  // ------- this mean probably that the NI was fake thus we do not correct it -------- /
 
  if (ref1->isTherePrimaryTracks() || ref1->isThereMergedTracks()) {
    std::vector<reco::Track> refittedTracks = ref1->refittedTracks();
    for (unsigned it = 0; it < refittedTracks.size(); it++) {
      reco::TrackBaseRef primaryBaseRef = ref1->originalTrack(refittedTracks[it]);
      if (ref1->isIncomingTrack(primaryBaseRef))
        LogTrace("PFCandConnector|analyseNuclearWSec")
            << "There is a Primary track ref with pt = " << primaryBaseRef->pt() << endl;
 
      for (unsigned int ce = 0; ce < pfCand.size(); ++ce) {
        //    cout << "PFCand Id = " << (pfCand.at(ce)).particleId() << endl;
        if ((pfCand.at(ce)).particleId() == reco::PFCandidate::e ||
            (pfCand.at(ce)).particleId() == reco::PFCandidate::mu) {
          LogTrace("PFCandConnector|analyseNuclearWSec")
              << " It is an electron and it has a ref to a track " << (pfCand.at(ce)).trackRef().isNonnull() << endl;
 
          if ((pfCand.at(ce)).trackRef().isNonnull()) {
            reco::TrackRef tRef = (pfCand.at(ce)).trackRef();
            reco::TrackBaseRef bRef(tRef);
            LogTrace("PFCandConnector|analyseNuclearWSec")
                << "With Track Ref pt = " << (pfCand.at(ce)).trackRef()->pt() << endl;
 
            if (bRef == primaryBaseRef) {
              if ((pfCand.at(ce)).particleId() == reco::PFCandidate::e)
                LogTrace("PFCandConnector|analyseNuclearWSec")
                    << "It is a NI from electron. NI Discarded. Just release the candidate." << endl;
              if ((pfCand.at(ce)).particleId() == reco::PFCandidate::mu)
                LogTrace("PFCandConnector|analyseNuclearWSec")
                    << "It is a NI from muon. NI Discarded. Just release the candidate" << endl;
 
              // release the track but take care of not overcounting bad tracks. In fact those tracks was protected against destruction in
              // PFAlgo. Now we treat them as if they was treated in PFAlgo
 
              if (caloEn < 0.1 && pfCand.at(ce1).trackRef()->ptError() > ptErrorSecondary_) {
                edm::LogInfo("PFCandConnector|analyseNuclearWSec")
                    << "discarded track since no calo energy and ill measured" << endl;
                bMask[ce1] = true;
              }
              if (caloEn > 0.1 && deltaEn > ptErrorSecondary_ &&
                  pfCand.at(ce1).trackRef()->ptError() > ptErrorSecondary_) {
                edm::LogInfo("PFCandConnector|analyseNuclearWSec")
                    << "rescaled momentum of the track since no calo energy and ill measured" << endl;
 
                double factor = caloEn / pfCand.at(ce1).p4().E();
                pfCand.at(ce1).rescaleMomentum(factor);
              }
 
              return;
            }
          }
        }
      }
    }
  }
 
  PFCandidate secondaryCand = pfCand.at(ce1);
 
  math::XYZTLorentzVectorD momentumSec = secondaryCand.p4();
 
  if (deltaEn > ptErrorSecondary_ && nMissOuterHits > 1) {
    math::XYZTLorentzVectorD momentumToAdd = pfCand.at(ce1).p4() * caloEn / pfCand.at(ce1).p4().E();
    momentumSec = momentumToAdd;
    LogTrace("PFCandConnector|analyseNuclearWSec")
        << "The difference track-calo s really large and the track miss at least 2 hits. A secondary NI may have "
           "happened. Let's trust the calo energy"
        << endl
        << "add " << momentumToAdd << endl;
  }
 
  // ------- look for the little friends -------- //
  for (unsigned int ce2 = ce1 + 1; ce2 < pfCand.size(); ++ce2) {
    if (isSecondaryNucl(pfCand.at(ce2))) {
      ref2 = (pfCand.at(ce2)).displacedVertexRef(fT_FROM_DISP_);
 
      if (ref1 == ref2) {
        LogTrace("PFCandConnector|analyseNuclearWSec")
            << "\t here is a Secondary Candidate " << ce2 << " " << pfCand.at(ce2) << endl
            << "\t based on the Track " << pfCand.at(ce2).trackRef().key()
            << " w pT = " << pfCand.at(ce2).trackRef()->pt() << " #pm " << pfCand.at(ce2).trackRef()->ptError() << " %"
            << " ECAL = " << pfCand.at(ce2).ecalEnergy() << " HCAL = " << pfCand.at(ce2).hcalEnergy()
            << " dE(Trk-CALO) = "
            << pfCand.at(ce2).trackRef()->p() - pfCand.at(ce2).ecalEnergy() - pfCand.at(ce2).hcalEnergy()
            << " Nmissing hits = "
            << pfCand.at(ce2).trackRef()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS) << endl;
 
        // Take now the parameters of the secondary track that are relevant and use them to construct the NI candidate
        PFCandidate::ElementsInBlocks elementsInBlocks = pfCand.at(ce2).elementsInBlocks();
        PFCandidate::ElementsInBlocks elementsAlreadyInBlocks = pfCand.at(ce1).elementsInBlocks();
        for (unsigned blockElem = 0; blockElem < elementsInBlocks.size(); blockElem++) {
          bool isAlreadyHere = false;
          for (unsigned alreadyBlock = 0; alreadyBlock < elementsAlreadyInBlocks.size(); alreadyBlock++) {
            if (elementsAlreadyInBlocks[alreadyBlock].second == elementsInBlocks[blockElem].second)
              isAlreadyHere = true;
          }
          if (!isAlreadyHere)
            pfCand.at(ce1).addElementInBlock(elementsInBlocks[blockElem].first, elementsInBlocks[blockElem].second);
        }
 
        double caloEn = pfCand.at(ce2).ecalEnergy() + pfCand.at(ce2).hcalEnergy();
        double deltaEn = pfCand.at(ce2).p4().E() - caloEn;
        int nMissOuterHits =
            pfCand.at(ce2).trackRef()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS);
        if (deltaEn > ptErrorSecondary_ && nMissOuterHits > 1) {
          math::XYZTLorentzVectorD momentumToAdd = pfCand.at(ce2).p4() * caloEn / pfCand.at(ce2).p4().E();
          momentumSec += momentumToAdd;
          LogTrace("PFCandConnector|analyseNuclearWSec")
              << "The difference track-calo s really large and the track miss at least 2 hits. A secondary NI may "
                 "have happened. Let's trust the calo energy"
              << endl
              << "add " << momentumToAdd << endl;
        } else {
          momentumSec += (pfCand.at(ce2)).p4();
        }
 
        bMask[ce2] = true;
      }
    }
  }
 
  math::XYZVector primDir = ref1->primaryDirection();
 
  if (primDir.Mag2() < 0.1) {
    // It might be 0 but this situation should never happend. Throw a warning if it happens.
    pfCand.at(ce1).setP4(momentumSec);
    edm::LogWarning("PFCandConnector") << "A Nuclear Interaction do not have primary direction" << std::endl;
    return;
  } else {
    // rescale the primary direction to the optimal momentum. But take care of the factthat it shall not be completly 0 to avoid a warning if Jet Area.
    double momentumS = momentumSec.P();
    if (momentumS < 1e-4)
      momentumS = 1e-4;
    double px = momentumS * primDir.x();
    double py = momentumS * primDir.y();
    double pz = momentumS * primDir.z();
    double E = sqrt(px * px + py * py + pz * pz + pion_mass2);
 
    math::XYZTLorentzVectorD momentum(px, py, pz, E);
 
    pfCand.at(ce1).setP4(momentum);
    return;
  }
}

References MillePedeFileConverter_cfg::e, reco::PFCandidate::e, DQMScaleToClient_cfi::factor, dqmdumpme::first, LogTrace, reco::HitPattern::MISSING_OUTER_HITS, reco::PFCandidate::mu, p4, reco::LeafCandidate::p4(), reco::TrackBase::pt(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, tkAlTrackRefitSequence_cff::refittedTracks, edm::second(), and mathSSE::sqrt().

connect()

reco::PFCandidateCollection PFCandConnector::connect

(

reco::PFCandidateCollection &

pfCand

)

const

Collection of primary PFCandidates to be transmitted to the Event

A mask to define the candidates which shall not be transmitted

Definition at line 63 of file PFCandConnector.cc.

                                                                                      {
  PFCandidateCollection pfC{};
  std::vector<bool> bMask;
  bMask.resize(pfCand.size(), false);
 
  // loop on primary
  if (bCorrect_) {
    LogTrace("PFCandConnector|connect") << "pfCand.size()=" << pfCand.size() << "bCalibPrimary_=" << bCalibPrimary_;
 
    for (unsigned int ce1 = 0; ce1 < pfCand.size(); ++ce1) {
      if (isPrimaryNucl(pfCand.at(ce1))) {
        LogTrace("PFCandConnector|connect")
            << "" << endl
            << "Nuclear Interaction w Primary Candidate " << ce1 << " " << pfCand.at(ce1) << endl
            << " based on the Track " << pfCand.at(ce1).trackRef().key()
            << " w pT = " << pfCand.at(ce1).trackRef()->pt() << " #pm "
            << pfCand.at(ce1).trackRef()->ptError() / pfCand.at(ce1).trackRef()->pt() * 100 << " %"
            << " ECAL = " << pfCand.at(ce1).ecalEnergy() << " HCAL = " << pfCand.at(ce1).hcalEnergy() << endl;
 
#ifdef EDM_ML_DEBUG
        (pfCand.at(ce1)).displacedVertexRef(fT_TO_DISP_)->Dump();
#endif
 
        analyseNuclearWPrim(pfCand, bMask, ce1);
 
#ifdef EDM_ML_DEBUG
        LogTrace("PFCandConnector|connect")
            << "After Connection the candidate " << ce1 << " is " << pfCand.at(ce1) << endl
            << endl;
 
        PFCandidate::ElementsInBlocks elementsInBlocks = pfCand.at(ce1).elementsInBlocks();
        for (unsigned blockElem = 0; blockElem < elementsInBlocks.size(); blockElem++) {
          if (blockElem == 0)
            LogTrace("PFCandConnector|connect") << *(elementsInBlocks[blockElem].first) << endl;
          LogTrace("PFCandConnector|connect") << " position " << elementsInBlocks[blockElem].second;
        }
#endif
      }
    }
 
    for (unsigned int ce1 = 0; ce1 < pfCand.size(); ++ce1) {
      if (!bMask[ce1] && isSecondaryNucl(pfCand.at(ce1))) {
        LogTrace("PFCandConnector|connect")
            << "" << endl
            << "Nuclear Interaction w no Primary Candidate " << ce1 << " " << pfCand.at(ce1) << endl
            << " based on the Track " << pfCand.at(ce1).trackRef().key()
            << " w pT = " << pfCand.at(ce1).trackRef()->pt() << " #pm " << pfCand.at(ce1).trackRef()->ptError() << " %"
            << " ECAL = " << pfCand.at(ce1).ecalEnergy() << " HCAL = " << pfCand.at(ce1).hcalEnergy()
            << " dE(Trk-CALO) = "
            << pfCand.at(ce1).trackRef()->p() - pfCand.at(ce1).ecalEnergy() - pfCand.at(ce1).hcalEnergy()
            << " Nmissing hits = "
            << pfCand.at(ce1).trackRef()->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS) << endl;
 
#ifdef EDM_ML_DEBUG
        (pfCand.at(ce1)).displacedVertexRef(fT_FROM_DISP_)->Dump();
#endif
 
        analyseNuclearWSec(pfCand, bMask, ce1);
 
#ifdef EDM_ML_DEBUG
        LogTrace("PFCandConnector|connect") << "After Connection the candidate " << ce1 << " is " << pfCand.at(ce1)
                                            << " and elements connected to it are: " << endl;
 
        PFCandidate::ElementsInBlocks elementsInBlocks = pfCand.at(ce1).elementsInBlocks();
        for (unsigned blockElem = 0; blockElem < elementsInBlocks.size(); blockElem++) {
          if (blockElem == 0)
            LogTrace("PFCandConnector|connect") << *(elementsInBlocks[blockElem].first) << endl;
          LogTrace("PFCandConnector|connect") << " position " << elementsInBlocks[blockElem].second;
        }
#endif
      }
    }
  }
 
  for (unsigned int ce1 = 0; ce1 < pfCand.size(); ++ce1)
    if (!bMask[ce1])
      pfC.push_back(pfCand.at(ce1));
 
  LogTrace("PFCandConnector|connect") << "end of function";
 
  return pfC;
}

References LogTrace, and reco::HitPattern::MISSING_OUTER_HITS.

Referenced by PFAlgo::makeConnectedCandidates(), and o2o_db_cfgmap.DbManagerDAQ::update_hashmap().

fillPSetDescription()

void PFCandConnector::fillPSetDescription ( edm::ParameterSetDescription &  iDesc )

static

Definition at line 554 of file PFCandConnector.cc.

                                                                           {
  iDesc.add<bool>("bCorrect", true);
  iDesc.add<bool>("bCalibPrimary", true);
  iDesc.add<double>("dptRel_PrimaryTrack", 10.0);
  iDesc.add<double>("dptRel_MergedTrack", 5.0);
  iDesc.add<double>("ptErrorSecondary", 1.0);
  iDesc.add<std::vector<double>>("nuclCalibFactors", {0.8, 0.15, 0.5, 0.5, 0.05});
}

References edm::ParameterSetDescription::add().

Referenced by PFProducer::fillDescriptions().

isPrimaryNucl()

bool PFCandConnector::isPrimaryNucl ( const reco::PFCandidate &  pf ) const

private

Definition at line 496 of file PFCandConnector.cc.

                                                               {
  PFDisplacedVertexRef ref1;
 
  // nuclear
  if (pf.flag(fT_TO_DISP_)) {
    ref1 = pf.displacedVertexRef(fT_TO_DISP_);
    //ref1->Dump();
 
    if (!ref1.isNonnull())
      return false;
    else if (ref1->isNucl() || ref1->isNucl_Loose() || ref1->isNucl_Kink())
      return true;
  }
 
  return false;
}

References edm::Ref< C, T, F >::isNonnull(), and packedPFCandidateRefMixer_cfi::pf.

isSecondaryNucl()

bool PFCandConnector::isSecondaryNucl ( const reco::PFCandidate &  pf ) const

private

Definition at line 481 of file PFCandConnector.cc.

                                                                 {
  PFDisplacedVertexRef ref1;
  // nuclear
  if (pf.flag(fT_FROM_DISP_)) {
    ref1 = pf.displacedVertexRef(fT_FROM_DISP_);
    //    ref1->Dump();
    if (!ref1.isNonnull())
      return false;
    else if (ref1->isNucl() || ref1->isNucl_Loose() || ref1->isNucl_Kink())
      return true;
  }
 
  return false;
}

References edm::Ref< C, T, F >::isNonnull(), and packedPFCandidateRefMixer_cfi::pf.

rescaleFactor()

double PFCandConnector::rescaleFactor ( const double  pt, const double  cFrac  ) const

private

Return a calibration factor for a reconstructed nuclear interaction.

Definition at line 513 of file PFCandConnector.cc.

                                                                               {
  /*
    LOG NORMAL FIT
 FCN=35.8181 FROM MIGRAD    STATUS=CONVERGED     257 CALLS         258 TOTAL
 EDM=8.85763e-09    STRATEGY= 1      ERROR MATRIX ACCURATE
  EXT PARAMETER                                   STEP         FIRST
  NO.   NAME      VALUE            ERROR          SIZE      DERIVATIVE
   1  p0           7.99434e-01   2.77264e-02   6.59108e-06   9.80247e-03
   2  p1           1.51303e-01   2.89981e-02   1.16775e-05   6.99035e-03
   3  p2          -5.03829e-01   2.87929e-02   1.90070e-05   1.37015e-03
   4  p3           4.54043e-01   5.00908e-02   3.17625e-05   3.86622e-03
   5  p4          -4.61736e-02   8.07940e-03   3.25775e-06  -1.37247e-02
  */
 
  /*
    FCN=34.4051 FROM MIGRAD    STATUS=CONVERGED     221 CALLS         222 TOTAL
    EDM=1.02201e-09    STRATEGY= 1  ERROR MATRIX UNCERTAINTY   2.3 per cent
 
   fConst
   1  p0           7.99518e-01   2.23519e-02   1.41523e-06   4.05975e-04
   2  p1           1.44619e-01   2.39398e-02  -7.68117e-07  -2.55775e-03
 
   fNorm
   3  p2          -5.16571e-01   3.12362e-02   5.74932e-07   3.42292e-03
   4  p3           4.69055e-01   5.09665e-02   1.94353e-07   1.69031e-03
 
   fExp
   5  p4          -5.18044e-02   8.13458e-03   4.29815e-07  -1.07624e-02
  */
 
  double fConst, fNorm, fExp;
 
  fConst = fConst_[0] + fConst_[1] * cFrac;
  fNorm = fNorm_[0] - fNorm_[1] * cFrac;
  fExp = fExp_[0];
 
  double factor = fConst - fNorm * exp(-fExp * pt);
 
  return factor;
}

References JetChargeProducer_cfi::exp, DQMScaleToClient_cfi::factor, and DiDispStaMuonMonitor_cfi::pt.

setParameters() [1/2]

void PFCandConnector::setParameters	(	bool	bCorrect,
		bool	bCalibPrimary,
		double	dptRel_PrimaryTrack,
		double	dptRel_MergedTrack,
		double	ptErrorSecondary,
		const std::vector< double > &	nuclCalibFactors
	)

Definition at line 15 of file PFCandConnector.cc.

                                                                               {
  bCorrect_ = bCorrect;
  bCalibPrimary_ = bCalibPrimary;
  dptRel_PrimaryTrack_ = dptRel_PrimaryTrack;
  dptRel_MergedTrack_ = dptRel_MergedTrack;
  ptErrorSecondary_ = ptErrorSecondary;
 
  if (nuclCalibFactors.size() == 5) {
    fConst_[0] = nuclCalibFactors[0];
    fConst_[1] = nuclCalibFactors[1];
 
    fNorm_[0] = nuclCalibFactors[2];
    fNorm_[1] = nuclCalibFactors[3];
 
    fExp_[0] = nuclCalibFactors[4];
  } else {
    edm::LogWarning("PFCandConnector")
        << "Wrong calibration factors for nuclear interactions. The calibration procedure would not be applyed."
        << std::endl;
    bCalibPrimary_ = false;
  }
 
  std::string sCorrect = bCorrect_ ? "On" : "Off";
  edm::LogInfo("PFCandConnector") << " ====================== The PFCandConnector is switched " << sCorrect.c_str()
                                  << " ==================== " << std::endl;
  std::string sCalibPrimary = bCalibPrimary_ ? "used for calibration" : "not used for calibration";
  if (bCorrect_)
    edm::LogInfo("PFCandConnector") << "Primary Tracks are " << sCalibPrimary.c_str() << std::endl;
  if (bCorrect_ && bCalibPrimary_)
    edm::LogInfo("PFCandConnector") << "Under the condition that the precision on the Primary track is better than "
                                    << dptRel_PrimaryTrack_ << " % " << std::endl;
  if (bCorrect_ && bCalibPrimary_)
    edm::LogInfo("PFCandConnector") << "      and on merged tracks better than " << dptRel_MergedTrack_ << " % "
                                    << std::endl;
  if (bCorrect_ && bCalibPrimary_)
    edm::LogInfo("PFCandConnector") << "      and secondary tracks in some cases more precise than "
                                    << ptErrorSecondary_ << " GeV" << std::endl;
  if (bCorrect_ && bCalibPrimary_)
    edm::LogInfo("PFCandConnector") << "factor = (" << fConst_[0] << " + " << fConst_[1] << "*cFrac) - (" << fNorm_[0]
                                    << " - " << fNorm_[1] << "cFrac)*exp( " << -1 * fExp_[0] << "*pT )" << std::endl;
  edm::LogInfo("PFCandConnector") << " =========================================================== " << std::endl;
}

References HLT_2018_cff::bCalibPrimary, HLT_2018_cff::bCorrect, HLT_2018_cff::nuclCalibFactors, and AlCaHLTBitMon_QueryRunRegistry::string.

setParameters() [2/2]

void PFCandConnector::setParameters ( const edm::ParameterSet &  iCfgCandConnector )

inline

Flag to apply the correction procedure for nuclear interactions

Flag to calibrate the reconstructed nuclear interactions with primary or merged tracks

Definition at line 30 of file PFCandConnector.h.

                                                               {
    bool bCorrect, bCalibPrimary;
    double dptRel_PrimaryTrack, dptRel_MergedTrack, ptErrorSecondary;
    std::vector<double> nuclCalibFactors;
 
    bCorrect = iCfgCandConnector.getParameter<bool>("bCorrect");
    bCalibPrimary = iCfgCandConnector.getParameter<bool>("bCalibPrimary");
 
    if (iCfgCandConnector.exists("dptRel_PrimaryTrack"))
      dptRel_PrimaryTrack = iCfgCandConnector.getParameter<double>("dptRel_PrimaryTrack");
    else {
      edm::LogWarning("PFCandConnector") << "dptRel_PrimaryTrack doesn't exist. Setting a default safe value 0"
                                         << std::endl;
      dptRel_PrimaryTrack = 0;
    }
 
    if (iCfgCandConnector.exists("dptRel_MergedTrack"))
      dptRel_MergedTrack = iCfgCandConnector.getParameter<double>("dptRel_MergedTrack");
    else {
      edm::LogWarning("PFCandConnector") << "dptRel_MergedTrack doesn't exist. Setting a default safe value 0"
                                         << std::endl;
      dptRel_MergedTrack = 0;
    }
 
    if (iCfgCandConnector.exists("ptErrorSecondary"))
      ptErrorSecondary = iCfgCandConnector.getParameter<double>("ptErrorSecondary");
    else {
      edm::LogWarning("PFCandConnector") << "ptErrorSecondary doesn't exist. Setting a default safe value 0"
                                         << std::endl;
      ptErrorSecondary = 0;
    }
 
    if (iCfgCandConnector.exists("nuclCalibFactors"))
      nuclCalibFactors = iCfgCandConnector.getParameter<std::vector<double> >("nuclCalibFactors");
    else {
      edm::LogWarning("PFCandConnector") << "nuclear calib factors doesn't exist the factor would not be applyed"
                                         << std::endl;
    }
 
    setParameters(bCorrect, bCalibPrimary, dptRel_PrimaryTrack, dptRel_MergedTrack, ptErrorSecondary, nuclCalibFactors);
  }

References HLT_2018_cff::bCalibPrimary, HLT_2018_cff::bCorrect, HLT_2018_cff::iCfgCandConnector, and HLT_2018_cff::nuclCalibFactors.

Referenced by PFAlgo::setCandConnectorParameters().

Member Data Documentation

bCalibPrimary_

bool PFCandConnector::bCalibPrimary_

private

Calibration parameters for the reconstructed nuclear interactions.

Definition at line 103 of file PFCandConnector.h.

Referenced by PFCandConnector().

bCorrect_

bool PFCandConnector::bCorrect_

private

Parameters.

Definition at line 100 of file PFCandConnector.h.

Referenced by PFCandConnector().

dptRel_MergedTrack_

double PFCandConnector::dptRel_MergedTrack_

private

Definition at line 110 of file PFCandConnector.h.

Referenced by PFCandConnector().

dptRel_PrimaryTrack_

double PFCandConnector::dptRel_PrimaryTrack_

private

Definition at line 109 of file PFCandConnector.h.

Referenced by PFCandConnector().

fConst_

std::vector<double> PFCandConnector::fConst_

private

Definition at line 104 of file PFCandConnector.h.

Referenced by PFCandConnector().

fExp_

std::vector<double> PFCandConnector::fExp_

private

Definition at line 106 of file PFCandConnector.h.

Referenced by PFCandConnector().

fNorm_

std::vector<double> PFCandConnector::fNorm_

private

Definition at line 105 of file PFCandConnector.h.

Referenced by PFCandConnector().

fT_FROM_DISP_

const reco::PFCandidate::Flags PFCandConnector::fT_FROM_DISP_ = PFCandidate::T_FROM_DISP

staticprivate

Definition at line 116 of file PFCandConnector.h.

fT_TO_DISP_

const reco::PFCandidate::Flags PFCandConnector::fT_TO_DISP_ = PFCandidate::T_TO_DISP

staticprivate

Definition at line 115 of file PFCandConnector.h.

pion_mass2

const double PFCandConnector::pion_mass2 = 0.0194

staticprivate

Useful constants.

Definition at line 114 of file PFCandConnector.h.

ptErrorSecondary_

double PFCandConnector::ptErrorSecondary_

private

Definition at line 111 of file PFCandConnector.h.

Referenced by PFCandConnector().