#include <AlignmentMuonSelector.h>

Classes
struct	ComparePt
	compare two muons in pt (used by theNHighestPtMuons) More...

Public Types
typedef std::vector< const reco::Muon * >	Muons

Public Member Functions
	AlignmentMuonSelector (const edm::ParameterSet &cfg)
	constructor More...

Muons	select (const Muons &muons, const edm::Event &evt) const
	select muons More...

	~AlignmentMuonSelector ()
	destructor More...

Private Member Functions
Muons	basicCuts (const Muons &muons) const
	apply basic cuts on pt,eta,phi,nhit More...

Muons	theBestMassPairCombinationMuons (const Muons &muons) const
	filter only those muons giving best mass pair combination More...

Muons	theNHighestPtMuons (const Muons &muons) const
	filter the n highest pt muons More...

Private Attributes
bool	applyBasicCuts
	private data members More...

bool	applyMassPairFilter

bool	applyMultiplicityFilter

bool	applyNHighestPt

double	chi2nMaxGB

double	chi2nMaxSA

double	chi2nMaxTO

double	etaMax

double	etaMin

double	maxMassPair

double	minMassPair

int	minMultiplicity

int	nHighestPt

double	nHitMaxGB

double	nHitMaxSA

double	nHitMaxTO

double	nHitMinGB

double	nHitMinSA

double	nHitMinTO

double	phiMax

double	phiMin

double	pMax

double	pMin

ComparePt	ptComparator

double	ptMax

double	ptMin

Detailed Description

Definition at line 26 of file AlignmentMuonSelector.h.

Member Typedef Documentation

typedef std::vector<const reco::Muon*> AlignmentMuonSelector::Muons

Definition at line 28 of file AlignmentMuonSelector.h.

Constructor & Destructor Documentation

AlignmentMuonSelector::AlignmentMuonSelector ( const edm::ParameterSet & cfg )

constructor

Definition at line 10 of file AlignmentMuonSelector.cc.

References applyBasicCuts, applyMassPairFilter, applyMultiplicityFilter, applyNHighestPt, chi2nMaxGB, chi2nMaxSA, chi2nMaxTO, etaMax, etaMin, maxMassPair, minMassPair, minMultiplicity, nHighestPt, nHitMaxGB, nHitMaxSA, nHitMaxTO, nHitMinGB, nHitMinSA, nHitMinTO, phiMax, phiMin, pMax, pMin, ptMax, and ptMin.

     : applyBasicCuts(cfg.getParameter<bool>("applyBasicCuts")),
       applyNHighestPt(cfg.getParameter<bool>("applyNHighestPt")),
       applyMultiplicityFilter(cfg.getParameter<bool>("applyMultiplicityFilter")),
       applyMassPairFilter(cfg.getParameter<bool>("applyMassPairFilter")),
       nHighestPt(cfg.getParameter<int>("nHighestPt")),
       minMultiplicity(cfg.getParameter<int>("minMultiplicity")),
       pMin(cfg.getParameter<double>("pMin")),
       pMax(cfg.getParameter<double>("pMax")),
       ptMin(cfg.getParameter<double>("ptMin")),
       ptMax(cfg.getParameter<double>("ptMax")),
       etaMin(cfg.getParameter<double>("etaMin")),
       etaMax(cfg.getParameter<double>("etaMax")),
       phiMin(cfg.getParameter<double>("phiMin")),
       phiMax(cfg.getParameter<double>("phiMax")),
       nHitMinSA(cfg.getParameter<double>("nHitMinSA")),
       nHitMaxSA(cfg.getParameter<double>("nHitMaxSA")),
       chi2nMaxSA(cfg.getParameter<double>("chi2nMaxSA")),
       nHitMinGB(cfg.getParameter<double>("nHitMinGB")),
       nHitMaxGB(cfg.getParameter<double>("nHitMaxGB")),
       chi2nMaxGB(cfg.getParameter<double>("chi2nMaxGB")),
       nHitMinTO(cfg.getParameter<double>("nHitMinTO")),
       nHitMaxTO(cfg.getParameter<double>("nHitMaxTO")),
       chi2nMaxTO(cfg.getParameter<double>("chi2nMaxTO")),
       minMassPair(cfg.getParameter<double>("minMassPair")),
       maxMassPair(cfg.getParameter<double>("maxMassPair")) {
   if (applyBasicCuts)
     edm::LogInfo("AlignmentMuonSelector")
         << "applying basic muon cuts ..."
         << "\npmin,pmax:           " << pMin << "," << pMax << "\nptmin,ptmax:         " << ptMin << "," << ptMax
         << "\netamin,etamax:       " << etaMin << "," << etaMax << "\nphimin,phimax:       " << phiMin << "," << phiMax
         << "\nnhitminSA,nhitmaxSA: " << nHitMinSA << "," << nHitMaxSA << "\nchi2nmaxSA:          " << chi2nMaxSA << ","
         << "\nnhitminGB,nhitmaxGB: " << nHitMinGB << "," << nHitMaxGB << "\nchi2nmaxGB:          " << chi2nMaxGB << ","
         << "\nnhitminTO,nhitmaxTO: " << nHitMinTO << "," << nHitMaxTO << "\nchi2nmaxTO:          " << chi2nMaxTO;
 
   if (applyNHighestPt)
     edm::LogInfo("AlignmentMuonSelector") << "filter N muons with highest Pt N=" << nHighestPt;
 
   if (applyMultiplicityFilter)
     edm::LogInfo("AlignmentMuonSelector") << "apply multiplicity filter N>=" << minMultiplicity;
 
   if (applyMassPairFilter)
     edm::LogInfo("AlignmentMuonSelector")
         << "apply Mass Pair filter minMassPair=" << minMassPair << " maxMassPair=" << maxMassPair;
 }

AlignmentMuonSelector::~AlignmentMuonSelector ( )

destructor

Definition at line 58 of file AlignmentMuonSelector.cc.

58 {}

Member Function Documentation

AlignmentMuonSelector::Muons AlignmentMuonSelector::basicCuts ( const Muons & muons ) const

private

apply basic cuts on pt,eta,phi,nhit

Definition at line 94 of file AlignmentMuonSelector.cc.

References chi2nMaxTO, reco::Muon::combinedMuon(), PVValHelper::eta, reco::LeafCandidate::eta(), etaMin, reco::Muon::isGlobalMuon(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), nHitMaxGB, nHitMaxSA, nHitMaxTO, nHitMinGB, nHitMinSA, nHitMinTO, reco::LeafCandidate::p(), AlCaHLTBitMon_ParallelJobs::p, phi, reco::LeafCandidate::phi(), phiMin, pMin, EnergyCorrector::pt, reco::LeafCandidate::pt(), ptMin, mps_fire::result, reco::Muon::standAloneMuon(), and reco::Muon::track().

Referenced by select().

                                                                                     {
   Muons result;
 
   for (Muons::const_iterator it = muons.begin(); it != muons.end(); ++it) {
     const reco::Muon* muonp = *it;
     float p = muonp->p();
     float pt = muonp->pt();
     float eta = muonp->eta();
     float phi = muonp->phi();
 
     int nhitSA = 0;
     float chi2nSA = 9999.;
     if (muonp->isStandAloneMuon()) {
       nhitSA = muonp->standAloneMuon()->numberOfValidHits();  // standAlone Muon
       chi2nSA = muonp->standAloneMuon()->normalizedChi2();    // standAlone Muon
     }
     int nhitGB = 0;
     float chi2nGB = 9999.;
     if (muonp->isGlobalMuon()) {
       nhitGB = muonp->combinedMuon()->numberOfValidHits();  // global Muon
       chi2nGB = muonp->combinedMuon()->normalizedChi2();    // global Muon
     }
     int nhitTO = 0;
     float chi2nTO = 9999.;
     if (muonp->isTrackerMuon()) {
       nhitTO = muonp->track()->numberOfValidHits();  // Tracker Only
       chi2nTO = muonp->track()->normalizedChi2();    // Tracker Only
     }
     edm::LogInfo("AlignmentMuonSelector")
         << " pt,eta,phi,nhitSA,chi2nSA,nhitGB,chi2nGB,nhitTO,chi2nTO: " << pt << "," << eta << "," << phi << ","
         << nhitSA << "," << chi2nSA << "," << nhitGB << "," << chi2nGB << "," << nhitTO << "," << chi2nTO;
 
     if (p > pMin && p < pMax && pt > ptMin && pt < ptMax && eta > etaMin && eta < etaMax && phi > phiMin &&
         phi < phiMax && nhitSA >= nHitMinSA && nhitSA <= nHitMaxSA && chi2nSA < chi2nMaxSA && nhitGB >= nHitMinGB &&
         nhitGB <= nHitMaxGB && chi2nGB < chi2nMaxGB && nhitTO >= nHitMinTO && nhitTO <= nHitMaxTO &&
         chi2nTO < chi2nMaxTO) {
       result.push_back(muonp);
     }
   }
 
   return result;
 }

AlignmentMuonSelector::Muons AlignmentMuonSelector::select	(	const Muons &	muons,
		const edm::Event &	evt
	)		const

select muons

Definition at line 62 of file AlignmentMuonSelector.cc.

References applyBasicCuts, applyMassPairFilter, applyMultiplicityFilter, applyNHighestPt, basicCuts(), createfilelist::int, minMultiplicity, extraflags_cff::muons, mps_fire::result, theBestMassPairCombinationMuons(), and theNHighestPtMuons().

Referenced by Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController::find(), Vispa.Views.LineDecayView.LineDecayContainer::mousePressEvent(), Vispa.Gui.PortConnection.PointToPointConnection::mousePressEvent(), Vispa.Gui.VispaWidget.VispaWidget::mousePressEvent(), Vispa.Views.AbstractView.AbstractView::restoreSelection(), and MuonConfigSelector::select().

                                                                                                       {
   Muons result = muons;
 
   // apply basic muon cuts (if selected)
   if (applyBasicCuts)
     result = this->basicCuts(result);
 
   // filter N muons with highest Pt (if selected)
   if (applyNHighestPt)
     result = this->theNHighestPtMuons(result);
 
   // apply minimum multiplicity requirement (if selected)
   if (applyMultiplicityFilter) {
     if (result.size() < (unsigned int)minMultiplicity)
       result.clear();
   }
 
   // apply mass pair requirement (if selected)
   if (applyMassPairFilter) {
     if (result.size() < 2)
       result.clear();  // at least 2 muons are require for a mass pair...
     else
       result = this->theBestMassPairCombinationMuons(result);
   }
 
   edm::LogInfo("AlignmentMuonSelector") << "muons all,kept: " << muons.size() << "," << result.size();
 
   return result;
 }

AlignmentMuonSelector::Muons AlignmentMuonSelector::theBestMassPairCombinationMuons ( const Muons & muons ) const

private

filter only those muons giving best mass pair combination

Definition at line 160 of file AlignmentMuonSelector.cc.

References ResonanceBuilder::mass, maxMassPair, minMassPair, extraflags_cff::muons, ptComparator, and mps_fire::result.

Referenced by select().

                                                                                                           {
   Muons sortedMuons = muons;
   Muons result;
   TLorentzVector mu1, mu2, pair;
   double mass = 0, minDiff = 999999.;
 
   // sort in pt
   std::sort(sortedMuons.begin(), sortedMuons.end(), ptComparator);
 
   // copy best mass pair combination muons to result vector
   // Criteria:
   // a) maxMassPair !=    minMassPair: the two highest pt muons with mass pair inside the given mass window
   // b) maxMassPair ==    minMassPair: the muon pair with massPair closest to given mass value
   for (Muons::const_iterator it1 = sortedMuons.begin(); it1 != sortedMuons.end(); ++it1) {
     for (Muons::const_iterator it2 = it1 + 1; it2 != sortedMuons.end(); ++it2) {
       mu1 = TLorentzVector((*it1)->momentum().x(), (*it1)->momentum().y(), (*it1)->momentum().z(), (*it1)->p());
       mu2 = TLorentzVector((*it2)->momentum().x(), (*it2)->momentum().y(), (*it2)->momentum().z(), (*it2)->p());
       pair = mu1 + mu2;
       mass = pair.M();
 
       if (maxMassPair != minMassPair) {
         if (mass < maxMassPair && mass > minMassPair) {
           result.push_back(*it1);
           result.push_back(*it2);
           break;
         }
       } else {
         if (fabs(mass - maxMassPair) < minDiff) {
           minDiff = fabs(mass - maxMassPair);
           result.clear();
           result.push_back(*it1);
           result.push_back(*it2);
         }
       }
     }
   }
 
   return result;
 }

AlignmentMuonSelector::Muons AlignmentMuonSelector::theNHighestPtMuons ( const Muons & muons ) const

private

filter the n highest pt muons

Definition at line 139 of file AlignmentMuonSelector.cc.

References extraflags_cff::muons, gen::n, nHighestPt, ptComparator, and mps_fire::result.

Referenced by select().

                                                                                              {
   Muons sortedMuons = muons;
   Muons result;
 
   // sort in pt
   std::sort(sortedMuons.begin(), sortedMuons.end(), ptComparator);
 
   // copy theMuonMult highest pt muons to result vector
   int n = 0;
   for (Muons::const_iterator it = sortedMuons.begin(); it != sortedMuons.end(); ++it) {
     if (n < nHighestPt) {
       result.push_back(*it);
       n++;
     }
   }
 
   return result;
 }