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 (const edm::ParameterSet &iCfgCandConnector)
void	setParameters (bool bCorrect, bool bCalibPrimary, double dptRel_PrimaryTrack, double dptRel_MergedTrack, double ptErrorSecondary, const std::vector< double > &nuclCalibFactors)

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.

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

                    {
    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.;
  }

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.

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

                                                                  {
  PFDisplacedVertexRef ref1, ref2, ref1_bis;

  PFCandidate primaryCand = pfCand.at(ce1);

  // ------- look for the little friends -------- //

  const math::XYZTLorentzVectorD& momentumPrim = primaryCand.p4();

  math::XYZTLorentzVectorD momentumSec(0., 0., 0., 0.);

  if (momentumPrim.E() > 0)
    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 candE = pfCand.at(ce2).p4().E();
        double caloEn = pfCand.at(ce2).ecalEnergy() + pfCand.at(ce2).hcalEnergy();
        double deltaEn = candE - 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 && candE > 0) {
          math::XYZTLorentzVectorD momentumToAdd = pfCand.at(ce2).p4() * caloEn / candE;
          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 && candE > 0) {
            math::XYZTLorentzVectorD momentumExcess = pfCand.at(ce2).p4() * deltaEn / candE;
            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 = momentumPrim.E() > 0 ? rescaleFactor(momentumPrim.Pt(), momentumSec.E() / momentumPrim.E()) : 1.;
      LogTrace("PFCandConnector|analyseNuclearWPrim") << "factor = " << factor << endl;
      if (factor * momentumPrim.Pt() < momentumSec.Pt())
        momentumSec = momentumPrim;
      else
        momentumSec += (1 - factor) * momentumPrim;
    }

    double px = 0, py = 0, pz = 0.;
    if (momentumPrim.P() > 0) {
      px = momentumPrim.Px() * momentumSec.P() / momentumPrim.P();
      py = momentumPrim.Py() * momentumSec.P() / momentumPrim.P();
      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;
    }
  }
}

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 328 of file PFCandConnector.cc.

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

                                                                 {
  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(0., 0., 0., 0.);
    float candE = pfCand.at(ce1).p4().E();
    if (candE > 0)
      momentumToAdd = pfCand.at(ce1).p4() * caloEn / candE;
    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 candE = pfCand.at(ce2).p4().E();
        double caloEn = pfCand.at(ce2).ecalEnergy() + pfCand.at(ce2).hcalEnergy();
        double deltaEn = candE - 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 / candE;
          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;
  }
}

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.

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

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

                                                                                      {
  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;
}

fillPSetDescription()

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

static

Definition at line 563 of file PFCandConnector.cc.

References edm::ParameterSetDescription::add().

Referenced by PFProducer::fillDescriptions().

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

isPrimaryNucl()

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

private

Definition at line 505 of file PFCandConnector.cc.

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

                                                               {
  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;
}

isSecondaryNucl()

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

private

Definition at line 490 of file PFCandConnector.cc.

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

                                                                 {
  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;
}

rescaleFactor()

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

private

Return a calibration factor for a reconstructed nuclear interaction.

Definition at line 522 of file PFCandConnector.cc.

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

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

setParameters() [1/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.

References HLT_2022v15_cff::bCalibPrimary, HLT_2022v15_cff::bCorrect, particleFlowTmpBarrel_cfi::dptRel_MergedTrack, particleFlowTmpBarrel_cfi::dptRel_PrimaryTrack, HLT_2022v15_cff::iCfgCandConnector, HLT_2022v15_cff::nuclCalibFactors, and particleFlowTmpBarrel_cfi::ptErrorSecondary.

Referenced by PFAlgo::setCandConnectorParameters().

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

setParameters() [2/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.

References HLT_2022v15_cff::bCalibPrimary, HLT_2022v15_cff::bCorrect, particleFlowTmpBarrel_cfi::dptRel_MergedTrack, particleFlowTmpBarrel_cfi::dptRel_PrimaryTrack, HLT_2022v15_cff::nuclCalibFactors, particleFlowTmpBarrel_cfi::ptErrorSecondary, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
  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;
}

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().