Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 12:49:20

0001 /*
0002  *  See header file for a description of this class.
0003  *
0004  *  \author Paolo Ronchese INFN Padova
0005  *
0006  */
0007 
0008 //-----------------------
0009 // This Class' Header --
0010 //-----------------------
0011 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoBuilder.h"
0012 
0013 //-------------------------------
0014 // Collaborating Class Headers --
0015 //-------------------------------
0016 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoSelect.h"
0017 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHMomentumSelect.h"
0018 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHVertexSelect.h"
0019 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHFitSelect.h"
0020 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoCandidate.h"
0021 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHTrackReference.h"
0022 #include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
0023 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0024 
0025 //---------------
0026 // C++ Headers --
0027 //---------------
0028 using namespace std;
0029 
0030 //-------------------
0031 // Initializations --
0032 //-------------------
0033 
0034 //----------------
0035 // Constructors --
0036 //----------------
0037 BPHRecoBuilder::BPHRecoBuilder(const edm::EventSetup& es) : evSetup(&es), minPDiff(-1.0) {
0038   msList.reserve(5);
0039   vsList.reserve(5);
0040 }
0041 
0042 //--------------
0043 // Destructor --
0044 //--------------
0045 BPHRecoBuilder::~BPHRecoBuilder() {
0046   int n = sourceList.size();
0047   while (n--) {
0048     delete sourceList[n]->collection;
0049     delete sourceList[n];
0050   }
0051   int m = srCompList.size();
0052   while (m--)
0053     delete srCompList[m];
0054   while (!compCollectList.empty()) {
0055     const vector<BPHRecoConstCandPtr>* cCollection = *compCollectList.begin();
0056     delete cCollection;
0057     compCollectList.erase(cCollection);
0058   }
0059 }
0060 
0061 //--------------
0062 // Operations --
0063 //--------------
0064 BPHRecoBuilder::BPHGenericCollection* BPHRecoBuilder::createCollection(const vector<const reco::Candidate*>& candList,
0065                                                                        const string& list) {
0066   return new BPHSpecificCollection<vector<const reco::Candidate*>>(candList, list);
0067 }
0068 
0069 void BPHRecoBuilder::add(const string& name, const BPHGenericCollection* collection, double mass, double msig) {
0070   BPHRecoSource* rs;
0071   if (sourceId.find(name) != sourceId.end()) {
0072     edm::LogPrint("TooManyParticles") << "BPHRecoBuilder::add: "
0073                                       << "Decay product already inserted with name " << name << " , skipped";
0074     return;
0075   }
0076   rs = new BPHRecoSource;
0077   rs->name = &sourceId.insert(make_pair(name, sourceList.size())).first->first;
0078   rs->collection = collection;
0079   rs->selector.reserve(5);
0080   rs->mass = mass;
0081   rs->msig = msig;
0082   sourceList.push_back(rs);
0083   return;
0084 }
0085 
0086 void BPHRecoBuilder::add(const string& name, const vector<BPHRecoConstCandPtr>& collection) {
0087   BPHCompSource* cs;
0088   if (srCompId.find(name) != srCompId.end()) {
0089     edm::LogPrint("TooManyParticles") << "BPHRecoBuilder::add: "
0090                                       << "Decay product already inserted with name " << name << " , skipped";
0091     return;
0092   }
0093   cs = new BPHCompSource;
0094   cs->name = &srCompId.insert(make_pair(name, srCompList.size())).first->first;
0095   cs->collection = &collection;
0096   srCompList.push_back(cs);
0097   return;
0098 }
0099 
0100 void BPHRecoBuilder::filter(const string& name, const BPHRecoSelect& sel) const {
0101   map<string, int>::const_iterator iter = sourceId.find(name);
0102   if (iter == sourceId.end())
0103     return;
0104   BPHRecoSource* rs = sourceList[iter->second];
0105   rs->selector.push_back(&sel);
0106   return;
0107 }
0108 
0109 void BPHRecoBuilder::filter(const string& name, const BPHMomentumSelect& sel) const {
0110   map<string, int>::const_iterator iter = srCompId.find(name);
0111   if (iter == sourceId.end())
0112     return;
0113   BPHCompSource* cs = srCompList[iter->second];
0114   cs->momSelector.push_back(&sel);
0115   return;
0116 }
0117 
0118 void BPHRecoBuilder::filter(const string& name, const BPHVertexSelect& sel) const {
0119   map<string, int>::const_iterator iter = srCompId.find(name);
0120   if (iter == sourceId.end())
0121     return;
0122   BPHCompSource* cs = srCompList[iter->second];
0123   cs->vtxSelector.push_back(&sel);
0124   return;
0125 }
0126 
0127 void BPHRecoBuilder::filter(const string& name, const BPHFitSelect& sel) const {
0128   map<string, int>::const_iterator iter = srCompId.find(name);
0129   if (iter == sourceId.end())
0130     return;
0131   BPHCompSource* cs = srCompList[iter->second];
0132   cs->fitSelector.push_back(&sel);
0133   return;
0134 }
0135 
0136 void BPHRecoBuilder::filter(const BPHMomentumSelect& sel) {
0137   msList.push_back(&sel);
0138   return;
0139 }
0140 
0141 void BPHRecoBuilder::filter(const BPHVertexSelect& sel) {
0142   vsList.push_back(&sel);
0143   return;
0144 }
0145 
0146 void BPHRecoBuilder::filter(const BPHFitSelect& sel) {
0147   fsList.push_back(&sel);
0148   return;
0149 }
0150 
0151 bool BPHRecoBuilder::accept(const BPHRecoCandidate& cand) const {
0152   int i;
0153   int n;
0154   n = msList.size();
0155   for (i = 0; i < n; ++i) {
0156     if (!msList[i]->accept(cand))
0157       return false;
0158   }
0159   n = vsList.size();
0160   for (i = 0; i < n; ++i) {
0161     if (!vsList[i]->accept(cand))
0162       return false;
0163   }
0164   n = fsList.size();
0165   for (i = 0; i < n; ++i) {
0166     if (!fsList[i]->accept(cand))
0167       return false;
0168   }
0169   return true;
0170 }
0171 
0172 void BPHRecoBuilder::setMinPDiffererence(double pMin) {
0173   minPDiff = pMin;
0174   return;
0175 }
0176 
0177 vector<BPHRecoBuilder::ComponentSet> BPHRecoBuilder::build() const {
0178   daugMap.clear();
0179   compMap.clear();
0180   vector<ComponentSet> candList;
0181   ComponentSet compSet;
0182   build(candList, compSet, sourceList.begin(), sourceList.end(), srCompList.begin(), srCompList.end());
0183   return candList;
0184 }
0185 
0186 const edm::EventSetup* BPHRecoBuilder::eventSetup() const { return evSetup; }
0187 
0188 bool BPHRecoBuilder::sameTrack(const reco::Candidate* lCand, const reco::Candidate* rCand, double minPDifference) {
0189   const reco::Track* lrcTrack = BPHTrackReference::getFromRC(*lCand);
0190   const reco::Track* rrcTrack = BPHTrackReference::getFromRC(*rCand);
0191   const reco::Track* lpfTrack = BPHTrackReference::getFromPF(*lCand);
0192   const reco::Track* rpfTrack = BPHTrackReference::getFromPF(*rCand);
0193   if ((lrcTrack != nullptr) && ((lrcTrack == rrcTrack) || (lrcTrack == rpfTrack)))
0194     return true;
0195   if ((lpfTrack != nullptr) && ((lpfTrack == rrcTrack) || (lpfTrack == rpfTrack)))
0196     return true;
0197   reco::Candidate::Vector pDiff = (lCand->momentum() - rCand->momentum());
0198   reco::Candidate::Vector pMean = (lCand->momentum() + rCand->momentum());
0199   double pDMod = pDiff.mag2();
0200   double pMMod = pMean.mag2();
0201   if (((pDMod / pMMod) < minPDifference) && (lCand->charge() == rCand->charge()))
0202     return true;
0203   return false;
0204 }
0205 
0206 void BPHRecoBuilder::build(vector<ComponentSet>& compList,
0207                            ComponentSet& compSet,
0208                            vector<BPHRecoSource*>::const_iterator r_iter,
0209                            vector<BPHRecoSource*>::const_iterator r_iend,
0210                            vector<BPHCompSource*>::const_iterator c_iter,
0211                            vector<BPHCompSource*>::const_iterator c_iend) const {
0212   if (r_iter == r_iend) {
0213     if (c_iter == c_iend) {
0214       compSet.compMap = compMap;
0215       compList.push_back(compSet);
0216       return;
0217     }
0218     BPHCompSource* source = *c_iter++;
0219     const vector<BPHRecoConstCandPtr>* collection = source->collection;
0220     vector<const BPHMomentumSelect*> momSelector = source->momSelector;
0221     vector<const BPHVertexSelect*> vtxSelector = source->vtxSelector;
0222     vector<const BPHFitSelect*> fitSelector = source->fitSelector;
0223     int i;
0224     int j;
0225     int n = collection->size();
0226     int m;
0227     bool skip;
0228     for (i = 0; i < n; ++i) {
0229       skip = false;
0230       BPHRecoConstCandPtr cand = collection->at(i);
0231       if (contained(compSet, cand))
0232         continue;
0233       m = momSelector.size();
0234       for (j = 0; j < m; ++j) {
0235         if (!momSelector[j]->accept(*cand)) {
0236           skip = true;
0237           break;
0238         }
0239       }
0240       if (skip)
0241         continue;
0242       m = vtxSelector.size();
0243       for (j = 0; j < m; ++j) {
0244         if (!vtxSelector[j]->accept(*cand)) {
0245           skip = true;
0246           break;
0247         }
0248       }
0249       if (skip)
0250         continue;
0251       m = fitSelector.size();
0252       for (j = 0; j < m; ++j) {
0253         if (!fitSelector[j]->accept(*cand)) {
0254           skip = true;
0255           break;
0256         }
0257       }
0258       if (skip)
0259         continue;
0260       compMap[*source->name] = cand;
0261       build(compList, compSet, r_iter, r_iend, c_iter, c_iend);
0262       compMap.erase(*source->name);
0263     }
0264     return;
0265   }
0266   BPHRecoSource* source = *r_iter++;
0267   const BPHGenericCollection* collection = source->collection;
0268   vector<const BPHRecoSelect*>& selector = source->selector;
0269   int i;
0270   int j;
0271   int n = collection->size();
0272   int m = selector.size();
0273   bool skip;
0274   for (i = 0; i < n; ++i) {
0275     const reco::Candidate& cand = collection->get(i);
0276     if (contained(compSet, &cand))
0277       continue;
0278     skip = false;
0279     for (j = 0; j < m; ++j) {
0280       if (!selector[j]->accept(cand, this)) {
0281         skip = true;
0282         break;
0283       }
0284     }
0285     if (skip)
0286       continue;
0287     BPHDecayMomentum::Component comp;
0288     comp.cand = &cand;
0289     comp.mass = source->mass;
0290     comp.msig = source->msig;
0291     comp.searchList = collection->searchList();
0292     compSet.daugMap[*source->name] = comp;
0293     daugMap[*source->name] = &cand;
0294     build(compList, compSet, r_iter, r_iend, c_iter, c_iend);
0295     daugMap.erase(*source->name);
0296     compSet.daugMap.erase(*source->name);
0297   }
0298   return;
0299 }
0300 
0301 bool BPHRecoBuilder::contained(ComponentSet& compSet, const reco::Candidate* cand) const {
0302   map<string, BPHDecayMomentum::Component>& dMap = compSet.daugMap;
0303   map<string, BPHDecayMomentum::Component>::const_iterator d_iter;
0304   map<string, BPHDecayMomentum::Component>::const_iterator d_iend = dMap.end();
0305   for (d_iter = dMap.begin(); d_iter != d_iend; ++d_iter) {
0306     const reco::Candidate* cChk = d_iter->second.cand;
0307     if (cand == cChk)
0308       return true;
0309     if (sameTrack(cand, cChk))
0310       return true;
0311   }
0312   return false;
0313 }
0314 
0315 bool BPHRecoBuilder::contained(ComponentSet& compSet, BPHRecoConstCandPtr cCand) const {
0316   map<string, BPHRecoConstCandPtr>::const_iterator c_iter;
0317   map<string, BPHRecoConstCandPtr>::const_iterator c_iend = compMap.end();
0318   const vector<const reco::Candidate*>& dCand = cCand->daughFull();
0319   int j;
0320   int m = dCand.size();
0321   int k;
0322   int l;
0323   for (j = 0; j < m; ++j) {
0324     const reco::Candidate* cand = cCand->originalReco(dCand[j]);
0325     map<string, BPHDecayMomentum::Component>& dMap = compSet.daugMap;
0326     map<string, BPHDecayMomentum::Component>::const_iterator d_iter;
0327     map<string, BPHDecayMomentum::Component>::const_iterator d_iend = dMap.end();
0328     for (d_iter = dMap.begin(); d_iter != d_iend; ++d_iter) {
0329       const reco::Candidate* cChk = d_iter->second.cand;
0330       if (cand == cChk)
0331         return true;
0332       if (sameTrack(cand, cChk))
0333         return true;
0334     }
0335 
0336     for (c_iter = compMap.begin(); c_iter != c_iend; ++c_iter) {
0337       const pair<string, BPHRecoConstCandPtr>& entry = *c_iter;
0338       BPHRecoConstCandPtr cCChk = entry.second;
0339       const vector<const reco::Candidate*>& dCChk = cCChk->daughFull();
0340       l = dCChk.size();
0341       for (k = 0; k < l; ++k) {
0342         const reco::Candidate* cChk = cCChk->originalReco(dCChk[k]);
0343         if (cand == cChk)
0344           return true;
0345         if (sameTrack(cand, cChk))
0346           return true;
0347       }
0348     }
0349   }
0350 
0351   return false;
0352 }
0353 
0354 bool BPHRecoBuilder::sameTrack(const reco::Candidate* lCand, const reco::Candidate* rCand) const {
0355   return sameTrack(lCand, rCand, minPDiff);
0356 }