HepMCValidationHelper Namespace Reference

Functions
void	allStatus1 (const HepMC::GenEvent *all, std::vector< const HepMC::GenParticle *> &status1)
void	allStatus2 (const HepMC::GenEvent *all, std::vector< const HepMC::GenParticle *> &status2)
void	allStatus3 (const HepMC::GenEvent *all, std::vector< const HepMC::GenParticle *> &status3)
void	allVisibleParticles (const HepMC::GenEvent *all, std::vector< const HepMC::GenParticle *> &visible)
void	findDescendents (const HepMC::GenParticle *a, std::vector< const HepMC::GenParticle *> &descendents)
void	findFSRPhotons (const std::vector< const HepMC::GenParticle *> &leptons, const std::vector< const HepMC::GenParticle *> &all, double deltaR, std::vector< const HepMC::GenParticle *> &photons)
void	findFSRPhotons (const std::vector< const HepMC::GenParticle *> &leptons, const HepMC::GenEvent *all, double deltaR, std::vector< const HepMC::GenParticle *> &photons)
TLorentzVector	genMet (const HepMC::GenEvent *all, double etamin=-9999., double etamax=9999.)
template<class T >
bool	GreaterByE (const T &a1, const T &a2)
bool	isChargedLepton (const HepMC::GenParticle *part)
bool	isNeutrino (const HepMC::GenParticle *part)
bool	isTau (const HepMC::GenParticle *part)
void	removeIsolatedLeptons (const HepMC::GenEvent *all, double deltaR, double sumPt, std::vector< const HepMC::GenParticle *> &pruned)
bool	sortByE (const HepMC::GenParticle *a, const HepMC::GenParticle *b)
bool	sortByPseudoRapidity (const HepMC::GenParticle *a, const HepMC::GenParticle *b)
bool	sortByPt (const HepMC::GenParticle *a, const HepMC::GenParticle *b)
template<class T >
bool	sortByPtRef (const T lhs, const T rhs)
bool	sortByRapidity (const HepMC::GenParticle *a, const HepMC::GenParticle *b)

Function Documentation

allStatus1()

void HepMCValidationHelper::allStatus1	(	const HepMC::GenEvent *	all,
		std::vector< const HepMC::GenParticle *> &	status1
	)

Definition at line 73 of file HepMCValidationHelper.cc.

References python.cmstools::all().

Referenced by allVisibleParticles(), MBUEandQCDValidation::analyze(), findFSRPhotons(), and removeIsolatedLeptons().

                                                                                         {
    for (HepMC::GenEvent::particle_const_iterator iter = all->particles_begin(); iter != all->particles_end(); ++iter) {
      if ((*iter)->status() == 1)
        status1.push_back(*iter);
    }
  }

allStatus2()

void HepMCValidationHelper::allStatus2	(	const HepMC::GenEvent *	all,
		std::vector< const HepMC::GenParticle *> &	status2
	)

Definition at line 80 of file HepMCValidationHelper.cc.

References python.cmstools::all().

Referenced by removeIsolatedLeptons().

                                                                                         {
    for (HepMC::GenEvent::particle_const_iterator iter = all->particles_begin(); iter != all->particles_end(); ++iter) {
      if ((*iter)->status() == 2)
        status1.push_back(*iter);
    }
  }

allStatus3()

void HepMCValidationHelper::allStatus3	(	const HepMC::GenEvent *	all,
		std::vector< const HepMC::GenParticle *> &	status3
	)

Definition at line 87 of file HepMCValidationHelper.cc.

References python.cmstools::all().

                                                                                         {
    for (HepMC::GenEvent::particle_const_iterator iter = all->particles_begin(); iter != all->particles_end(); ++iter) {
      if ((*iter)->status() == 3)
        status1.push_back(*iter);
    }
  }

allVisibleParticles()

void HepMCValidationHelper::allVisibleParticles	(	const HepMC::GenEvent *	all,
		std::vector< const HepMC::GenParticle *> &	visible
	)

Definition at line 277 of file HepMCValidationHelper.cc.

References python.cmstools::all(), allStatus1(), mps_fire::i, and isNeutrino().

Referenced by genMet().

                                                                                                  {
    std::vector<const HepMC::GenParticle*> status1;
    visible.clear();
    allStatus1(all, status1);
    for (unsigned int i = 0; i < status1.size(); ++i) {
      if (!isNeutrino(status1[i]))
        visible.push_back(status1[i]);
    }
  }

findDescendents()

void HepMCValidationHelper::findDescendents	(	const HepMC::GenParticle *	a,
		std::vector< const HepMC::GenParticle *> &	descendents
	)

Definition at line 94 of file HepMCValidationHelper.cc.

References a.

Referenced by removeIsolatedLeptons().

                                                                                                   {
    HepMC::GenVertex* decayVertex = a->end_vertex();
    if (!decayVertex)
      return;
    HepMC::GenVertex::particles_out_const_iterator ipart;
    for (ipart = decayVertex->particles_out_const_begin(); ipart != decayVertex->particles_out_const_end(); ++ipart) {
      if ((*ipart)->status() == 1)
        descendents.push_back(*ipart);
      else
        findDescendents(*ipart, descendents);
    }
  }

findFSRPhotons() [1/2]

void HepMCValidationHelper::findFSRPhotons	(	const std::vector< const HepMC::GenParticle *> &	leptons,
		const std::vector< const HepMC::GenParticle *> &	all,
		double	deltaR,
		std::vector< const HepMC::GenParticle *> &	photons
	)

Definition at line 21 of file HepMCValidationHelper.cc.

References python.cmstools::all(), PbPb_ZMuSkimMuonDPG_cff::deltaR, mps_fire::i, HLT_2023v12_cff::leptons, and mps_update::status.

Referenced by WValidation::analyze(), DrellYanValidation::analyze(), findFSRPhotons(), and removeIsolatedLeptons().

                                                                      {
    //find all status 1 photons
    std::vector<const HepMC::GenParticle*> allphotons;
    for (unsigned int i = 0; i < all.size(); ++i) {
      if (all[i]->status() == 1 && all[i]->pdg_id() == 22)
        allphotons.push_back(all[i]);
    }

    //loop over the photons and check the distance wrt the leptons
    for (unsigned int ipho = 0; ipho < allphotons.size(); ++ipho) {
      bool close = false;
      for (unsigned int ilep = 0; ilep < leptons.size(); ++ilep) {
        if (deltaR(allphotons[ipho]->momentum(), leptons[ilep]->momentum()) < deltaRcut) {
          close = true;
          break;
        }
      }
      if (close)
        fsrphotons.push_back(allphotons[ipho]);
    }
  }

findFSRPhotons() [2/2]

void HepMCValidationHelper::findFSRPhotons	(	const std::vector< const HepMC::GenParticle *> &	leptons,
		const HepMC::GenEvent *	all,
		double	deltaR,
		std::vector< const HepMC::GenParticle *> &	photons
	)

Definition at line 12 of file HepMCValidationHelper.cc.

References python.cmstools::all(), allStatus1(), findFSRPhotons(), and HLT_2023v12_cff::leptons.

                                                                      {
    std::vector<const HepMC::GenParticle*> status1;
    allStatus1(all, status1);
    findFSRPhotons(leptons, status1, deltaRcut, fsrphotons);
  }

genMet()

TLorentzVector HepMCValidationHelper::genMet	(	const HepMC::GenEvent *	all,
		double	etamin = -9999.,
		double	etamax = 9999.
	)

Definition at line 288 of file HepMCValidationHelper.cc.

References python.cmstools::all(), allVisibleParticles(), TrackingDataMCValidation_Standalone_cff::etamax, TrackingDataMCValidation_Standalone_cff::etamin, mps_fire::i, BTaggingMonitor_cfi::met, submitPVValidationJobs::t, and x.

Referenced by GenSpecificAlgo::addInfo(), WValidation::analyze(), HLTJetMETValidation::analyze(), pat::GenMETExtractor::produce(), HLTTauMCProducer::produce(), and l1t::GenToInputProducer::produce().

                                                                                {
    std::vector<const HepMC::GenParticle*> visible;
    allVisibleParticles(all, visible);
    TLorentzVector momsum(0., 0., 0., 0.);
    for (unsigned int i = 0; i < visible.size(); ++i) {
      if (visible[i]->momentum().eta() > etamin && visible[i]->momentum().eta() < etamax) {
        TLorentzVector mom(visible[i]->momentum().x(),
                           visible[i]->momentum().y(),
                           visible[i]->momentum().z(),
                           visible[i]->momentum().t());
        momsum += mom;
      }
    }
    TLorentzVector met(-momsum.Px(), -momsum.Py(), 0., momsum.Pt());
    return met;
  }

GreaterByE()

template<class T >

bool HepMCValidationHelper::GreaterByE ( const T &  a1, const T &  a2  )

inline

Definition at line 10 of file HepMCValidationHelper.h.

References testProducerWithPsetDescEmpty_cfi::a2.

                                                   {
    return a1.E() > a2.E();
  }

isChargedLepton()

bool HepMCValidationHelper::isChargedLepton

(

const HepMC::GenParticle *

part

)

Definition at line 47 of file HepMCValidationHelper.cc.

References funct::abs(), HiggsValidation_cfi::pdg_id, and mps_update::status.

Referenced by removeIsolatedLeptons().

                                                     {
    int status = part->status();
    unsigned int pdg_id = abs(part->pdg_id());
    if (status == 2)
      return pdg_id == 15;
    else
      return status == 1 && (pdg_id == 11 || pdg_id == 13);
  }

isNeutrino()

bool HepMCValidationHelper::isNeutrino

(

const HepMC::GenParticle *

part

)

Definition at line 57 of file HepMCValidationHelper.cc.

References funct::abs(), HiggsValidation_cfi::pdg_id, and mps_update::status.

Referenced by allVisibleParticles(), and removeIsolatedLeptons().

                                                {
    int status = part->status();
    unsigned int pdg_id = abs(part->pdg_id());
    return status == 1 && (pdg_id == 12 || pdg_id == 14 || pdg_id == 16);
  }

isTau()

bool HepMCValidationHelper::isTau

(

const HepMC::GenParticle *

part

)

Definition at line 64 of file HepMCValidationHelper.cc.

References funct::abs().

Referenced by removeIsolatedLeptons().

{ return part->status() == 2 && abs(part->pdg_id()) == 15; }

removeIsolatedLeptons()

void HepMCValidationHelper::removeIsolatedLeptons	(	const HepMC::GenEvent *	all,
		double	deltaR,
		double	sumPt,
		std::vector< const HepMC::GenParticle *> &	pruned
	)

Definition at line 107 of file HepMCValidationHelper.cc.

References python.cmstools::all(), allStatus1(), allStatus2(), gather_cfg::cout, PbPb_ZMuSkimMuonDPG_cff::deltaR, Exception, findDescendents(), findFSRPhotons(), mps_fire::i, isChargedLepton(), isNeutrino(), isTau(), dqmiolumiharvest::j, HLT_2023v12_cff::leptons, HiggsValidation_cfi::pdg_id, contentValuesCheck::ss, submitPVValidationJobs::t, Tau3MuMonitor_cff::taus, bphysicsOniaDQM_cfi::vertex, and x.

Referenced by MBUEandQCDValidation::analyze().

                                                                         {
    //get all status 1 particles
    std::vector<const HepMC::GenParticle*> status1;
    allStatus1(all, status1);
    std::vector<const HepMC::GenParticle*> toRemove;
    //loop on all particles and find candidates to be isolated
    for (unsigned int i = 0; i < status1.size(); ++i) {
      //if it is a neutrino is a charged lepton (not a tau) this is a candidate to be isolated
      if (isNeutrino(status1[i]) || (isChargedLepton(status1[i]) && !isTau(status1[i]))) {
        //list of particles not to be considered in the isolation computation.
        //this includes the particle to be isolated and the fsr photons in case of charged lepton
        std::vector<const HepMC::GenParticle*> leptons;
        leptons.push_back(status1[i]);
        std::vector<const HepMC::GenParticle*> removedForIsolation;
        removedForIsolation.push_back(status1[i]);
        if (isChargedLepton(status1[i]))
          findFSRPhotons(leptons, status1, deltaRcut, removedForIsolation);
#ifdef DEBUG_HepMCValidationHelper
          //std::cout << removedForIsolation.size() << " particles to be removed for isolation calculation " << std::endl;
#endif
        //create vector of particles to compute isolation (removing removedForIsolation);
        std::vector<const HepMC::GenParticle*> forIsolation;
        std::vector<const HepMC::GenParticle*>::iterator iiso;
        for (iiso = status1.begin(); iiso != status1.end(); ++iiso) {
          std::vector<const HepMC::GenParticle*>::const_iterator iremove;
          bool marked = false;
          for (iremove = removedForIsolation.begin(); iremove != removedForIsolation.end(); ++iremove) {
            if ((*iiso)->barcode() == (*iremove)->barcode()) {
#ifdef DEBUG_HepMCValidationHelper
              //std::cout << "removing particle " << **iiso << " from the list of particles to compute isolation" << std::endl;
#endif
              marked = true;
              break;
            }
          }
          if (!marked)
            forIsolation.push_back(*iiso);
        }
        //now compute isolation
        double sumIso = 0;
        for (iiso = forIsolation.begin(); iiso < forIsolation.end(); ++iiso) {
          if (deltaR(leptons.front()->momentum(), (*iiso)->momentum()) < deltaRcut) {
            sumIso += (*iiso)->momentum().perp();
          }
        }
        //if isolated remove from the pruned list
        if (sumIso < sumPtCut) {
#ifdef DEBUG_HepMCValidationHelper
          std::cout << "particle " << *status1[i] << " is considered isolated, with sumPt " << sumIso << std::endl;
#endif
          toRemove.insert(toRemove.end(), removedForIsolation.begin(), removedForIsolation.end());
        }
#ifdef DEBUG_HepMCValidationHelper
        else {
          std::cout << "NOT isolated! " << *status1[i] << " is considered not isolated, with sumPt " << sumIso
                    << std::endl;
        }
#endif
      }
    }
    //at this point we have taken care of the electrons and muons, but pruned could  still contain the decay products of isolated taus,
    //we want to remove these as well
    std::vector<const HepMC::GenParticle*> status2;
    allStatus2(all, status2);
    std::vector<const HepMC::GenParticle*> taus;
    //getTaus(all, taus);
    for (unsigned int i = 0; i < status2.size(); ++i) {
      if (isTau(status2[i])) {
        //check the list we have already for duplicates
        //there use to be duplicates in some generators (sherpa)
        bool duplicate = false;
        TLorentzVector taumomentum(status2[i]->momentum().x(),
                                   status2[i]->momentum().y(),
                                   status2[i]->momentum().z(),
                                   status2[i]->momentum().t());
        for (unsigned int j = 0; j < taus.size(); ++j) {
          //compare momenta
          TLorentzVector othermomentum(
              taus[j]->momentum().x(), taus[j]->momentum().y(), taus[j]->momentum().z(), taus[j]->momentum().t());
          othermomentum -= taumomentum;
          if (status2[i]->pdg_id() == taus[j]->pdg_id() &&
              othermomentum.E() < 0.1 &&  //std::numeric_limits<float>::epsilon() &&
              othermomentum.P() < 0.1) {  //std::numeric_limits<float>::epsilon()){
            duplicate = true;
            break;
          }
        }
        if (!duplicate)
          taus.push_back(status2[i]);
      }
    }
    //loop over the taus, find the descendents, remove all these from the list of particles to compute isolation
    for (unsigned int i = 0; i < taus.size(); ++i) {
      std::vector<const HepMC::GenParticle*> taudaughters;
      findDescendents(taus[i], taudaughters);
      if (taudaughters.empty()) {
        std::ostringstream ss;
        auto vertex = taus[i]->end_vertex();
        if (vertex) {
          ss << "( " << vertex->point3d().x() << " " << vertex->point3d().y() << " " << vertex->point3d().z() << " )";
        } else {
          ss << "( did not decay )";
        }
        throw cms::Exception("NoTauDaugters")
            << " HepMCValidationHelper found no daughters for Tau within index " << i << " and info \n"
            << *taus[i] << " decay point " << ss.str()
            << "\n  This should not be able to happen and needs to be fixed.";
      }
      const HepMC::FourVector& taumom = taus[i]->momentum();
      //remove the daughters from the list of particles to compute isolation
      std::vector<const HepMC::GenParticle*> forIsolation;
      std::vector<const HepMC::GenParticle*>::iterator iiso;
      for (iiso = status1.begin(); iiso < status1.end(); ++iiso) {
        bool marked = false;
        std::vector<const HepMC::GenParticle*>::const_iterator iremove;
        for (iremove = taudaughters.begin(); iremove != taudaughters.end(); ++iremove) {
          if ((*iiso)->barcode() == (*iremove)->barcode()) {
#ifdef DEBUG_HepMCValidationHelper
//            std::cout << "removing particle " << **iiso << " from the list of particles to compute isolation because it comes from a tau" << std::endl;
#endif
            marked = true;
            break;
          }
        }
        if (!marked)
          forIsolation.push_back(*iiso);
      }
      //no compute isolation wrt the status 2 tau direction
      double sumIso = 0;
      for (iiso = forIsolation.begin(); iiso < forIsolation.end(); ++iiso) {
        if (deltaR(taumom, (*iiso)->momentum()) < deltaRcut) {
          sumIso += (*iiso)->momentum().perp();
        }
      }
      //if isolated remove the tau daughters from the pruned list
      if (sumIso < sumPtCut) {
#ifdef DEBUG_HepMCValidationHelper
        std::cout << "particle " << *taus[i] << " is considered isolated, with sumPt " << sumIso << std::endl;
#endif
        toRemove.insert(toRemove.end(), taudaughters.begin(), taudaughters.end());
      }
    }

    //now actually remove
    pruned.clear();
    for (unsigned int i = 0; i < status1.size(); ++i) {
      bool marked = false;
      std::vector<const HepMC::GenParticle*>::const_iterator iremove;
      for (iremove = toRemove.begin(); iremove != toRemove.end(); ++iremove) {
        if (status1[i]->barcode() == (*iremove)->barcode()) {
          marked = true;
          break;
        }
      }
      if (!marked)
        pruned.push_back(status1[i]);
    }

#ifdef DEBUG_HepMCValidationHelper
    std::cout << "list of remaining particles:" << std::endl;
    for (unsigned int i = 0; i < pruned.size(); ++i) {
      std::cout << *pruned[i] << std::endl;
    }
#endif
  }

sortByE()

bool HepMCValidationHelper::sortByE ( const HepMC::GenParticle *  a, const HepMC::GenParticle *  b  )

inline

Definition at line 25 of file HepMCValidationHelper.h.

References a, and b.

                                                                            {
    return a->momentum().e() > b->momentum().e();
  }

sortByPseudoRapidity()

bool HepMCValidationHelper::sortByPseudoRapidity ( const HepMC::GenParticle *  a, const HepMC::GenParticle *  b  )

inline

Definition at line 39 of file HepMCValidationHelper.h.

References a, and b.

                                                                                         {
    return a->momentum().eta() > b->momentum().eta();
  }

sortByPt()

bool HepMCValidationHelper::sortByPt ( const HepMC::GenParticle *  a, const HepMC::GenParticle *  b  )

inline

Definition at line 15 of file HepMCValidationHelper.h.

References a, and b.

Referenced by WValidation::analyze(), and DrellYanValidation::analyze().

                                                                             {
    return a->momentum().perp() > b->momentum().perp();
  }

sortByPtRef()

template<class T >

bool HepMCValidationHelper::sortByPtRef ( const T  lhs, const T  rhs  )

inline

Definition at line 20 of file HepMCValidationHelper.h.

                                                    {
    return lhs->pt() > rhs->pt();
  }

sortByRapidity()

bool HepMCValidationHelper::sortByRapidity ( const HepMC::GenParticle *  a, const HepMC::GenParticle *  b  )

inline

Definition at line 30 of file HepMCValidationHelper.h.

References a, b, and dqm-mbProfile::log.

                                                                                   {
    const HepMC::FourVector& amom = a->momentum();
    const HepMC::FourVector& bmom = b->momentum();
    double rapa = 0.5 * std::log((amom.e() + amom.z()) / (amom.e() - amom.z()));
    double rapb = 0.5 * std::log((bmom.e() + bmom.z()) / (bmom.e() - bmom.z()));
    return rapa > rapb;
  }