CMSSW Reference Manual

typedef std::vector< std::pair<unsigned int, int> > JetPartonMatching::MatchingCollection

Definition at line 16 of file JetPartonMatching.h.

Enumerator:

totalMinDist
minSumDist
ptOrderedMinDist
unambiguousOnly

Definition at line 17 of file JetPartonMatching.h.

00017 { totalMinDist, minSumDist, ptOrderedMinDist, unambiguousOnly };

JetPartonMatching::JetPartonMatching ( ) [inline]

Definition at line 19 of file JetPartonMatching.h.

00019 {};

JetPartonMatching::JetPartonMatching	(	const std::vector< const reco::Candidate * > &	p,
		const std::vector< reco::GenJet > &	j,
		const	int = `totalMinDist`,
		const	bool = `true`,
		const	bool = `true`,
		const	double = `0.3`
	)

Definition at line 5 of file JetPartonMatching.cc.

References calculate(), i, and jets.

00008   : partons(p), algorithm_(algorithm), useMaxDist_(useMaxDist), useDeltaR_(useDeltaR), maxDist_(maxDist)
00009 {
00010   std::vector<const reco::Candidate*> js;
00011   for(unsigned int i=0; i<j.size(); ++i) js.push_back( &(j[i]) );
00012   jets = js;
00013   calculate();
00014 }

JetPartonMatching::JetPartonMatching	(	const std::vector< const reco::Candidate * > &	p,
		const std::vector< reco::CaloJet > &	j,
		const	int = `totalMinDist`,
		const	bool = `true`,
		const	bool = `true`,
		const	double = `0.3`
	)

Definition at line 16 of file JetPartonMatching.cc.

References calculate(), i, and jets.

00019   : partons(p), algorithm_(algorithm), useMaxDist_(useMaxDist), useDeltaR_(useDeltaR), maxDist_(maxDist)
00020 {
00021   std::vector<const reco::Candidate*> js;
00022   for(unsigned int i = 0; i < j.size(); ++i) js.push_back( &(j[i]) );
00023   jets = js; 
00024   calculate(); 
00025 }

JetPartonMatching::JetPartonMatching	(	const std::vector< const reco::Candidate * > &	p,
		const std::vector< pat::Jet > &	j,
		const	int = `totalMinDist`,
		const	bool = `true`,
		const	bool = `true`,
		const	double = `0.3`
	)

Definition at line 27 of file JetPartonMatching.cc.

References calculate(), i, and jets.

00030   : partons(p), algorithm_(algorithm), useMaxDist_(useMaxDist), useDeltaR_(useDeltaR), maxDist_(maxDist)
00031 {
00032   std::vector<const reco::Candidate*> js;
00033   for(unsigned int i = 0; i < j.size(); ++i) js.push_back( &(j[i]) );
00034   jets = js; 
00035   calculate(); 
00036 }

JetPartonMatching::JetPartonMatching	(	const std::vector< const reco::Candidate * > &	p,
		const std::vector< const reco::Candidate * > &	j,
		const	int = `totalMinDist`,
		const	bool = `true`,
		const	bool = `true`,
		const	double = `0.3`
	)

Definition at line 38 of file JetPartonMatching.cc.

References calculate().

00041   : partons(p), jets(j), algorithm_(algorithm), useMaxDist_(useMaxDist), useDeltaR_(useDeltaR), maxDist_(maxDist)
00042 {
00043   calculate();
00044 }

JetPartonMatching::~JetPartonMatching ( ) [inline]

Definition at line 28 of file JetPartonMatching.h.

00028 {};

void JetPartonMatching::calculate ( ) [private]

Definition at line 47 of file JetPartonMatching.cc.

References algorithm_, bookConverter::comb, distance(), relval_parameters_module::energy, first, getMatchForParton(), i, jets, edm::match(), matching, matchingMinSumDist(), matchingPtOrderedMinDist(), matchingTotalMinDist(), matchingUnambiguousOnly(), minSumDist, numberOfUnmatchedPartons, p4, partons, ptOrderedMinDist, edm::second(), python::multivaluedict::sort(), sumDeltaE, sumDeltaPt, sumDeltaR, totalMinDist, unambiguousOnly, and useMaxDist_.

Referenced by JetPartonMatching().

00048 {
00049   // use maximal distance between objects 
00050   // in case of unambiguousOnly algorithmm
00051   if(algorithm_==unambiguousOnly) useMaxDist_=true;
00052 
00053   // check if there are empty partons in
00054   // the vector, which happpens if the 
00055   // event is not ttbar or the decay is 
00056   // not as expected
00057   bool emptyParton=false;
00058   for(unsigned int ip=0; ip<partons.size(); ++ip){
00059     if( partons[ip]->pdgId() ==0 ){
00060       emptyParton=true;
00061       break;
00062     }
00063   }
00064 
00065   // switch algorithm, default is to match
00066   // on the minimal sum of the distance 
00067   // (if jets or a parton is empty fill match with blanks)
00068   if( jets.empty() || emptyParton ) {
00069     MatchingCollection dummyMatch;
00070     for(unsigned int ip=0; ip<partons.size(); ++ip)
00071       dummyMatch.push_back( std::make_pair(ip, -1) );
00072     matching.push_back( dummyMatch );
00073   }
00074   else {
00075     switch(algorithm_) {
00076       
00077     case totalMinDist: 
00078       matchingTotalMinDist();    
00079       break;
00080       
00081     case minSumDist: 
00082       matchingMinSumDist();
00083       break;
00084       
00085     case ptOrderedMinDist: 
00086       matchingPtOrderedMinDist();
00087       break;
00088       
00089     case unambiguousOnly:
00090       matchingUnambiguousOnly();
00091       break;
00092       
00093     default:
00094       matchingMinSumDist();
00095     }
00096   }
00097 
00098   numberOfUnmatchedPartons.clear();
00099   sumDeltaE .clear();
00100   sumDeltaPt.clear();
00101   sumDeltaR .clear();
00102   for(unsigned int comb = 0; comb < matching.size(); ++comb) {
00103     MatchingCollection match = matching[comb];
00104     std::sort(match.begin(), match.end());
00105     matching[comb] = match;
00106     
00107     int nUnmatchedPartons = partons.size();
00108     for(unsigned int part=0; part<partons.size(); ++part)
00109       if(getMatchForParton(part,comb)>=0) --nUnmatchedPartons;
00110 
00111     double sumDE  = -999.;
00112     double sumDPt = -999.;
00113     double sumDR  = -999.;
00114     if(nUnmatchedPartons==0){
00115       sumDE  = 0;
00116       sumDPt = 0;
00117       sumDR  = 0;
00118       for(unsigned int i=0; i<match.size(); ++i){
00119         sumDE  += fabs(partons[match[i].first]->energy() - jets[match[i].second]->energy());
00120         sumDPt += fabs(partons[match[i].first]->pt()     - jets[match[i].second]->pt());
00121         sumDR  += distance(partons[match[i].first]->p4(), jets[match[i].second]->p4());
00122       }
00123     }
00124 
00125     numberOfUnmatchedPartons.push_back( nUnmatchedPartons );
00126     sumDeltaE .push_back( sumDE  );
00127     sumDeltaPt.push_back( sumDPt );
00128     sumDeltaR .push_back( sumDR  );
00129   }
00130 }

double JetPartonMatching::distance	(	const math::XYZTLorentzVector &	v1,
		const math::XYZTLorentzVector &	v2
	)			`[private]`

Definition at line 133 of file JetPartonMatching.cc.

References useDeltaR_.

Referenced by calculate(), getDistanceForParton(), matchingPtOrderedMinDist(), matchingTotalMinDist(), matchingUnambiguousOnly(), and minSumDist_recursion().

00134 {
00135   // calculate the distance between two lorentz vectors 
00136   // using DeltaR(eta, phi) or normal space angle(theta, phi)
00137   if(useDeltaR_) return ROOT::Math::VectorUtil::DeltaR(v1, v2);
00138   return ROOT::Math::VectorUtil::Angle(v1, v2);
00139 }

double JetPartonMatching::getDistanceForParton	(	const unsigned int	part,
		const unsigned int	comb = `0`
	)

Definition at line 349 of file JetPartonMatching.cc.

References distance(), getMatchForParton(), jets, p4, and partons.

Referenced by getSumDistances(), TtSemiEvtSolutionMaker::produce(), and TtHadEvtSolutionMaker::produce().

00350 {
00351   // get the distance between parton and its best matched jet
00352   if(getMatchForParton(part, comb) < 0) return -999.;
00353   return distance( jets[getMatchForParton(part,comb)]->p4(), partons[part]->p4() );
00354 }

std::vector< int > JetPartonMatching::getMatchesForPartons ( const unsigned int comb = 0 )

Definition at line 338 of file JetPartonMatching.cc.

References getMatchForParton(), and partons.

Referenced by TtJetPartonMatch< C >::produce().

00339 {
00340   // return a vector with the indices of the matched jets
00341   // (ordered according to the vector of partons)
00342   std::vector<int> jetIndices;
00343   for(unsigned int part=0; part<partons.size(); ++part)
00344     jetIndices.push_back( getMatchForParton(part, comb) );
00345   return jetIndices;
00346 }

int JetPartonMatching::getMatchForParton	(	const unsigned int	part,
		const unsigned int	comb = `0`
	)

Definition at line 327 of file JetPartonMatching.cc.

References matching, and size.

Referenced by calculate(), getDistanceForParton(), getMatchesForPartons(), print(), TtSemiEvtSolutionMaker::produce(), and TtHadEvtSolutionMaker::produce().

00328 {
00329   // return index of the matched jet for a given parton
00330   // (if arguments for parton index and combinatoric index
00331   // are in the valid range)
00332   if(comb >= matching.size()) return -9;
00333   if(part >= matching[comb].size()) return -9;
00334   return (matching[comb])[part].second;
00335 }

unsigned int JetPartonMatching::getNumberOfAvailableCombinations ( ) [inline]

Definition at line 31 of file JetPartonMatching.h.

References matching.

Referenced by print(), and TtJetPartonMatch< C >::produce().

00031 { return matching.size(); }

int JetPartonMatching::getNumberOfUnmatchedPartons ( const unsigned int comb = 0 ) [inline]

Definition at line 32 of file JetPartonMatching.h.

References bookConverter::comb, int, and numberOfUnmatchedPartons.

00032 { return (comb<numberOfUnmatchedPartons.size() ? (int)numberOfUnmatchedPartons[comb] : -1 ); }

double JetPartonMatching::getSumDeltaE ( const unsigned int comb = 0 ) [inline]

Definition at line 39 of file JetPartonMatching.h.

References bookConverter::comb, size, and sumDeltaE.

Referenced by print().

00039 { return (comb<sumDeltaE .size() ? sumDeltaE [comb] : -999.); }

double JetPartonMatching::getSumDeltaPt ( const unsigned int comb = 0 ) [inline]

Definition at line 40 of file JetPartonMatching.h.

References bookConverter::comb, and sumDeltaPt.

Referenced by print(), and TtJetPartonMatch< C >::produce().

00040 { return (comb<sumDeltaPt.size() ? sumDeltaPt[comb] : -999.); }

double JetPartonMatching::getSumDeltaR ( const unsigned int comb = 0 ) [inline]

Definition at line 41 of file JetPartonMatching.h.

References bookConverter::comb, size, and sumDeltaR.

Referenced by print(), and TtJetPartonMatch< C >::produce().

00041 { return (comb<sumDeltaR .size() ? sumDeltaR [comb] : -999.); }

double JetPartonMatching::getSumDistances ( const unsigned int comb = 0 )

Definition at line 357 of file JetPartonMatching.cc.

References dist(), getDistanceForParton(), and partons.

Referenced by TtSemiEvtSolutionMaker::produce(), and TtHadEvtSolutionMaker::produce().

00358 {
00359   // get sum of distances between partons and matched jets
00360   double sumDists = 0.;
00361   for(unsigned int part=0; part<partons.size(); ++part){
00362     double dist = getDistanceForParton(part, comb);
00363     if(dist < 0.) return -999.;
00364     sumDists += dist;
00365   }
00366   return sumDists;
00367 }

void JetPartonMatching::matchingMinSumDist ( ) [private]

Definition at line 221 of file JetPartonMatching.cc.

References i, jets, matching, minSumDist_recursion(), partons, and python::multivaluedict::sort().

Referenced by calculate().

00222 {
00223   // match partons to jets with minimal sum of
00224   // the distances between all partons and jets
00225 
00226   std::vector<std::pair<double, MatchingCollection> > distMatchVec;
00227 
00228   std::vector<bool> usedJets;
00229   for(unsigned int i=0; i<jets.size(); ++i){
00230     usedJets.push_back(false);
00231   }
00232 
00233   std::vector<unsigned int> jetIndices;
00234   jetIndices.reserve(partons.size());
00235 
00236   minSumDist_recursion(0, jetIndices, usedJets, distMatchVec);
00237 
00238   std::sort(distMatchVec.begin(), distMatchVec.end());
00239 
00240   matching.clear();
00241   for(unsigned int i=0; i<distMatchVec.size(); ++i)
00242     matching.push_back( distMatchVec[i].second );  
00243   return;
00244 }

void JetPartonMatching::matchingPtOrderedMinDist ( ) [private]

Definition at line 247 of file JetPartonMatching.cc.

References dist(), distance(), jets, edm::match(), matching, maxDist_, p4, partons, edm::second(), python::multivaluedict::sort(), and useMaxDist_.

Referenced by calculate().

00248 {
00249   // match partons to jets with minimal sum of
00250   // the distances between all partons and jets
00251   // order partons in pt first
00252   std::vector<std::pair <double, unsigned int> > ptOrderedPartons;
00253 
00254   for(unsigned int ip=0; ip<partons.size(); ++ip)
00255     ptOrderedPartons.push_back(std::make_pair(partons[ip]->pt(), ip));
00256 
00257   std::sort(ptOrderedPartons.begin(), ptOrderedPartons.end());
00258   std::reverse(ptOrderedPartons.begin(), ptOrderedPartons.end());
00259 
00260   std::vector<unsigned int> jetIndices;
00261   for(unsigned int ij=0; ij<jets.size(); ++ij) jetIndices.push_back(ij);
00262 
00263   MatchingCollection match;
00264 
00265   for(unsigned int ip=0; ip<ptOrderedPartons.size(); ++ip){
00266     double minDist = 999.;
00267     int ijMin = -1;
00268 
00269     for(unsigned int ij=0; ij<jetIndices.size(); ++ij){
00270       double dist = distance(partons[ptOrderedPartons[ip].second]->p4(), jets[jetIndices[ij]]->p4());
00271       if(dist < minDist){
00272         if(!useMaxDist_ || dist <= maxDist_){
00273           minDist = dist;
00274           ijMin = ij;
00275         }
00276       }
00277     }
00278     
00279     if(ijMin >= 0){
00280       match.push_back( std::make_pair(ptOrderedPartons[ip].second, jetIndices[ijMin]) );
00281       jetIndices.erase(jetIndices.begin() + ijMin, jetIndices.begin() + ijMin + 1);
00282     }
00283     else
00284       match.push_back( std::make_pair(ptOrderedPartons[ip].second, -1) );
00285   }
00286 
00287   matching.clear();
00288   matching.push_back( match );
00289   return;
00290 }

void JetPartonMatching::matchingTotalMinDist ( ) [private]

Definition at line 142 of file JetPartonMatching.cc.

References a, dist(), distance(), first, jets, edm::match(), matching, maxDist_, p4, partons, python::multivaluedict::sort(), and useMaxDist_.

Referenced by calculate().

00143 {
00144   // match parton to jet with shortest distance
00145   // starting with the shortest distance available
00146   // apply some outlier rejection if desired
00147 
00148   // prepare vector of pairs with distances between
00149   // all partons to all jets in the input vectors
00150   std::vector< std::pair<double, unsigned int> > distances;
00151   for(unsigned int ip=0; ip<partons.size(); ++ip){
00152     for(unsigned int ij=0; ij<jets.size(); ++ij){ 
00153       double dist = distance(jets[ij]->p4(), partons[ip]->p4());
00154       distances.push_back(std::pair<double, unsigned int>(dist, ip*jets.size()+ij));
00155     }
00156   }
00157   std::sort(distances.begin(), distances.end());
00158 
00159   MatchingCollection match;
00160 
00161   while(match.size() < partons.size()){
00162     unsigned int partonIndex = distances[0].second/jets.size();
00163     int jetIndex = distances[0].second-jets.size()*partonIndex;
00164     
00165     // use primitive outlier rejection if desired
00166     if(useMaxDist_&& distances[0].first>maxDist_) jetIndex = -1;
00167 
00168     // prevent underflow in case of too few jets
00169     if( distances.empty() )
00170       match.push_back(std::make_pair(partonIndex, -1));
00171     else
00172       match.push_back(std::make_pair(partonIndex, jetIndex));
00173     
00174     // remove all values for the matched parton 
00175     // and the matched jet
00176     for(unsigned int a=0; a<distances.size(); ++a){
00177       unsigned int pIndex = distances[a].second/jets.size();
00178       int jIndex = distances[a].second-jets.size()*pIndex;
00179       if((pIndex == partonIndex) || (jIndex == jetIndex)){
00180         distances.erase(distances.begin()+a, distances.begin()+a+1); 
00181         --a;
00182       }
00183     }
00184   }
00185 
00186   matching.clear();
00187   matching.push_back( match );
00188   return;
00189 }

void JetPartonMatching::matchingUnambiguousOnly ( ) [private]

Definition at line 293 of file JetPartonMatching.cc.

References dist(), distance(), jets, edm::match(), matching, maxDist_, p4, and partons.

Referenced by calculate().

00294 {
00295   // match partons to jets, only accept event 
00296   // if there are no ambiguities
00297   std::vector<bool> jetMatched;
00298   for(unsigned int ij=0; ij<jets.size(); ++ij) jetMatched.push_back(false);
00299 
00300   MatchingCollection match;
00301   
00302   for(unsigned int ip=0; ip<partons.size(); ++ip){
00303     int iMatch = -1;
00304     for(unsigned int ij=0; ij<jets.size(); ++ij){
00305       double dist = distance(partons[ip]->p4(), jets[ij]->p4());
00306       if(dist <= maxDist_){
00307         if(!jetMatched[ij]){ // new match for jet
00308           jetMatched[ij] = true;
00309           if(iMatch == -1) // new match for parton and jet
00310             iMatch = ij;
00311           else // parton already matched: ambiguity!
00312             iMatch = -2;
00313         }
00314         else // jet already matched: ambiguity!
00315           iMatch = -2;
00316       }
00317     }
00318     match.push_back(std::make_pair(ip, iMatch));
00319   }
00320 
00321   matching.clear();
00322   matching.push_back( match );
00323   return;
00324 }

void JetPartonMatching::minSumDist_recursion	(	const unsigned int	ip,
		std::vector< unsigned int > &	jetIndices,
		std::vector< bool > &	usedJets,
		std::vector< std::pair< double, MatchingCollection > > &	distMatchVec
	)			`[private]`

Definition at line 192 of file JetPartonMatching.cc.

References dist(), distance(), jets, edm::match(), maxDist_, p4, partons, and useMaxDist_.

Referenced by matchingMinSumDist().

00194 {
00195   // build up jet combinations recursively
00196   if(ip<partons.size()){
00197     for(unsigned int ij=0; ij<jets.size(); ++ij){
00198       if(usedJets[ij]) continue;
00199       usedJets[ij] = true;
00200       jetIndices[ip] = ij;
00201       minSumDist_recursion(ip+1, jetIndices, usedJets, distMatchVec);
00202       usedJets[ij] = false;
00203     }
00204     return;
00205   }
00206 
00207   // calculate sumDist for each completed combination
00208   double sumDist = 0;
00209   MatchingCollection match;
00210   for(unsigned int ip=0; ip<partons.size(); ++ip){
00211     double dist  = distance(partons[ip]->p4(), jets[jetIndices[ip]]->p4());
00212     if(useMaxDist_ && dist > maxDist_) return; // outlier rejection
00213     sumDist += distance(partons[ip]->p4(), jets[jetIndices[ip]]->p4());
00214     match.push_back(std::make_pair(ip, jetIndices[ip]));
00215   }
00216 
00217   distMatchVec.push_back( std::make_pair(sumDist, match)  );
00218   return;
00219 }

void JetPartonMatching::print ( void )

Definition at line 370 of file JetPartonMatching.cc.

References algorithm_, bookConverter::comb, getMatchForParton(), getNumberOfAvailableCombinations(), getSumDeltaE(), getSumDeltaPt(), getSumDeltaR(), jets, funct::log(), matching, maxDist_, minSumDist, partons, ptOrderedMinDist, totalMinDist, unambiguousOnly, useDeltaR_, and useMaxDist_.

Referenced by TtJetPartonMatch< C >::produce().

00371 {
00372   //report using MessageLogger
00373   edm::LogInfo log("JetPartonMatching");
00374   log << "++++++++++++++++++++++++++++++++++++++++++++++ \n";
00375   log << " algorithm : ";
00376   switch(algorithm_) {
00377   case totalMinDist     : log << "totalMinDist    "; break;
00378   case minSumDist       : log << "minSumDist      "; break;
00379   case ptOrderedMinDist : log << "ptOrderedMinDist"; break;
00380   case unambiguousOnly  : log << "unambiguousOnly "; break;
00381   default               : log << "UNKNOWN         ";
00382   }
00383   log << "\n";
00384   log << " useDeltaR : ";
00385   switch(useDeltaR_) {
00386   case false : log << "false"; break;
00387   case true  : log << "true ";
00388   }
00389   log << "\n";
00390   log << " useMaxDist: ";
00391   switch(useMaxDist_) {
00392   case false : log << "false"; break;
00393   case true  : log << "true ";
00394   }
00395   log << "      maxDist: " << maxDist_ << "\n";
00396   log << " number of partons / jets: " << partons.size() << " / " << jets.size() << "\n";
00397   log << " number of available combinations: " << getNumberOfAvailableCombinations() << "\n";
00398   for(unsigned int comb = 0; comb < matching.size(); ++comb) {
00399     log << " -------------------------------------------- \n";
00400     log << " ind. of matched jets:";
00401     for(unsigned int part = 0; part < partons.size(); ++part)
00402       log << std::setw(4) << getMatchForParton(part, comb);
00403     log << "\n";
00404     log << " sumDeltaR             : " << getSumDeltaR(comb) << "\n";
00405     log << " sumDeltaPt / sumDeltaE: " << getSumDeltaPt(comb) << " / "  << getSumDeltaE(comb);
00406     log << "\n";
00407   }
00408   log << "++++++++++++++++++++++++++++++++++++++++++++++";
00409 }

int JetPartonMatching::algorithm_ [private]

Definition at line 66 of file JetPartonMatching.h.

Referenced by calculate(), and print().

std::vector<const reco::Candidate*> JetPartonMatching::jets [private]

Definition at line 58 of file JetPartonMatching.h.

Referenced by calculate(), getDistanceForParton(), JetPartonMatching(), matchingMinSumDist(), matchingPtOrderedMinDist(), matchingTotalMinDist(), matchingUnambiguousOnly(), minSumDist_recursion(), and print().

std::vector<MatchingCollection> JetPartonMatching::matching [private]

Definition at line 59 of file JetPartonMatching.h.

Referenced by calculate(), getMatchForParton(), getNumberOfAvailableCombinations(), matchingMinSumDist(), matchingPtOrderedMinDist(), matchingTotalMinDist(), matchingUnambiguousOnly(), and print().

double JetPartonMatching::maxDist_ [private]

Definition at line 69 of file JetPartonMatching.h.

Referenced by matchingPtOrderedMinDist(), matchingTotalMinDist(), matchingUnambiguousOnly(), minSumDist_recursion(), and print().

std::vector<unsigned int> JetPartonMatching::numberOfUnmatchedPartons [private]

Definition at line 61 of file JetPartonMatching.h.

Referenced by calculate(), and getNumberOfUnmatchedPartons().

std::vector<const reco::Candidate*> JetPartonMatching::partons [private]

Definition at line 57 of file JetPartonMatching.h.

Referenced by calculate(), getDistanceForParton(), getMatchesForPartons(), getSumDistances(), matchingMinSumDist(), matchingPtOrderedMinDist(), matchingTotalMinDist(), matchingUnambiguousOnly(), minSumDist_recursion(), and print().

std::vector<double> JetPartonMatching::sumDeltaE [private]

Definition at line 62 of file JetPartonMatching.h.

Referenced by calculate(), and getSumDeltaE().

std::vector<double> JetPartonMatching::sumDeltaPt [private]

Definition at line 63 of file JetPartonMatching.h.

Referenced by calculate(), and getSumDeltaPt().

std::vector<double> JetPartonMatching::sumDeltaR [private]

Definition at line 64 of file JetPartonMatching.h.

Referenced by calculate(), and getSumDeltaR().

bool JetPartonMatching::useDeltaR_ [private]

Definition at line 68 of file JetPartonMatching.h.

Referenced by distance(), and print().

bool JetPartonMatching::useMaxDist_ [private]

Definition at line 67 of file JetPartonMatching.h.

Referenced by calculate(), matchingPtOrderedMinDist(), matchingTotalMinDist(), minSumDist_recursion(), and print().

JetPartonMatching Class Reference

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Types
enum	algorithms { totalMinDist, minSumDist, ptOrderedMinDist, unambiguousOnly }
typedef std::vector< std::pair < unsigned int, int > >	MatchingCollection
Public Member Functions
double	getDistanceForParton (const unsigned int part, const unsigned int comb=0)
std::vector< int >	getMatchesForPartons (const unsigned int comb=0)
int	getMatchForParton (const unsigned int part, const unsigned int comb=0)
unsigned int	getNumberOfAvailableCombinations ()
int	getNumberOfUnmatchedPartons (const unsigned int comb=0)
double	getSumDeltaE (const unsigned int comb=0)
double	getSumDeltaPt (const unsigned int comb=0)
double	getSumDeltaR (const unsigned int comb=0)
double	getSumDistances (const unsigned int comb=0)
	JetPartonMatching (const std::vector< const reco::Candidate * > &, const std::vector< const reco::Candidate * > &, const int, const bool, const bool, const double)
	JetPartonMatching (const std::vector< const reco::Candidate * > &, const std::vector< pat::Jet > &, const int, const bool, const bool, const double)
	JetPartonMatching (const std::vector< const reco::Candidate * > &, const std::vector< reco::CaloJet > &, const int, const bool, const bool, const double)
	JetPartonMatching (const std::vector< const reco::Candidate * > &, const std::vector< reco::GenJet > &, const int, const bool, const bool, const double)
	JetPartonMatching ()
void	print ()
	~JetPartonMatching ()
Private Member Functions
void	calculate ()
double	distance (const math::XYZTLorentzVector &, const math::XYZTLorentzVector &)
void	matchingMinSumDist ()
void	matchingPtOrderedMinDist ()
void	matchingTotalMinDist ()
void	matchingUnambiguousOnly ()
void	minSumDist_recursion (const unsigned int, std::vector< unsigned int > &, std::vector< bool > &, std::vector< std::pair< double, MatchingCollection > > &)
Private Attributes
int	algorithm_
std::vector< const reco::Candidate * >	jets
std::vector< MatchingCollection >	matching
double	maxDist_
std::vector< unsigned int >	numberOfUnmatchedPartons
std::vector< const reco::Candidate * >	partons
std::vector< double >	sumDeltaE
std::vector< double >	sumDeltaPt
std::vector< double >	sumDeltaR
bool	useDeltaR_
bool	useMaxDist_