JetCombinatorics.cc

Go to the documentation of this file.

#include "TopQuarkAnalysis/TopPairBSM/interface/JetCombinatorics.h"
#include "TMath.h"

#include <iostream>

std::string itoa(int i) {
  char temp[20];
  sprintf(temp,"%d",i);
  return((std::string)temp);
}



//_______________________________________________________________
JetCombinatorics::JetCombinatorics() {

    this->Clear();
        
    minMassLepW_ = -999999.;
    maxMassLepW_ = 999999.;
    minMassHadW_ = -999999.;
    maxMassHadW_ = 999999.;
    minMassLepTop_ = -999999.;
    maxMassLepTop_ = 999999.;
    
    minPhi_ = -1.;
    removeDuplicates_ = true;
    maxNJets_ = 9999;
    verbosef = false;
    UsebTagging_ = false;
    UseMtop_ = true;
    SigmasTypef = 0;
    UseFlv_ = false;
    
    Template4jCombos_ = NestedCombinatorics(); // 12 combinations
    Template5jCombos_ = Combinatorics(4,5); // 5 combinations of 4 combos
    Template6jCombos_ = Combinatorics(4,6); // 15 combinations of 4 combos
    Template7jCombos_ = Combinatorics(4,7); // xx combinations of 4 combos
    
}

//_______________________________________________________________
JetCombinatorics::~JetCombinatorics() {
  this->Clear();
}

//_______________________________________________________________
void JetCombinatorics::Clear() {

    allCombos_.clear();
    allCombosSumEt_.clear();
    Template4jCombos_.clear();
    Template5jCombos_.clear();
    Template6jCombos_.clear();
    Template7jCombos_.clear();
    cand1_.clear();
    
}
    

//_______________________________________________________________
std::map< int, std::string > JetCombinatorics::Combinatorics(int n, int max) {

    // find a combinatorics template
    // This is a simple stupid function to make algebratic combinatorics

    int kcombos = n;
    int maxcombos = max;

    std::string list;

    for ( int m=0; m<maxcombos; m++) { list = list + (itoa(m));}

    std::string seed;
    for ( int m=0; m<kcombos; m++) { seed = seed + (itoa(m));}

    
    std::map< int, std::string > aTemplateCombos;
    aTemplateCombos.clear();
    
    aTemplateCombos[0] = seed;

    int i = 0;
    int totalmatches = seed.size();
    int totalIte = list.size();

    for ( int ite = 0; ite < ((int)totalIte); ite++) {

        //cout << "iteration " << ite << endl;
        //i = 0;
        //for ( Itevec = seed.begin(); Itevec != seed.end(); ++Itevec) {
        for ( i=0; i< (int) totalmatches; i++) {

            std::string newseed = aTemplateCombos[ite];
            std::string newseed2;
            /*
            cout << "newseed size= " << newseed.size() << " : ";
            for (std::vector< std::string>::iterator iite = newseed.begin();
                 iite != newseed.end(); ++iite) {

                cout << *iite << " ";
            }
            cout << endl;
            */
            for ( int itemp=0; itemp<(int)newseed.size(); itemp++) {
                if (itemp!=i) newseed2 = newseed2 + (newseed[itemp]);
            }
            /*
            cout << "newseed2: ";
            for (std::vector< std::string>::iterator iite = newseed2.begin();
                 iite != newseed2.end(); ++iite) {

                cout << *iite << " ";
            }
            cout << endl;
            */
            for ( int j=0; j<(int) list.size(); j++) {
                //cout << " j = " << j << endl;
                bool Isnewelement = true;
                std::string newelement = "0";
                //bool Isnewcombo = true;
                for (int k=0; k< (int)newseed2.size(); k++) {
                    if ( list[j] == newseed2[k] ) Isnewelement = false;
                }
                if (Isnewelement) {

                    newelement = list[j];
                    //cout << "new element: " << newelement << endl;

                    std::string candseed = newseed2;
                    candseed = candseed + newelement;

                    bool IsnewCombo = true;
                    for (int ic=0; ic<(int)aTemplateCombos.size(); ++ic ) {

                        int nmatch = 0;
                        for ( int ij=0; ij<(int)(aTemplateCombos[ic]).size(); ij++) {

                            for (int ik=0; ik<(int)candseed.size(); ik++) {
                                if ( candseed[ik] == aTemplateCombos[ic][ij] ) nmatch++;
                            }
                        }
                        if (nmatch == (int)totalmatches)
                            IsnewCombo = false;

                    }
                    if (IsnewCombo) {
                        //cout << "new combo"<< " before combo size=" << aTemplateCombos.size() << endl;
                        aTemplateCombos[(int)aTemplateCombos.size()] = candseed;
                        //cout << " after size = " << aTemplateCombos.size() << endl;
                    }
                }

            }
        }
    }//close iterations

    // debug info
    
    //std::cout << " build templates for total combos = " << aTemplateCombos.size() << std::endl;
    //std::cout << " template combos: " << std::endl;
    //for (size_t ic=0; ic != aTemplateCombos.size(); ++ic) {

    //std::cout << aTemplateCombos[ic] << std::endl;
    //}
    
    return aTemplateCombos;
    
    
    
}


//______________________________________________________________
std::map< int, std::string > JetCombinatorics::NestedCombinatorics() {

    // build by hand 12 combinations for semileptonic top decays

    std::map< int, std::string > aTemplateCombos;
    aTemplateCombos.clear();
    
    aTemplateCombos[0] = "0123";
    aTemplateCombos[1] = "0132";
    aTemplateCombos[2] = "0213";
    aTemplateCombos[3] = "0231";
    aTemplateCombos[4] = "0312";
    aTemplateCombos[5] = "0321";
    aTemplateCombos[6] = "1203";
    aTemplateCombos[7] = "1230";
    aTemplateCombos[8] = "1302";
    aTemplateCombos[9] = "1320";
    aTemplateCombos[10] = "2301";
    aTemplateCombos[11] = "2310";
        
    return aTemplateCombos;

}

//______________________________________________________________
void JetCombinatorics::FourJetsCombinations(std::vector<TLorentzVector> jets, std::vector<double> bdiscriminators ) {


    int n = 0; // total number of combos
    std::map< Combo, int, minChi2 > allCombos;
    std::map< Combo, int, maxSumEt > allCombosSumEt;
    
    std::map< int, std::string > aTemplateCombos;
    aTemplateCombos.clear();

    if ( jets.size() == 4 ) aTemplateCombos[0] = std::string("0123");
    if ( jets.size() == 5 ) aTemplateCombos = Template5jCombos_;
    if ( jets.size() == 6 ) aTemplateCombos = Template6jCombos_;
    if ( jets.size() == 7 ) aTemplateCombos = Template7jCombos_;    

    // force to use only 4 jets
    if ( maxNJets_ == 4 ) aTemplateCombos[0] = std::string("0123");
    
    if (verbosef) std::cout << "[JetCombinatorics] size of vector of jets = " << jets.size() << std::endl;
    
    for (size_t ic=0; ic != aTemplateCombos.size(); ++ic) {

        if (verbosef) std::cout << "[JetCombinatorics] get 4 jets from the list, cluster # " << ic << "/"<< aTemplateCombos.size()-1 << std::endl;
        
        // get a template
        std::string aTemplate = aTemplateCombos[ic];

        if (verbosef) std::cout << "[JetCombinatorics] template of 4 jets = " << aTemplate << std::endl;
        
        // make a list of 4 jets
        std::vector< TLorentzVector > the4jets;
        std::vector< int > the4Ids;
        std::vector< double > thebdisc;
        std::vector< double > theFlvCorr;
        //the4jets[0] = jets[0];
        
        for (int ij=0; ij<4; ij++) {
            //std::cout << "ij= " << ij << std::endl;
            //std::cout << "atoi = " << atoi((aTemplate.substr(0,1)).c_str()) << std::endl;
            //std::cout << "jets[].Pt = " << jets[ij].Pt() << std::endl;
            int tmpi = atoi((aTemplate.substr(ij,1)).c_str());
            //std::cout << "tmpi= " << tmpi << std::endl;
            the4jets.push_back(jets[tmpi]);
            the4Ids.push_back(tmpi);
            if ( UsebTagging_ ) thebdisc.push_back( bdiscriminators[tmpi] );
            if ( UseFlv_ ) theFlvCorr.push_back( flavorCorrections_[tmpi] );
        }

        if (verbosef) std::cout<< "[JetCombinatorics] with these 4 jets, make 12 combinations: " <<std::endl;

        //std::cout << " the4jets[ij].size = " << the4jets.size() << std::endl;
            
        for (size_t itemplate=0; itemplate!= Template4jCombos_.size(); ++itemplate) {
            
            std::string a4template = Template4jCombos_[itemplate];

            if (verbosef) std::cout << "[JetCombinatorics] ==> combination: " << a4template << " is # " << itemplate << "/"<<  Template4jCombos_.size()-1 << std::endl;
            
            Combo acombo;
            
            acombo.SetWp( the4jets[atoi((a4template.substr(0,1)).c_str())] );
            acombo.SetWq( the4jets[atoi((a4template.substr(1,1)).c_str())] );
            acombo.SetHadb( the4jets[atoi((a4template.substr(2,1)).c_str())] );
            acombo.SetLepb( the4jets[atoi((a4template.substr(3,1)).c_str())] );
            acombo.SetLepW( theLepW_ );

            acombo.SetIdWp( the4Ids[atoi((a4template.substr(0,1)).c_str())] );
            acombo.SetIdWq( the4Ids[atoi((a4template.substr(1,1)).c_str())] );
            acombo.SetIdHadb( the4Ids[atoi((a4template.substr(2,1)).c_str())] );
            acombo.SetIdLepb( the4Ids[atoi((a4template.substr(3,1)).c_str())] );
            //std::cout << " acombo setup" << std::endl;

            if ( UseFlv_ ) {
                acombo.SetFlvCorrWp( theFlvCorr[atoi((a4template.substr(0,1)).c_str())] );
                acombo.SetFlvCorrWq( theFlvCorr[atoi((a4template.substr(1,1)).c_str())] );
                acombo.SetFlvCorrHadb( theFlvCorr[atoi((a4template.substr(2,1)).c_str())] );
                acombo.SetFlvCorrLepb( theFlvCorr[atoi((a4template.substr(3,1)).c_str())] );
                acombo.ApplyFlavorCorrections();
            }
            if ( UsebTagging_ ) {

                acombo.Usebtagging();
                acombo.SetbDiscPdf(bTagPdffilename_);
                acombo.SetWp_disc( thebdisc[atoi((a4template.substr(0,1)).c_str())] );
                acombo.SetWq_disc( thebdisc[atoi((a4template.substr(1,1)).c_str())] );
                acombo.SetHadb_disc( thebdisc[atoi((a4template.substr(2,1)).c_str())] );
                acombo.SetLepb_disc( thebdisc[atoi((a4template.substr(3,1)).c_str())] );
                
            }

            acombo.UseMtopConstraint(UseMtop_);
            // choose value of sigmas
            acombo.SetSigmas(SigmasTypef);

            acombo.analyze();

            if (verbosef) {

              std::cout << "[JetCombinatorics] ==> combination done:" << std::endl;
              acombo.Print();
            }

            // invariant mass cuts
            TLorentzVector aHadWP4 = acombo.GetHadW();
            TLorentzVector aLepWP4 = acombo.GetLepW();
            TLorentzVector aLepTopP4=acombo.GetLepTop();
            
            if ( ( aHadWP4.M() > minMassHadW_ && aHadWP4.M() < maxMassHadW_ ) &&
                 ( aLepWP4.M() > minMassLepW_ && aLepWP4.M() < maxMassLepW_ ) &&
                 ( aLepTopP4.M() > minMassLepTop_ && aLepTopP4.M() < maxMassLepTop_) ) {
            
                allCombos[acombo] = n;
                allCombosSumEt[acombo] = n;
            
                n++;
            }
        
        }
    }

    allCombos_ = allCombos;
    allCombosSumEt_ = allCombosSumEt;
       
}

Combo JetCombinatorics::GetCombination(int n) {

    int j = 0;
    Combo a;
    for ( std::map<Combo,int,minChi2>::const_iterator ite=allCombos_.begin();
          ite!=allCombos_.end(); ++ite) {
        
        if (j == n) a = ite->first;
        j++;
    }

    return a;

    
}

Combo JetCombinatorics::GetCombinationSumEt(int n) {

    int j = 0;
    Combo a;
    for ( std::map<Combo,int,maxSumEt>::const_iterator ite=allCombosSumEt_.begin();
          ite!=allCombosSumEt_.end(); ++ite) {
        
        if (j == n) a = ite->first;
        j++;
    }

    return a;

    
}