////////////////////////
// Clear the event list
SEXP clear(SEXP eventList)
{
  TEventList* el = checkForEventListWrapper(eventList);
  
  el->Clear();
  
  return R_NilValue;
}
///////////////////////
// Get the number of entries in the event list
SEXP nEntriesEventList(SEXP eventList)
{
  TEventList* el = checkForEventListWrapper(eventList);
  
  SEXP n = NEW_INTEGER(1);
  INTEGER(n)[0] = el->GetN();
  
  return n;
}
///////////////////////
// Get the title of the event list
SEXP getTitle(SEXP eventList)
{
  TEventList* el = checkForEventListWrapper(eventList);
  
  SEXP name = NEW_CHARACTER(1);
  SET_STRING_ELT( name, 0, mkChar(el->GetTitle()) );
  
  return name;
}
/////////////////////////
// Put entries into the event list
SEXP putIntoEventList(SEXP eventList, SEXP entryNums)
{
  
  TEventList* el = checkForEventListWrapper(eventList);
  
  for ( unsigned int i = 0; i < GET_LENGTH(entryNums); ++i ) {
    el->Enter( INTEGER(entryNums)[i] );
  }

  return R_NilValue;
}
////////////////
// Get the event list
SEXP RootChainManager::getEventListName()
{
  TEventList* ev = m_chain->GetEventList();
	
  if (! ev ) return R_NilValue;
	
  SEXP r = NEW_CHARACTER(1);
  SET_STRING_ELT(r, 0, mkChar(ev->GetName()) );
	
  return r;
}
void NCIdeogram::addTree(TTree *tree, const char *mu, const char *sigma)
{
	TLeaf *leafMu = tree->FindLeaf(mu);
	TLeaf *leafSigma = tree->FindLeaf(sigma);
	TEventList *elist = tree->GetEventList();
	Long64_t j,ix,nbr;
	
	nbr = elist ? elist->GetN() : tree->GetEntries();
	for (j = 0; j < nbr; j++) {
		ix = elist ? elist->GetEntry(j) : j;
		tree->GetEntry(ix);
		addPoint(leafMu->GetValue(), leafSigma->GetValue());
	}
} // addTree()
/////////////////////////
// Return a logical vector if entries are in the event list
SEXP isInEventList(SEXP eventList, SEXP entryNums)
{
  
  TEventList* el = checkForEventListWrapper(eventList);
  
  SEXP l;
  PROTECT(l = NEW_LOGICAL( GET_LENGTH(entryNums) ) );
  
  for ( unsigned int i = 0; i < GET_LENGTH(entryNums); ++i ) {
    LOGICAL(l)[i] = el->Contains( INTEGER(entryNums)[i] ) == 1;
  }
  
  UNPROTECT(1);
  
  return l;
}
void treeTest(  const TString fList = "temp.list",
                const TString fOutName = "fOut.root",
                Long64_t nEvents = 9999
                ) 
{

	gROOT->LoadMacro("$STAR/StRoot/StMuDSTMaker/COMMON/macros/loadSharedLibraries.C");
    gROOT->LoadMacro("makeEventList.C");
	loadSharedLibraries();

    TFile* fOut = new TFile(fOutName.Data(),"RECREATE");

    TH1D* hZdc = new TH1D("hZdc","hZdc", 50, 0.5, 5000.5);

	//----------------- Read data using StMuDstMaker ---------------//
	StChain* muChain = new StChain("StChain");
	StMuDstMaker* muMaker = new StMuDstMaker(0,0,"",fList.Data(),"st:MuDst.root", 100, "MuDst");

    muChain->Init();
    Float_t zdcCut = 1623;

    TEventList* eventList = makeEventList(muMaker->chain(), zdcCut);
    muMaker->SetEventList(eventList);
    Long64_t nList = eventList->GetN();
    if(nList < nEvents) {nEvents = nList;}

    for(Int_t i = 0; i <= (nEvents-1); i++)
    {
        muChain->Make();
        Float_t zdcWest = muMaker->muDst()->event()->zdcTriggerDetector().adc(0);
        Float_t zdcEast = muMaker->muDst()->event()->zdcTriggerDetector().adc(4);

        hZdc->Fill(zdcWest);
        hZdc->Fill(zdcEast);


    }

    muChain->Finish();
    fOut->Write();
    fOut->Close();

    delete muChain;
    delete eventList;

}
//////////////////////////
// Return all of the events as a big vector
SEXP getEntries(SEXP eventList)
{
  TEventList* el = checkForEventListWrapper(eventList);
  
  unsigned int l = el->GetN();
  
  SEXP e;
  PROTECT( e = NEW_INTEGER(l) );
  
  for ( unsigned int i = 0; i < l; ++i) {
    INTEGER(e)[i] = el->GetEntry(i);
  }
  
  UNPROTECT(1);
  
  return e;
}
Exemple #10
0
    int CEntityParent::lTriggerEvent(lua_State* L)
    {
        //first param is userdata
        int nEventId = luaL_checkint(L, 2);
        CHECK_UNSIGNED(nEventId, 2);

        //参数个数
        int nParam = lua_gettop(L) - 2;

        if (nParam >= 0)
        {
            CEventDispatcher * p = GetWorld()->GetEventDispatcher();
            TEventList* l = p->TriggerEvent(GetId(), nEventId);
            if (l)
            {
                TEventList::iterator iter1 = l->begin();
                map<TENTITYID, string> tmap;
                for (;iter1 != l->end(); iter1++)
                {
                    tmap.insert(make_pair(iter1->first, iter1->second));
                }

                map<TENTITYID, string>::iterator iter2 = tmap.begin();
                for (;iter2 != tmap.end(); ++iter2)
                {
                    CEntityParent* pe = GetWorld()->GetEntity(iter2->first);
                    if(pe)
                    {
                        int n = EntityMethodCall(L, pe, iter2->second.c_str(), nParam, 0);
                        lua_pop(L, n);
                        //LogDebug("lTriggerEvent", "%d", l->size());
                    }
                }
            }
        }

        return 0;
    }
//this file stores the data events in our signal regions in several histograms 
//that are used by MT2Results_PlotsAndTables.C
//can also choose to store files in control region or MC events
//additionally it creates a log file with run:lumisection:eventnumber for all those events.
void MakeDataFile(){

	fLogStream = new std::ostringstream();

	bool poisson = false;//set poissonian uncertainties, works from next root version on

	//decide on filename histograms are stored, also define the samples.dat
  	gROOT->ProcessLine(".x SetStyle_PRD.C");
	TString fOutDir                    = "../Results/Filtered/";
	TString outputname = "NewDataNumbers.root";
	if(ourfilter    ) outputname = "NewDataNumbersOurFilter.root";
	if(calometfilter) outputname = "NewDataNumbersOurFilterCaloMETfilter.root";
	if(tobtecfilter ) outputname = "NewDataNumbersOurFilterCaloMETfilterTOBTECFilter.root";
	if(poisson) outputname = "NewDataNumbersPoisson.root";
	TString samples = "samples/samples_HTandMET_filter.dat";

	//definition of the histograms
	map<string, TH1D*>    histos;
	for(int i2 = 0; i2<signalregionsize; ++i2){
	for(int i3 = 0; i3<HTbinsize;        ++i3){
		int NMT2bins;
		if(i3==0){
			if(signal_region[i2]=="2j0b")    NMT2bins = gNMT2bins_2j0b_lHT;
			if(signal_region[i2]=="2j1to2b") NMT2bins = gNMT2bins_2j1b_lHT;
			if(signal_region[i2]=="3to5j0b") NMT2bins = gNMT2bins_3j0b_lHT;
			if(signal_region[i2]=="3to5j1b") NMT2bins = gNMT2bins_3j1b_lHT;
			if(signal_region[i2]=="3to5j2b") NMT2bins = gNMT2bins_3j2b_lHT;
			if(signal_region[i2]=="6j0b")    NMT2bins = gNMT2bins_6j0b_lHT;
			if(signal_region[i2]=="6j1b")    NMT2bins = gNMT2bins_6j1b_lHT;
			if(signal_region[i2]=="6j2b")    NMT2bins = gNMT2bins_6j2b_lHT;
			if(signal_region[i2]=="3b")      NMT2bins = gNMT2bins_3b_lHT;
		} if(i3==1){
			if(signal_region[i2]=="2j0b")    NMT2bins = gNMT2bins_2j0b_mHT;
			if(signal_region[i2]=="2j1to2b") NMT2bins = gNMT2bins_2j1b_mHT;
			if(signal_region[i2]=="3to5j0b") NMT2bins = gNMT2bins_3j0b_mHT;
			if(signal_region[i2]=="3to5j1b") NMT2bins = gNMT2bins_3j1b_mHT;
			if(signal_region[i2]=="3to5j2b") NMT2bins = gNMT2bins_3j2b_mHT;
			if(signal_region[i2]=="6j0b")    NMT2bins = gNMT2bins_6j0b_mHT;
			if(signal_region[i2]=="6j1b")    NMT2bins = gNMT2bins_6j1b_mHT;
			if(signal_region[i2]=="6j2b")    NMT2bins = gNMT2bins_6j2b_mHT;
			if(signal_region[i2]=="3b")      NMT2bins = gNMT2bins_3b_mHT;
		} if(i3==2){
			if(signal_region[i2]=="2j0b")    NMT2bins = gNMT2bins_2j0b_hHT;
			if(signal_region[i2]=="2j1to2b") NMT2bins = gNMT2bins_2j1b_hHT;
			if(signal_region[i2]=="3to5j0b") NMT2bins = gNMT2bins_3j0b_hHT;
			if(signal_region[i2]=="3to5j1b") NMT2bins = gNMT2bins_3j1b_hHT;
			if(signal_region[i2]=="3to5j2b") NMT2bins = gNMT2bins_3j2b_hHT;
			if(signal_region[i2]=="6j0b")    NMT2bins = gNMT2bins_6j0b_hHT;
			if(signal_region[i2]=="6j1b")    NMT2bins = gNMT2bins_6j1b_hHT;
			if(signal_region[i2]=="6j2b")    NMT2bins = gNMT2bins_6j2b_hHT;
			if(signal_region[i2]=="3b")      NMT2bins = gNMT2bins_3b_hHT;
		}
  		double MT2bins[NMT2bins+1];
		if(i3==0){
			if(signal_region[i2]=="2j0b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_2j0b_lHT[i0]; }
			if(signal_region[i2]=="2j1to2b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_2j1b_lHT[i0]; }
			if(signal_region[i2]=="3to5j0b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j0b_lHT[i0]; }
			if(signal_region[i2]=="3to5j1b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j1b_lHT[i0]; }
			if(signal_region[i2]=="3to5j2b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j2b_lHT[i0]; }
			if(signal_region[i2]=="6j0b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j0b_lHT[i0]; }
			if(signal_region[i2]=="6j1b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j1b_lHT[i0]; }
			if(signal_region[i2]=="6j2b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j2b_lHT[i0]; }
			if(signal_region[i2]=="3b")      { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3b_lHT[i0];   }
		} if(i3==1){
			if(signal_region[i2]=="2j0b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_2j0b_mHT[i0];  }
			if(signal_region[i2]=="2j1to2b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_2j1b_mHT[i0];  }
			if(signal_region[i2]=="3to5j0b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j0b_mHT[i0];  }
			if(signal_region[i2]=="3to5j1b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j1b_mHT[i0];  }
			if(signal_region[i2]=="3to5j2b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j2b_mHT[i0];  }
			if(signal_region[i2]=="6j0b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j0b_mHT[i0];  }
			if(signal_region[i2]=="6j1b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j1b_mHT[i0];  }
			if(signal_region[i2]=="6j2b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j2b_mHT[i0];  }
			if(signal_region[i2]=="3b")      { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3b_mHT[i0];    }
		} if(i3==2){
			if(signal_region[i2]=="2j0b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_2j0b_hHT[i0];  }
			if(signal_region[i2]=="2j1to2b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_2j1b_hHT[i0];  }
			if(signal_region[i2]=="3to5j0b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j0b_hHT[i0];  }
			if(signal_region[i2]=="3to5j1b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j1b_hHT[i0];  }
			if(signal_region[i2]=="3to5j2b") { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3j2b_hHT[i0];  }
			if(signal_region[i2]=="6j0b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j0b_hHT[i0];  }
			if(signal_region[i2]=="6j1b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j1b_hHT[i0];  }
			if(signal_region[i2]=="6j2b")    { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_6j2b_hHT[i0];  }
			if(signal_region[i2]=="3b")      { for(int i0 = 0; i0<=NMT2bins; ++i0) MT2bins[i0] = gMT2bins_3b_hHT[i0];    }
		}

		string hs = string("_") + HT_bin[i3] + string("_") + signal_region[i2];
		string mapname = "MT2" + hs;
		if(histos.count(mapname) == 0 ) histos[mapname] = new TH1D(mapname.c_str(), "", NMT2bins, MT2bins);
	//	if(poisson) histos[mapname]->SetBinErrorOption((TH1::EBinErrorOpt)1);//store already here the poissonian errors, works from next root version on
	}}
	for(map<string,TH1D*>::iterator h=histos.begin(); h!=histos.end();++h){
		h->second->Sumw2();}

	//signal selection cuts
	std::ostringstream  fCutStreamSignal;
	fCutStreamSignal << " " 
	  << "misc.MT2>=100"                                               << "&&"
	  << "misc.MET>=30"                                                << "&&"
	  << "misc.HT >=450"                                               << "&&"
	  << "NEles==0"                                                    << "&&"
	  << "NMuons==0"                                                   << "&&"
	  << "NTausIDLoose3Hits==0"                                        << "&&"
	  << "misc.Jet0Pass ==1"                                           << "&&"
	  << "misc.Jet1Pass ==1"                                           << "&&"
	  << "misc.PassJet40ID ==1"                                        << "&&"
	  << "NJetsIDLoose40 >=2"                                          << "&&"
	  << "misc.MinMetJetDPhi4Pt40 >0.3"                                << "&&"
	  << "misc.Vectorsumpt < 70"                                       << "&&"
	  // Noise
	  << "(misc.HBHENoiseFlag == 0 || misc.ProcessID==10)"             << "&&" // for rare SM samples
	  << "misc.CSCTightHaloIDFlag == 0"                                << "&&"
	  << "misc.trackingFailureFlag==0"                                 << "&&"
	  << "misc.eeBadScFlag==0"                                         << "&&"
	  << "misc.EcalDeadCellTriggerPrimitiveFlag==0"                    << "&&"
	  << "misc.TrackingManyStripClusFlag==0"                           << "&&"
	  << "misc.TrackingTooManyStripClusFlag==0"                        << "&&"
	  << "misc.TrackingLogErrorTooManyClustersFlag==0"                 << "&&"
          << "misc.CrazyHCAL==0";
	fCutStreamSignal << "&&((misc.MET>=200&&misc.MT2>=200&&misc.HT<750)||(misc.HT>750))";
	fCutStreamSignal << "&&NJetsIDLoose40>=2";
	fCutStreamSignal << "&&misc.MET/misc.CaloMETRaw<=2.";
	TString cuts = fCutStreamSignal.str().c_str();

  std::ostringstream triggerStream;
  triggerStream << "( ( ( "
		<< "trigger.HLT_PFHT650_v5 == 1 || trigger.HLT_PFHT650_v6 == 1 || trigger.HLT_PFHT650_v7 == 1 || trigger.HLT_PFHT650_v8 == 1 || trigger.HLT_PFHT650_v9 == 1 || "
		<< "trigger.HLT_PFNoPUHT650_v1 == 1 || trigger.HLT_PFNoPUHT650_v3 == 1 || trigger.HLT_PFNoPUHT650_v4 == 1) ||";

  triggerStream << "( ( "
		<< "trigger.HLT_PFMET150_v2 == 1 || trigger.HLT_PFMET150_v3 == 1 || trigger.HLT_PFMET150_v4 == 1 || "
  		<< "trigger.HLT_PFMET150_v5 == 1 || trigger.HLT_PFMET150_v6 == 1 || trigger.HLT_PFMET150_v7 == 1 )"
		<< "||("
		<< "trigger.HLT_PFHT350_PFMET100_v3==1 || trigger.HLT_PFHT350_PFMET100_v4==1 || trigger.HLT_PFHT350_PFMET100_v5==1 || "
		<< "trigger.HLT_PFHT350_PFMET100_v6==1 || trigger.HLT_PFHT350_PFMET100_v7==1 || trigger.HLT_PFNoPUHT350_PFMET100_v1==1 || "
		<< "trigger.HLT_PFNoPUHT350_PFMET100_v3==1 || trigger.HLT_PFNoPUHT350_PFMET100_v4==1 ) ) )&&TOBTECTagger<=8&&ExtraBeamHaloFilter==0)";

	TString trigger = triggerStream.str().c_str();
	load(samples.Data());

	int counterAll = 0;

  	for(size_t i = 0; i < fSamples.size(); ++i){

	    string sampletype = (string)fSamples[i].type;
	    if(sampletype!="data") continue;//run only over data - extendable to MC 

	    Double_t sample_weight = fSamples[i].xsection * fSamples[i].kfact * fSamples[i].lumi / (fSamples[i].nevents*fSamples[i].PU_avg_weight);
	    if(fVerbose>2) cout << "ZnunuNumbers: looping over " << fSamples[i].name << " added in " << sampletype << endl;
	    if(fVerbose>2) cout << "              sample has weight " << sample_weight << " and " << fSamples[i].tree->GetEntries() << " entries" << endl; 
	    if(fVerbose>2 && fSamples[i].tree->GetEntries()==0) cout << "skip sample, has no entries" << endl;
            if(fSamples[i].tree->GetEntries()==0) continue;

	    MT2tree* fMT2tree = new MT2tree();
	    fSamples[i].tree->SetBranchAddress("MT2tree", &fMT2tree);
	    Long64_t nentries =  fSamples[i].tree->GetEntries();
	    Long64_t nbytes = 0, nb = 0;
	    int nev =0;
        
	    TString myCuts = cuts;// + "&&" + basecuts;
        
	    if( fSamples[i].type=="data") myCuts += " && " + trigger; //cuts to be aplied only on data
        
   	    cout << "Cuts for Flow: " << myCuts << endl;
   	    fSamples[i].tree->Draw(">>selList", myCuts);
        
	    TEventList *myEvtList = (TEventList*)gDirectory->Get("selList");
	    fSamples[i].tree->SetEventList(myEvtList);
	    int counter=0;
	    cout << "Filtering done, size=" <<myEvtList->GetN()  << endl;
	    if(myEvtList->GetSize()==0) continue;
	*fLogStream << "Sample " << fSamples[i].name << endl;
	//run over all selected events
        while(myEvtList->GetEntry(counter++) !=-1){	
		int jentry = myEvtList->GetEntry(counter-1);
            
		nb =  fSamples[i].tree->GetEntry(jentry);   nbytes += nb;
		fSamples[i].tree->SetBranchAddress("MT2tree", &fMT2tree);
		
		if ( fVerbose>2 && counter % 5000 == 0  )  cout << "+++ Proccessing event " << counter << endl;

		string sHT;//HT region
		if(fMT2tree->misc.HT<450.)      sHT = "_HTge0";
		else if(fMT2tree->misc.HT<750.) sHT = "_lowHT";
		else if(fMT2tree->misc.HT<1200.)sHT = "_mediumHT";
		else                            sHT = "_highHT";

		string ssignal;//topological region
		if(fMT2tree->NJetsIDLoose40 == 2 &&                                  fMT2tree->NBJets40CSVM == 0) ssignal = "_2j0b";
		if(fMT2tree->NJetsIDLoose40 == 2 &&                                  fMT2tree->NBJets40CSVM >= 1) ssignal = "_2j1to2b";
		if(fMT2tree->NJetsIDLoose40 >= 3 && fMT2tree->NJetsIDLoose40 <= 5 && fMT2tree->NBJets40CSVM == 0) ssignal = "_3to5j0b";
		if(fMT2tree->NJetsIDLoose40 >= 3 && fMT2tree->NJetsIDLoose40 <= 5 && fMT2tree->NBJets40CSVM == 1) ssignal = "_3to5j1b";
		if(fMT2tree->NJetsIDLoose40 >= 3 && fMT2tree->NJetsIDLoose40 <= 5 && fMT2tree->NBJets40CSVM == 2) ssignal = "_3to5j2b";
		if(                                                                  fMT2tree->NBJets40CSVM >= 3) ssignal = "_3b";
		if(fMT2tree->NJetsIDLoose40 >= 6 &&                                  fMT2tree->NBJets40CSVM == 0) ssignal = "_6j0b";
		if(fMT2tree->NJetsIDLoose40 >= 6 &&                                  fMT2tree->NBJets40CSVM == 1) ssignal = "_6j1b";
		if(fMT2tree->NJetsIDLoose40 >= 6 &&                                  fMT2tree->NBJets40CSVM == 2) ssignal = "_6j2b";

		string hh = sHT + ssignal;
		histos[(string)"MT2"        + hh]->Fill(fMT2tree->misc.MT2);//fill histogram
		if(fMT2tree->misc.MT2>histos[(string)"MT2"        + hh]->GetBinLowEdge(1)){
			if(sHT=="_lowHT" && (fMT2tree->trigger.HLT_PFHT350_PFMET100_v3==1||fMT2tree->trigger.HLT_PFHT350_PFMET100_v4==1||fMT2tree->trigger.HLT_PFHT350_PFMET100_v5==1||fMT2tree->trigger.HLT_PFHT350_PFMET100_v6==1||fMT2tree->trigger.HLT_PFHT350_PFMET100_v7==1 || fMT2tree->trigger.HLT_PFNoPUHT350_PFMET100_v1==1 || fMT2tree->trigger.HLT_PFNoPUHT350_PFMET100_v3==1 || fMT2tree->trigger.HLT_PFNoPUHT350_PFMET100_v4==1 ) ) *fLogStream << "HTMHT ";
			else if(sHT=="_lowHT") *fLogStream << "MET   ";
			else *fLogStream << "JetHT ";
			*fLogStream << int(fMT2tree->misc.Run) << ":" << int(fMT2tree->misc.LumiSection) << ":" << int(fMT2tree->misc.Event) << endl;//file log file (including trigger stream
			++counterAll;
		}
	}//while
	delete fMT2tree;
	delete fSamples[i].tree;

	}//for samples

	cout << "add overflow to last bin" << endl;
	for(map<string,TH1D*>::iterator h=histos.begin(); h!=histos.end();++h){
		h->second->SetBinContent(h->second->GetNbinsX(),
					 h->second->GetBinContent(h->second->GetNbinsX()  )+ 
					 h->second->GetBinContent(h->second->GetNbinsX()+1)  );
		h->second->SetBinError(  h->second->GetNbinsX(),
					 sqrt(h->second->GetBinError(h->second->GetNbinsX()  )*
					      h->second->GetBinError(h->second->GetNbinsX()  )+
					      h->second->GetBinError(h->second->GetNbinsX()+1)*
					      h->second->GetBinError(h->second->GetNbinsX()+1)  ));
	}

	cout << "Saving." << endl;
    	TFile *fsavefile = new TFile(fOutDir + outputname,"RECREATE");
	fsavefile->cd();
	for(map<string,TH1D*>::iterator h=histos.begin(); h!=histos.end();++h){
		h->second->Write();
	}
	fsavefile->Close();
	cout << "Saved histograms in " << fOutDir << outputname << endl;

	TString logname ="eventlistMT2inclusive.log"; 
	cout << counterAll << " events in " << logname.Data() << endl;
	ofstream f_log (logname.Data(), ios::trunc);
	f_log << fLogStream->str();
}
Exemple #12
0
void Plot(Char_t *filen = "jsf.root")
{
  //gROOT->Reset();
  gSystem->Load("libS4Utils.so");
  gSystem->Load("libAnlib.so");

  Int_t nZoneX = 4;
  Int_t nZoneY = 3;

  TCanvas *c1 = new TCanvas("c1","",0,0, 300*nZoneX, 300*nZoneY);
  c1->SetHighLightColor(5);
  c1->SetFillColor(19);
  c1->Divide(nZoneX,nZoneY);

  gStyle->SetOptFit();

  cerr << filen << endl;
  TFile   *filep = new TFile(filen);
  TNtupleD *tup   = (TNtupleD *)gROOT->FindObject("hEvt");

  //--
  // Preselection
  //--
#if 0
  TString sel("evis>0.");
#else
  TString sel("pt<20.&&abs(pl)<30.&&ycut>0.0015");
#endif
  tup->Draw(">>elist",sel.Data(),"goff");

  TEventList *elist = static_cast<TEventList*>(gROOT->FindObject("elist"));
  Int_t nlist = elist->GetN();
  cerr << "Nevent = " << nlist << endl;

  //--
  // Loop over preselected events
  //--
  Double_t kToDeg = 180./TMath::Pi();
  for (Int_t i=0; i<nlist; i++) {
#if 0
        Int_t event = elist->GetEntry(i);
        cerr << "i = " << i << " event = " << event << endl;
#else
        Int_t event = i;
#endif
        Double_t ntracks;
        Double_t evis;
        Double_t pt;
        Double_t pl;
        Double_t ycut;
        Double_t chi2;
        Double_t mh;
        Double_t mw1;
        Double_t mw2;
        Double_t mt1;
        Double_t mt2;
        Double_t mtt;

        tup->SetBranchAddress("ntracks",&ntracks);
        tup->SetBranchAddress("evis",&evis);
        tup->SetBranchAddress("pt",&pt);
        tup->SetBranchAddress("pl",&pl);
        tup->SetBranchAddress("ycut",&ycut);
        tup->SetBranchAddress("chi2",&chi2);
        tup->SetBranchAddress("mh",&mh);
        tup->SetBranchAddress("mw1",&mw1);
        tup->SetBranchAddress("mw2",&mw2);
        tup->SetBranchAddress("mt1",&mt1);
        tup->SetBranchAddress("mt2",&mt2);
        tup->SetBranchAddress("mtt",&mtt);

        tup->GetEntry(event);

        hMhMw->Fill(mh,  mw1, 1.);
        hMwMw->Fill(mw1, mw2, 1.);
        hMtMt->Fill(mt1, mt2, 1.);
	hEvis->Fill(evis, 1.);
	hPtPl->Fill(pt, pl, 1.);
        hMttMh->Fill(mtt,  mh, 1.);
  }
  Int_t id = 0;
  id++; c1->cd(id); hStat->Draw();
  id++; c1->cd(id); hMhMw->Draw();
  id++; c1->cd(id); hMhMw->ProjectionX()->Draw();
  id++; c1->cd(id); hMhMw->ProjectionY()->Draw();
  id++; c1->cd(id); hEvis->Draw();
  id++; c1->cd(id); hMwMw->Draw();
  id++; c1->cd(id); hMwMw->ProjectionX()->Draw();
  id++; c1->cd(id); hMwMw->ProjectionY()->Draw();
  id++; c1->cd(id); hMtMt->Draw();
  id++; c1->cd(id); hMtMt->ProjectionX()->Draw();
  id++; c1->cd(id); hMtMt->ProjectionY()->Draw();
  id++; c1->cd(id); hMttMh->ProjectionX()->Draw();
}
Exemple #13
0
void RAA_calo_pf_JetCorrelation_pp(int startfile = 10, int endfile = 11, int radius=2, int deltaR=2/*which i will divide by 10 later when using*/, Float_t CALOPTCUT = 30.0, Float_t PFPTCUT = 30.0, char *dataset = "MC", char *etaWidth = "n20_eta_p20"){

  TH1::SetDefaultSumw2();

  TStopwatch timer;
  timer.Start();

  TDatime date;
  
  bool printDebug = false;

  // Since this has to run on the HiForest files, it is best to run them as condor jobs similar to the Pp data read macro, along with the jet trees which get their branch address set. 
  
  std::string infile1;
  if(dataset == "Data")infile1 = "jetRAA_pp_data_forest.txt";
  if(dataset == "MC")infile1 = "jetRAA_pp_mc_forest.txt";

  std::ifstream instr1(infile1.c_str(),std::ifstream::in);
  std::string filename1;

  cout<<"reading from "<<startfile<<" to "<<endfile<<endl;

  if(dataset=="MC"){
    for(int ifile = 0;ifile<4*startfile;ifile++){
      instr1>>filename1;
    }
  }
  if(dataset=="Data"){
    for(int ifile = 0;ifile<startfile;ifile++){
      instr1>>filename1;
    }
  }

  
  const int N = 5;
  
  TChain *jetpp1[N][no_radius];

  string dir[N][no_radius];
  
  for(int k = 0;k<no_radius;k++){
    dir[0][k] = "hltanalysis";
    dir[1][k] = "skimanalysis";
    dir[2][k] = Form("ak%dCaloJetAnalyzer",3);
    dir[3][k] = Form("ak%dPFJetAnalyzer",radius);
    dir[4][k] = "hiEvtAnalyzer";
    //dir[5][k] = "hltobject";
    //dir[6][k] = "pfcandAnalyzer";
  }
  
  
  string trees[N] = {
    "HltTree",
    "HltTree",
    "t",
    "t",
    "HiTree"
    //"jetObjTree",
    //"pfTree"
  };
  
  //this loop is to assign the tree values before we go into the file loop. 
  for(int k = 0;k<no_radius;k++){
    for(int t = 0;t<N;t++){
      jetpp1[t][k] = new TChain(string(dir[t][k]+"/"+trees[t]).data());
    }//tree loop ends
  }// radius loop ends
  
  if(dataset == "Data"){
    for(int ifile = startfile;ifile<endfile;ifile++){
    
      instr1>>filename1;
      if(printDebug)cout<<"File: "<<filename1<<endl;
      for(int k = 0;k<no_radius;k++){

	for(int t = 0;t<N;t++){
	
	  jetpp1[t][k]->Add(filename1.c_str());
	  if(printDebug)cout << "Tree loaded  " << string(dir[t][k]+"/"+trees[t]).data() << endl;
	  if(printDebug)cout << "Entries : " << jetpp1[t][k]->GetEntries() << endl;
		
	}// tree loop ends
      
      }// radius loop ends
    
    }// file loop ends

  }

  // these different file loops for MC is necessary because of eachfile being split into 4 files except the last pthat 540 which has 5 files. 
  if(dataset == "MC" && startfile <10){
    for(int ifile = 4*startfile;ifile<4*endfile;ifile++){
    
      instr1>>filename1;
      if(printDebug)cout<<"File: "<<filename1<<endl;
      for(int k = 0;k<no_radius;k++){

	for(int t = 0;t<N;t++){
	
	  jetpp1[t][k]->Add(filename1.c_str());
	  if(printDebug)cout << "Tree loaded  " << string(dir[t][k]+"/"+trees[t]).data() << endl;
	  if(printDebug)cout << "Entries : " << jetpp1[t][k]->GetEntries() << endl;
		
	}// tree loop ends
      
      }// radius loop ends
    
    }// file loop ends

  }

  if(dataset == "MC" && startfile == 10){
    for(int ifile = 4*startfile;ifile<4*endfile+1;ifile++){
    
      instr1>>filename1;
      if(printDebug)cout<<"File: "<<filename1<<endl;
      for(int k = 0;k<no_radius;k++){

	for(int t = 0;t<N;t++){
	
	  jetpp1[t][k]->Add(filename1.c_str());
	  if(printDebug)cout << "Tree loaded  " << string(dir[t][k]+"/"+trees[t]).data() << endl;
	  if(printDebug)cout << "Entries : " << jetpp1[t][k]->GetEntries() << endl;
		
	}// tree loop ends
      
      }// radius loop ends
    
    }// file loop ends

  }
  
  for(int k = 0;k<no_radius;k++){
    jetpp1[2][k]->AddFriend(jetpp1[0][k]);
    jetpp1[2][k]->AddFriend(jetpp1[1][k]);
    jetpp1[2][k]->AddFriend(jetpp1[4][k]);
    //jetpp1[2][k]->AddFriend(jetpp1[5][k]);
    
    jetpp1[3][k]->AddFriend(jetpp1[0][k]);
    jetpp1[3][k]->AddFriend(jetpp1[1][k]);
    jetpp1[3][k]->AddFriend(jetpp1[4][k]);
    //jetpp1[3][k]->AddFriend(jetpp1[5][k]);
    
  }// radius loop ends
 
  // Ok this should now work. 

  cout<<"total no of entries in the combined forest files = "<<jetpp1[2][0]->GetEntries()<<endl;
  //  if(printDebug)cout<<"total no of entries in the Jet80 Tree     = "<<jetpp2[2][0]->GetEntries()<<endl;

  // get the centrality weight, vz weight and the scale from the cross section, pt weighting. 
  static const Int_t nbins_pthat = 11;
  Double_t xsection[nbins_pthat+1] = {2.034e-01, 1.075e-02, 1.025e-03,  9.865e-05, 1.129e-05, 1.465e-06, 2.837e-07, 5.323e-08, 5.934e-09, 8.125e-10, 1.468e-10, 0};
  Double_t boundaries_pthat[nbins_pthat+1] = {15, 30, 50, 80, 120, 170, 220, 280, 370, 460, 540, 2000};
  TH1F * hpthatBin = new TH1F("hpthatBin","",nbins_pthat, boundaries_pthat);

  // Vertex reweighting for pp
  TF1 *fVzPP = new TF1("fVzPP","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x");
  fVzPP->SetParameters(8.41684e-01,-2.58609e-02,4.86550e-03,-3.10581e-04,2.07918e-05);
  
  
  TFile f(Form("/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_20/src/Output/pp_%s_closure_histogram_noJetID_deltaR_0p%d_ak%d_%d_%d.root",dataset,deltaR,radius,date.GetDate(),endfile),"RECREATE");
  f.cd();


  //set the branch addresses:
  // jet tree 1 - Calo 
  int nrefe_1;
  float pt_1[1000];
  float raw_1[1000];
  float refpt_1[1000];
  float eta_1[1000];
  float phi_1[1000];
  float chMax_1[1000];
  float trkMax_1[1000];
  float chSum_1[1000];
  float phSum_1[1000];
  float neSum_1[1000];
  float trkSum_1[1000];
  float phMax_1[1000];
  float neMax_1[1000];
  float eMax_1[1000];
  float muMax_1[1000];
  float eSum_1[1000];
  float muSum_1[1000];
  float jtpu_1[1000];
  float hcalSum_1[1000];
  float ecalSum_1[1000];
  int subid_1[1000];
  
  // jet tree 2 - PF
  int nrefe_2;
  float pt_2[1000];
  float raw_2[1000];
  float refpt_2[1000];
  float eta_2[1000];
  float eta_2_CM[1000];
  float phi_2[1000];
  float chMax_2[1000];
  float trkMax_2[1000];
  float chSum_2[1000];
  float phSum_2[1000];
  float neSum_2[1000];
  float trkSum_2[1000];
  float phMax_2[1000];
  float neMax_2[1000];
  float eMax_2[1000];
  float muMax_2[1000];
  float eSum_2[1000];
  float muSum_2[1000];
  float jtpu_2[1000];
  float hcalSum_2[1000];
  float ecalSum_2[1000];
  int subid_2[1000];
  
  // event tree
  int evt_1;
  int run_1;
  int lumi_1;
  float pthat_1;
  float vx_1;
  float vy_1;
  float vz_1;
  int hiNpix_1;
  int hiNtracks_1;
  float hiHF_1;
  float hiHFminus_1;
  float hiHFplus_1;
  float hiHFplusEta4_1;
  float hiHFminusEta4_1;
  int pPAcollisionEventSelectionPA_1;
  int pHBHENoiseFilter_1;
  int pprimaryvertexFilter_1;
  int pVertexFilterCutGplus_1;

  // trigger tree
  int jet40_1;
  int jet60_1;
  int jet80_1;
  int jet40_p_1;
  int jet60_p_1;
  int jet80_p_1;

  for(int k = 0;k<no_radius;k++){
    //set the branch addresses:  - one of the most boring parts of the code: 
    jetpp1[2][k]->SetBranchAddress("evt",&evt_1);
    jetpp1[2][k]->SetBranchAddress("run",&run_1);
    jetpp1[2][k]->SetBranchAddress("lumi",&lumi_1);
    if(dataset=="MC") jetpp1[2][k]->SetBranchAddress("pthat",&pthat_1);
    jetpp1[2][k]->SetBranchAddress("vz",&vz_1);
    jetpp1[2][k]->SetBranchAddress("vx",&vx_1);
    jetpp1[2][k]->SetBranchAddress("vy",&vy_1);
    jetpp1[2][k]->SetBranchAddress("hiNpix",&hiNpix_1);
    jetpp1[2][k]->SetBranchAddress("hiNtracks",&hiNtracks_1);
    jetpp1[2][k]->SetBranchAddress("hiHFminus",&hiHFminus_1);
    jetpp1[2][k]->SetBranchAddress("hiHF",&hiHF_1);
    jetpp1[2][k]->SetBranchAddress("hiHFplus",&hiHFplus_1);
    jetpp1[2][k]->SetBranchAddress("hiHFplusEta4",&hiHFplusEta4_1);
    jetpp1[2][k]->SetBranchAddress("hiHFminusEta4",&hiHFminusEta4_1);
    jetpp1[2][k]->SetBranchAddress("pPAcollisionEventSelectionPA",&pPAcollisionEventSelectionPA_1);
    jetpp1[2][k]->SetBranchAddress("pHBHENoiseFilter",&pHBHENoiseFilter_1);
    //jetpp1[2][k]->SetBranchAddress("pprimaryvertexFilter",&pprimaryvertexFilter_1);
    //jetpp1[2][k]->SetBranchAddress("pVertexFilterCutGplus",&pVertexFilterCutGplus_1);
  
    jetpp1[2][k]->SetBranchAddress("nref",&nrefe_1);
    jetpp1[2][k]->SetBranchAddress("jtpt",&pt_1);
    jetpp1[2][k]->SetBranchAddress("jteta",&eta_1);
    jetpp1[2][k]->SetBranchAddress("jtphi",&phi_1);
    jetpp1[2][k]->SetBranchAddress("rawpt",&raw_1);
    jetpp1[2][k]->SetBranchAddress("jtpu",&jtpu_1);
    jetpp1[2][k]->SetBranchAddress("chargedMax",&chMax_1);
    jetpp1[2][k]->SetBranchAddress("chargedSum",&chSum_1);
    jetpp1[2][k]->SetBranchAddress("trackMax",&trkMax_1);
    jetpp1[2][k]->SetBranchAddress("trackSum",&trkSum_1);
    jetpp1[2][k]->SetBranchAddress("photonMax",&phMax_1);
    jetpp1[2][k]->SetBranchAddress("photonSum",&phSum_1);
    jetpp1[2][k]->SetBranchAddress("neutralMax",&neMax_1);
    jetpp1[2][k]->SetBranchAddress("neutralSum",&neSum_1);
    jetpp1[2][k]->SetBranchAddress("eSum",&eSum_1);
    jetpp1[2][k]->SetBranchAddress("eMax",&eMax_1);
    jetpp1[2][k]->SetBranchAddress("muSum",&muSum_1);
    jetpp1[2][k]->SetBranchAddress("muMax",&muMax_1);
    jetpp1[2][k]->SetBranchAddress("ecalSum",&ecalSum_1);
    jetpp1[2][k]->SetBranchAddress("hcalSum",&hcalSum_1);
    
    jetpp1[3][k]->SetBranchAddress("nref",&nrefe_2);
    jetpp1[3][k]->SetBranchAddress("jtpt",&pt_2);
    jetpp1[3][k]->SetBranchAddress("jteta",&eta_2);
    jetpp1[3][k]->SetBranchAddress("jtphi",&phi_2);
    jetpp1[3][k]->SetBranchAddress("rawpt",&raw_2);
    jetpp1[3][k]->SetBranchAddress("jtpu",&jtpu_2);
    jetpp1[3][k]->SetBranchAddress("chargedMax",&chMax_2);
    jetpp1[3][k]->SetBranchAddress("chargedSum",&chSum_2);
    jetpp1[3][k]->SetBranchAddress("trackMax",&trkMax_2);
    jetpp1[3][k]->SetBranchAddress("trackSum",&trkSum_2);
    jetpp1[3][k]->SetBranchAddress("photonMax",&phMax_2);
    jetpp1[3][k]->SetBranchAddress("photonSum",&phSum_2);
    jetpp1[3][k]->SetBranchAddress("neutralMax",&neMax_2);
    jetpp1[3][k]->SetBranchAddress("neutralSum",&neSum_2);
    jetpp1[3][k]->SetBranchAddress("eSum",&eSum_2);
    jetpp1[3][k]->SetBranchAddress("eMax",&eMax_2);
    jetpp1[3][k]->SetBranchAddress("muSum",&muSum_2);
    jetpp1[3][k]->SetBranchAddress("muMax",&muMax_2);
    jetpp1[3][k]->SetBranchAddress("ecalSum",&ecalSum_2);
    jetpp1[3][k]->SetBranchAddress("hcalSum",&hcalSum_2);
    
    if(dataset=="MC"){

      jetpp1[2][k]->SetBranchAddress("subid",&subid_1);
      jetpp1[3][k]->SetBranchAddress("subid",&subid_2);
      jetpp1[2][k]->SetBranchAddress("refpt",&refpt_1);
      jetpp1[3][k]->SetBranchAddress("refpt",&refpt_2);

    }
    

    jetpp1[2][k]->SetBranchAddress("HLT_PAJet40_NoJetID_v1",&jet40_1);
    jetpp1[2][k]->SetBranchAddress("HLT_PAJet40_NoJetID_v1_Prescl",&jet40_p_1);
    jetpp1[2][k]->SetBranchAddress("HLT_PAJet60_NoJetID_v1",&jet60_1);
    jetpp1[2][k]->SetBranchAddress("HLT_PAJet60_NoJetID_v1_Prescl",&jet60_p_1);
    jetpp1[2][k]->SetBranchAddress("HLT_PAJet80_NoJetID_v1",&jet80_1);
    jetpp1[2][k]->SetBranchAddress("HLT_PAJet80_NoJetID_v1_Prescl",&jet80_p_1);

    // jetpp1[2][k]->SetBranchAddress("id",&trgObj_id_1);
    // jetpp1[2][k]->SetBranchAddress("pt",&trgObj_pt_1);
    // jetpp1[2][k]->SetBranchAddress("eta",&trgObj_eta_1);
    // jetpp1[2][k]->SetBranchAddress("phi",&trgObj_phi_1);
    // jetpp1[2][k]->SetBranchAddress("mass",&trgObj_mass_1);
    
    /*
    jetpp1[2][k]->SetBranchAddress("nPFpart", &nPFpart);
    jetpp1[2][k]->SetBranchAddress("pfId", pfId);
    jetpp1[2][k]->SetBranchAddress("pfPt", pfPt);
    jetpp1[2][k]->SetBranchAddress("pfVsPtInitial", pfVsPtInitial);
    jetpp1[2][k]->SetBranchAddress("pfVsPt", pfVsPt);
    jetpp1[2][k]->SetBranchAddress("pfEta", pfEta);
    jetpp1[2][k]->SetBranchAddress("pfPhi", pfPhi);
    jetpp1[2][k]->SetBranchAddress("pfArea", pfArea);
    jetpp1[2][k]->SetBranchAddress("vn",&v_n);
    jetpp1[2][k]->SetBranchAddress("psin",&psi_n);
    jetpp1[2][k]->SetBranchAddress("sumpt",&sumpT);
    */

  }// radius loop
  cout<<"after branch declaration"<<endl;

  cout<<"after histogram declaration"<<endl;

  Float_t calopt, pfpt, deltar, chMax, phMax, neMax, muMax, eMax, chSum, phSum, neSum, muSum, eSum, hcalSum, ecalSum;
  Int_t  jet80, jet80_prescl, jet60, jet60_prescl, jet40, jet40_prescl; 
  Int_t evt_value;
  Int_t run_value;
  Int_t lumi_value;
  Float_t weight;
  Float_t subid, pfrawpt, calorawpt, pfrefpt, calorefpt, pfjtpu, calojtpu, vz, pthat, caloeta, calophi, pfeta, pfphi;
  
  TTree* matchJets = new TTree("matchedJets","Ntuple containing important information about matched jets");
  matchJets->Branch("calopt",&calopt,"calopt/F");   matchJets->Branch("phSum",&phSum,"phSum/F");
  matchJets->Branch("pfpt",&pfpt,"pfpt/F");         matchJets->Branch("neSum",&neSum,"neSum/F");
  matchJets->Branch("deltar",&deltar,"deltar/F");   matchJets->Branch("muSum",&muSum,"muSum/F");
  matchJets->Branch("chMax",&chMax,"chMax/F");      matchJets->Branch("eSum",&eSum,"eSum/F");
  matchJets->Branch("phMax",&phMax,"phMax/F"); 
  matchJets->Branch("neMax",&neMax,"neMax/F");      matchJets->Branch("jet80",&jet80,"jet80/I");
  matchJets->Branch("muMax",&muMax,"muMax/F");      matchJets->Branch("jet80_prescl",&jet80_prescl,"jet80_prescl/I");
  matchJets->Branch("eMax",&eMax,"eMax/F");         matchJets->Branch("jet60",&jet60,"jet60/I");
  matchJets->Branch("chSum",&chSum,"chSum/F");      matchJets->Branch("jet60_prescl",&jet60_prescl,"jet60_prescl/I");
  matchJets->Branch("jet40",&jet40,"jet40/I");      matchJets->Branch("jet40_prescl",&jet40_prescl,"jet40_prescl/I");
  matchJets->Branch("hcalSum",&hcalSum,"hcalSum/F");matchJets->Branch("ecalSum",&ecalSum,"ecalSum/F");
  matchJets->Branch("run_value",&run_value,"run_value/I");
  matchJets->Branch("evt_value",&evt_value,"evt_value/I");
  matchJets->Branch("lumi_value",&lumi_value,"lumi_value/I");
  matchJets->Branch("caloeta", &caloeta, "caloeta/F");
  matchJets->Branch("calophi", &calophi, "calophi/F");
  matchJets->Branch("pfeta", &pfeta, "pfeta/F");
  matchJets->Branch("pfphi", &pfphi, "pfphi/F");
  if(dataset=="MC") matchJets->Branch("subid",&subid,"subid/I"); matchJets->Branch("pfrawpt",&pfrawpt,"pfrawpt/F");
  if(dataset=="MC") matchJets->Branch("pfrefpt",&pfrefpt,"pfrefpt/F"); matchJets->Branch("pfjtpu",&pfjtpu,"pfjtpu/F");
  if(dataset=="MC") matchJets->Branch("calorefpt",&calorefpt,"calorefpt/F");
  if(dataset=="MC") matchJets->Branch("pthat",&pthat,"pthat/F"); if(dataset=="MC") matchJets->Branch("vz",&vz,"vz/F");
  if(dataset=="MC") matchJets->Branch("weight",&weight,"weight/F");
  matchJets->Branch("calorawpt",&calorawpt,"calorawpt/F");
  matchJets->Branch("calojtpu",&calojtpu,"calojtpu/F");
  
  TTree* unmatchPFJets = new TTree("unmatchedPFJets","Ntuple containing important information about unmatched PF jets");
  unmatchPFJets->Branch("phSum",&phSum,"phSum/F");
  unmatchPFJets->Branch("pfpt",&pfpt,"pfpt/F");         unmatchPFJets->Branch("neSum",&neSum,"neSum/F");
  unmatchPFJets->Branch("deltar",&deltar,"deltar/F");   unmatchPFJets->Branch("muSum",&muSum,"muSum/F");
  unmatchPFJets->Branch("chMax",&chMax,"chMax/F");      unmatchPFJets->Branch("eSum",&eSum,"eSum/F");
  unmatchPFJets->Branch("phMax",&phMax,"phMax/F");
  unmatchPFJets->Branch("neMax",&neMax,"neMax/F");      unmatchPFJets->Branch("jet80",&jet80,"jet80/I");
  unmatchPFJets->Branch("muMax",&muMax,"muMax/F");      unmatchPFJets->Branch("jet80_prescl",&jet80_prescl,"jet80_prescl/I");
  unmatchPFJets->Branch("eMax",&eMax,"eMax/F");         unmatchPFJets->Branch("jet60",&jet60,"jet60/I");
  unmatchPFJets->Branch("chSum",&chSum,"chSum/F");      unmatchPFJets->Branch("jet60_prescl",&jet60_prescl,"jet60_prescl/I");
  unmatchPFJets->Branch("jet40",&jet40,"jet40/I");      unmatchPFJets->Branch("jet40_prescl",&jet40_prescl,"jet40_prescl/I");
  unmatchPFJets->Branch("hcalSum",&hcalSum,"hcalSum/F");unmatchPFJets->Branch("ecalSum",&ecalSum,"ecalSum/F");
  unmatchPFJets->Branch("run_value",&run_value,"run_value/I");
  unmatchPFJets->Branch("evt_value",&evt_value,"evt_value/I");
  unmatchPFJets->Branch("lumi_value",&lumi_value,"lumi_value/I");
  unmatchPFJets->Branch("pfeta", &pfeta, "pfeta/F");
  unmatchPFJets->Branch("pfphi", &pfphi, "pfphi/F");
  if(dataset=="MC") unmatchPFJets->Branch("subid",&subid,"subid/I"); unmatchPFJets->Branch("pfrawpt",&pfrawpt,"pfrawpt/F");
  if(dataset=="MC") unmatchPFJets->Branch("pfrefpt",&pfrefpt,"pfrefpt/F"); unmatchPFJets->Branch("pfjtpu",&pfjtpu,"pfjtpu/F");
  if(dataset=="MC") unmatchPFJets->Branch("weight",&weight,"weight/F");
  if(dataset=="MC") unmatchPFJets->Branch("pthat",&pthat,"pthat/F"); if(dataset=="MC") unmatchPFJets->Branch("vz",&vz,"vz/F");
  
  TTree* unmatchCaloJets = new TTree("unmatchedCaloJets","Ntuple containing important information about unmatched Calo jets");
  unmatchCaloJets->Branch("phSum",&phSum,"phSum/F");
  unmatchCaloJets->Branch("calopt",&calopt,"calopt/F");   unmatchCaloJets->Branch("neSum",&neSum,"neSum/F");
  unmatchCaloJets->Branch("deltar",&deltar,"deltar/F");   unmatchCaloJets->Branch("muSum",&muSum,"muSum/F");
  unmatchCaloJets->Branch("chMax",&chMax,"chMax/F");      unmatchCaloJets->Branch("eSum",&eSum,"eSum/F");
  unmatchCaloJets->Branch("phMax",&phMax,"phMax/F");     
  unmatchCaloJets->Branch("neMax",&neMax,"neMax/F");      unmatchCaloJets->Branch("jet80",&jet80,"jet80/I");
  unmatchCaloJets->Branch("muMax",&muMax,"muMax/F");      unmatchCaloJets->Branch("jet80_prescl",&jet80_prescl,"jet80_prescl/I");
  unmatchCaloJets->Branch("eMax",&eMax,"eMax/F");         unmatchCaloJets->Branch("jet60",&jet60,"jet60/I");
  unmatchCaloJets->Branch("chSum",&chSum,"chSum/F");      unmatchCaloJets->Branch("jet60_prescl",&jet60_prescl,"jet60_prescl/I");
  unmatchCaloJets->Branch("jet40",&jet40,"jet40/I");      unmatchCaloJets->Branch("jet40_prescl",&jet40_prescl,"jet40_prescl/I");
  unmatchCaloJets->Branch("hcalSum",&hcalSum,"hcalSum/F");unmatchCaloJets->Branch("ecalSum",&ecalSum,"ecalSum/F");
  unmatchCaloJets->Branch("run_value",&run_value,"run_value/I");
  unmatchCaloJets->Branch("evt_value",&evt_value,"evt_value/I");
  unmatchCaloJets->Branch("lumi_value",&lumi_value,"lumi_value/I");
  unmatchCaloJets->Branch("caloeta", &caloeta, "caloeta/F");
  unmatchCaloJets->Branch("calophi", &calophi, "calophi/F");
  if(dataset=="MC") unmatchCaloJets->Branch("subid",&subid,"subid/I"); 
  if(dataset=="MC") unmatchCaloJets->Branch("calorefpt",&calorefpt,"calorefpt/F");
  if(dataset=="MC") unmatchCaloJets->Branch("pthat",&pthat,"pthat/F"); if(dataset=="MC") unmatchCaloJets->Branch("vz",&vz,"vz/F");
  if(dataset=="MC") unmatchCaloJets->Branch("weight",&weight,"weight/F");
  unmatchCaloJets->Branch("calorawpt",&calorawpt,"calorawpt/F");
  unmatchCaloJets->Branch("calojtpu",&calojtpu,"calojtpu/F");


  TH1F * hEvents = new TH1F("hEvents","",20,0,10);

  // define the histograms 

  // define the histograms necessary for that MC closure test.
  TH2F *hpp_mcclosure_matrix_HLT;
  TH2F *hpp_mcclosure_matrix;
  //TH2F *hpp_response;
  TH1F *hpp_mcclosure_JetComb_data;
  TH1F *hpp_mcclosure_data;
  TH1F *hpp_mcclosure_Jet80_data;
  TH1F *hpp_mcclosure_Jet60_data;
  TH1F *hpp_mcclosure_Jet40_data;
  TH1F *hpp_mcclosure_gen;
  TH1F *hpp_mcclosure_JetComb_gen;
  TH1F *hpp_mcclosure_Jet80_gen;
  TH1F *hpp_mcclosure_Jet60_gen;
  TH1F *hpp_mcclosure_Jet40_gen;
  
  hpp_mcclosure_matrix_HLT = new TH2F(Form("hpp_mcclosure_matrix_HLT_R%d_%s",radius,etaWidth),Form("Matrix for mcclosure refpt jtpt from Jet triggers R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt,nbins_pt,boundaries_pt);
  hpp_mcclosure_matrix = new TH2F(Form("hpp_mcclosure_matrix_R%d_%s",radius,etaWidth),Form("Matrix for mcclosure refpt jtpt from Jet triggers R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt,nbins_pt,boundaries_pt);
  //cout<<"C"<<endl;
  hpp_mcclosure_data = new TH1F(Form("hpp_mcclosure_data_R%d_%s",radius,etaWidth),Form("data for unfolding mc closure test R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_JetComb_data = new TH1F(Form("hpp_mcclosure_JetComb_data_R%d_%s",radius,etaWidth),Form("data for unfolding mc closure test trigger combined  R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_Jet80_data = new TH1F(Form("hpp_mcclosure_Jet80_data_R%d_%s",radius,etaWidth),Form("data for unfolding mc closure test trigger 80  R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_Jet60_data = new TH1F(Form("hpp_mcclosure_Jet60_data_R%d_%s",radius,etaWidth),Form("data for unfolding mc closure test trigger 60  R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_Jet40_data = new TH1F(Form("hpp_mcclosure_Jet40_data_R%d_%s",radius,etaWidth),Form("data for unfolding mc closure test trigger 40  R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);

  hpp_mcclosure_gen = new TH1F(Form("hpp_mcclosure_gen_R%d_%s",radius,etaWidth),Form("gen spectra for unfolding mc closure test R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_JetComb_gen = new TH1F(Form("hpp_mcclosure_gen_JetComb_R%d_%s",radius,etaWidth),Form("gen spectra for unfolding mc closure test trigger combined R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_Jet80_gen = new TH1F(Form("hpp_mcclosure_gen_Jet80_R%d_%s",radius,etaWidth),Form("gen spectra for unfolding mc closure test trigger 80 R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_Jet60_gen = new TH1F(Form("hpp_mcclosure_gen_Jet60_R%d_%s",radius,etaWidth),Form("gen spectra for unfolding mc closure test trigger 60 R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);
  hpp_mcclosure_Jet40_gen = new TH1F(Form("hpp_mcclosure_gen_Jet40_R%d_%s",radius,etaWidth),Form("gen spectra for unfolding mc closure test trigger 40 R%d %s ",radius,etaWidth),nbins_pt,boundaries_pt);

  
  // declare the 2d calo and pf candidate vectors, deltaR_calovsPF is going to be a 3d vector like so:
  // calo jet on x axis, pf jet on y axis, and delta R, calopT, pfpT on z axis.
  // we also need to add in the trigger information here since we need to know what trigger the matching comes from. maybe i can run that later as an added check. for now just to see if the algorithm is working should try to run things. 
  //vector<vector<double> > caloJet;
  //vector<vector<double> > pfJet;

  // start the loop process

  for(int k = 0;k<no_radius;k++){

    Long64_t nentries = jetpp1[2][k]->GetEntries();
    //Long64_t nentries = 100;

    Long64_t fentries= 1;
    if(dataset=="MC"){
      TEventList *el = new TEventList("el","el");
      double pthat_upper = boundaries_pthat[startfile + 1];
      stringstream selection; selection<<"pthat<"<<pthat_upper;
      
      jetpp1[2][k]->Draw(">>el",selection.str().c_str());
      fentries = el->GetN();
      delete el;
    }
    
    for(Long64_t nentry = 0; nentry<nentries;nentry++){
      if(printDebug)cout<<"event no = "<<nentry<<endl;
      for(int t = 0;t<N;t++)  jetpp1[t][k]->GetEntry(nentry);
      
      hEvents->Fill(0);

      //int centBin = findBin(hiBin_1);
      //if(centBin==-1) continue;
      //if(pHBHENoiseFilter_1==0 || pcollisionEventSelection_1==0) continue; 
      if(pPAcollisionEventSelectionPA_1==0) continue; 
      hEvents->Fill(1);
      if(dataset=="Data") if(pHBHENoiseFilter_1==0 ) continue;
      hEvents->Fill(2);

      if(fabs(vz_1)>15) continue;
      //cout<<"passed the selection"<<endl;

      hEvents->Fill(3);

      weight = 1;

      if(dataset=="MC"){
	
	int pthatBin = hpthatBin->FindBin(pthat_1);
	
	double scale = (double)(xsection[pthatBin-1]-xsection[pthatBin])/fentries;

	Float_t weight_vz = fVzPP->Eval(vz_1);
	weight = scale*weight_vz;

      }

      // start doing the search for the match. - best thing to do would be to create a 2D match delta R matrix with each calo jet and pf jet. Once thats done - find the smallest entry in that matrix. the i,j of that smallest entry are matched. now remove the row i and column j and then we have a new distance matrix. where we need to find the smallest element again. keep doing this till we have either no rows or no columns.  

      // declare the necessary variables:
      Float_t deltaRCaloPF = 0;
      Float_t calojet_eta = 0;
      Float_t calojet_phi = 0;
      Float_t calojet_pt = 0;
      Float_t pfjet_eta = 0;
      Float_t pfjet_phi = 0;
      Float_t pfjet_pt = 0;
      
      vector<vector<double> > matchedCaloPFJet;
      vector<vector<vector<double> > > deltaR_calovsPF;
      int calosize = 0;
      Float_t deltapT = 0;
      int calomatchcounter = 0;
      
      for(int g = 0;g<nrefe_1;g++){
	
	calojet_eta = eta_1[g];
	calojet_phi = phi_1[g];
	calojet_pt = pt_1[g];
	
	if(calojet_pt < CALOPTCUT) continue;
	if(TMath::Abs(calojet_eta) > 2.0) continue;
	
	int pfmatchcounter = 0;
	deltaR_calovsPF.push_back(vector<vector<double> > ());
	
	calosize++;
	
	for(int j = 0;j<nrefe_2;j++){

	  pfjet_eta = eta_2[j];
	  pfjet_phi = phi_2[j];
	  pfjet_pt = pt_2[j];

	  if(pfjet_pt < PFPTCUT) continue;
	  if(TMath::Abs(pfjet_eta) > 2.0) continue;

	  deltaRCaloPF = Calc_deltaR(calojet_eta, calojet_phi, pfjet_eta, pfjet_phi);
	  
	  // if(deltaRCaloPF > (Float_t)deltaR/10) continue;
	  deltapT = TMath::Abs(calojet_pt - pfjet_pt);

	  deltaR_calovsPF[calomatchcounter].push_back(vector<double> ());
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(deltaRCaloPF); // 0 - delta R
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(deltapT); // 1 - delta pT	  
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(g); // 2 - calo counter 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(calojet_pt); // 3 - calo jet pT 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(j); // 4 - pf counter 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(pfjet_pt); // 5 - pf jet pT
	  // this will have the candidate variables for the matched jets. 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(chMax_2[j]); // 6 - chMax 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(phMax_2[j]); // 7 - phMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(neMax_2[j]); // 8 - neMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(muMax_2[j]); // 9 - muMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(eMax_2[j]); // 10 - eMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(chSum_2[j]); // 11 - chSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(phSum_2[j]); // 12 - phSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(neSum_2[j]); // 13 - neSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(muSum_2[j]); // 14 - muSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(eSum_2[j]); // 15 - eSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(0.0); // 16 - this is the variable which will tell me if a jet is matched.
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(hcalSum_2[j]); // 17 - hcalSum 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(ecalSum_2[j]); // 18 - hcalSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(raw_2[j]); // 19 - raw pt
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(jtpu_2[j]); // 20 - jtpu
	  //all the following candidate information is for the calo jets 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(chMax_1[g]); // 21 - chMax 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(phMax_1[g]); // 22 - phMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(neMax_1[g]); // 23 - neMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(muMax_1[g]); // 24 - muMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(eMax_1[g]); // 25 - eMax
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(chSum_1[g]); // 26 - chSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(phSum_1[g]); // 27 - phSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(neSum_1[g]); // 28 - neSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(muSum_1[g]); // 29 - muSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(eSum_1[g]); // 30 - eSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(hcalSum_1[g]); // 31 - hcalSum 
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(ecalSum_1[g]); // 32 - hcalSum
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(raw_1[g]); // 33 - raw pt
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(jtpu_1[g]); // 34 - jtpu

	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(pfjet_eta); // 35 - pf eta
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(pfjet_phi); // 36 - pf phi
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(calojet_eta); // 37 - calo eta
	  deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(calojet_phi); // 38 - calo phi
	  
	  if(dataset=="MC") {
	    deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(refpt_1[g]); // 39 calo ref pt 
	    deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(refpt_2[j]); // 40 pf ref pt 
	    deltaR_calovsPF[calomatchcounter][pfmatchcounter].push_back(subid_2[j]); // 41 - subid only for MC
	    
	  }
	  
	  
	  ++pfmatchcounter;

	}// pf jet loop
	++calomatchcounter;
	
      }// calo jet loop

      // set the event variables before proceeding to the matching. 
      jet80 = jet80_1;
      jet80_prescl = jet80_p_1;
      jet60 = jet60_1;
      jet60_prescl = jet60_p_1;
      jet40 = jet40_1;
      jet40_prescl = jet40_p_1;
      run_value = run_1;
      evt_value = evt_1;
      lumi_value = lumi_1;
      vz = vz_1;
      if(dataset=="MC")pthat = pthat_1;

      if(printDebug)cout<<deltaR_calovsPF.size()<<endl;
      if(printDebug)for(int a = 0;a<deltaR_calovsPF.size();++a) cout<<deltaR_calovsPF[a].size()<<" ";
      if(printDebug)cout<<endl<<"going to small matching"<<endl;
      
      // now that we have the 2D matrix, lets find the smallest delta R element from that and fill in the value of the 

      Float_t smallDeltaR = 10;
      Int_t small_calo = 0;
      Int_t small_pf = 0;

      for(int c = 0;c<deltaR_calovsPF.size();++c){
	// if(printDebug)cout<<"going through all rows in the  matrix "<<c<<endl;
	for(int a = 0;a<deltaR_calovsPF.size();++a){
	  // if(printDebug)cout<<"calo jet iteration "<<a<<endl;
	  for(int b = 0;b<deltaR_calovsPF[a].size();++b){
	    // if(printDebug)cout<<"pf jet iteration "<<b<<endl;
	    
	    if(deltaR_calovsPF[a][b][16]==1){ 
	      break;
	    }
	    if(smallDeltaR > deltaR_calovsPF[a][b][0]){
	      
	      smallDeltaR = deltaR_calovsPF[a][b][0];
	      small_calo = a;
	      small_pf = b;
	      
	    }
	  }
	}
	
	if(smallDeltaR > (Float_t)deltaR/10 || deltaR_calovsPF[small_calo][small_pf][16] == 1) continue;
	
	calopt = deltaR_calovsPF[small_calo][small_pf][3];
	pfpt = deltaR_calovsPF[small_calo][small_pf][5];
	if(dataset=="MC"){
	  pfrefpt = deltaR_calovsPF[small_calo][small_pf][40];
	  calorefpt = deltaR_calovsPF[small_calo][small_pf][39];
	  subid = deltaR_calovsPF[small_calo][small_pf][41]; 
	}
	pfrawpt = deltaR_calovsPF[small_calo][small_pf][19]; 
	calorawpt = deltaR_calovsPF[small_calo][small_pf][33]; 
	pfjtpu = deltaR_calovsPF[small_calo][small_pf][20]; 
	calojtpu = deltaR_calovsPF[small_calo][small_pf][34];
	deltar = deltaR_calovsPF[small_calo][small_pf][0];
	chMax = deltaR_calovsPF[small_calo][small_pf][6];
	phMax = deltaR_calovsPF[small_calo][small_pf][7];
	neMax = deltaR_calovsPF[small_calo][small_pf][8];
	muMax = deltaR_calovsPF[small_calo][small_pf][9];
	eMax = deltaR_calovsPF[small_calo][small_pf][10];
	chSum = deltaR_calovsPF[small_calo][small_pf][11];
	phSum = deltaR_calovsPF[small_calo][small_pf][12];
	neSum = deltaR_calovsPF[small_calo][small_pf][13];
	muSum = deltaR_calovsPF[small_calo][small_pf][14];
	eSum = deltaR_calovsPF[small_calo][small_pf][15];
	pfeta = deltaR_calovsPF[small_calo][small_pf][35];
	pfphi = deltaR_calovsPF[small_calo][small_pf][36];
	caloeta = deltaR_calovsPF[small_calo][small_pf][37];
	calophi = deltaR_calovsPF[small_calo][small_pf][38];
	hcalSum = deltaR_calovsPF[small_calo][small_pf][17];
	ecalSum = deltaR_calovsPF[small_calo][small_pf][18];
	
	//matchJets->Fill();
	
	if(c==0) hEvents->Fill(4);
	  
	if(dataset=="MC"){
	  // fill in the matched histograms with the Jet ID cuts:
	  if(subid!=0) continue;
	
	  Float_t Sumcand = chSum + phSum + neSum + muSum;

	  //if(calopt/pfpt > 0.5 && calopt/pfpt <= 0.85 && eMax/Sumcand < ((Float_t)18/7 *(Float_t)calopt/pfpt - (Float_t)9/7)){
	    if(nentry%2==1) {
	      hpp_mcclosure_matrix->Fill(pfrefpt, pfpt, weight);
	      hpp_mcclosure_gen->Fill(pfrefpt, weight);
	    }
	    if(nentry%2==1) {
	      hpp_mcclosure_data->Fill(pfpt, weight);
	    }
	    //}
	  
	  if(jet40 == 1 && jet60==0 && jet80 == 0){

	    //if(calopt/pfpt > 0.5 && calopt/pfpt <= 0.85 && eMax/Sumcand < ((Float_t)18/7 *(Float_t)calopt/pfpt - (Float_t)9/7)){
	      if(nentry%2==1) {
		hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
		hpp_mcclosure_Jet40_gen->Fill(pfrefpt, weight);
	      }
	      if(nentry%2==1) {
		hpp_mcclosure_Jet40_data->Fill(pfpt, weight);
	      }
	      //}

	    // if(calopt/pfpt > 0.85) {
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
	    // 	hpp_mcclosure_Jet40_gen->Fill(pfrefpt, weight);
	    //   }
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_Jet40_data->Fill(pfpt, weight);
	    //   }
	    // }

	    // if(calopt/pfpt <= 0.5 && eMax/Sumcand < 0.05) {
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
	    // 	hpp_mcclosure_Jet40_gen->Fill(pfrefpt, weight);
	    //   }
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_Jet40_data->Fill(pfpt, weight);
	    //   }
	    // }
	  
	  }

	  if(jet60 == 1 && jet80 == 0){

	    //if(calopt/pfpt > 0.5 && calopt/pfpt <= 0.85 && eMax/Sumcand < ((Float_t)18/7 *(Float_t)calopt/pfpt - (Float_t)9/7)){
	      if(nentry%2==1) {
		hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
		hpp_mcclosure_Jet60_gen->Fill(pfrefpt, weight);
	      }
	      if(nentry%2==1) {
		hpp_mcclosure_Jet60_data->Fill(pfpt, weight);
	      }
	      //}

	    // if(calopt/pfpt > 0.85) {
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
	    // 	hpp_mcclosure_Jet60_gen->Fill(pfrefpt, weight);
	    //   }
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_Jet60_data->Fill(pfpt, weight);
	    //   }
	    // }

	    // if(calopt/pfpt <= 0.5 && eMax/Sumcand < 0.05) {
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
	    // 	hpp_mcclosure_Jet60_gen->Fill(pfrefpt, weight);
	    //   }
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_Jet60_data->Fill(pfpt, weight);
	    //   }
	    // }
	  
	  
	  }

	  if(jet80==1){

	    //if(calopt/pfpt > 0.5 && calopt/pfpt <= 0.85 && eMax/Sumcand < ((Float_t)18/7 *(Float_t)calopt/pfpt - (Float_t)9/7)){
	      if(nentry%2==1) {
		hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
		hpp_mcclosure_Jet80_gen->Fill(pfrefpt, weight);
	      }
	      if(nentry%2==1) {
		hpp_mcclosure_Jet80_data->Fill(pfpt, weight);
	      }
	      //}

	    // if(calopt/pfpt > 0.85) {
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
	    // 	hpp_mcclosure_Jet80_gen->Fill(pfrefpt, weight);
	    //   }
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_Jet80_data->Fill(pfpt, weight);
	    //   }
	    // }

	    // if(calopt/pfpt <= 0.5 && eMax/Sumcand < 0.05) {
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
	    // 	hpp_mcclosure_Jet80_gen->Fill(pfrefpt, weight);
	    //   }
	    //   if(nentry%2==1) {
	    // 	hpp_mcclosure_Jet80_data->Fill(pfpt, weight);
	    //   }
	    // }
	  
	  
	  }

	}


	smallDeltaR = 10;
	for(int b = 0;b<deltaR_calovsPF[small_calo].size();++b){
	  deltaR_calovsPF[small_calo][b][16] = 1; // by setting this value you effectively remove that calo and pf jet for further matching // removes the column for getting matched. 
	}
	for(int a = 0;a<deltaR_calovsPF.size();++a){
	  deltaR_calovsPF[a][small_pf][16] = 1; // this removes the whole row from getting matched later. 
	}

      }// running it for the number of calo jets: 

      if(printDebug)cout<<"now going to find unmatched pf jets"<<endl;
      // ok Now lets find the un-matched jets and fill the necessary unmatched ntuple:

      if(deltaR_calovsPF.size() == 0) continue;
      for(int b = 0;b<deltaR_calovsPF[0].size();++b){
	if(printDebug)cout<<"pf jet iteration "<<b<<endl;

	if(deltaR_calovsPF[0][b][16] == 1) continue;

	pfpt = deltaR_calovsPF[0][b][5];
	deltar = deltaR_calovsPF[0][b][0];
	if(dataset=="MC"){
	  pfrefpt = deltaR_calovsPF[0][b][40];
	  subid = deltaR_calovsPF[0][b][41]; 
	}
	pfrawpt = deltaR_calovsPF[0][b][19]; 
	pfjtpu = deltaR_calovsPF[0][b][20]; 
	chMax = deltaR_calovsPF[0][b][6];
	phMax = deltaR_calovsPF[0][b][7];
	neMax = deltaR_calovsPF[0][b][8];
	muMax = deltaR_calovsPF[0][b][9];
	eMax = deltaR_calovsPF[0][b][10];
	chSum = deltaR_calovsPF[0][b][11];
	phSum = deltaR_calovsPF[0][b][12];
	neSum = deltaR_calovsPF[0][b][13];
	muSum = deltaR_calovsPF[0][b][14];
	eSum = deltaR_calovsPF[0][b][15];
	pfeta = deltaR_calovsPF[0][b][35];
	pfphi = deltaR_calovsPF[0][b][36];
	hcalSum = deltaR_calovsPF[0][b][17];
	ecalSum = deltaR_calovsPF[0][b][18];
	
	//unmatchPFJets->Fill();

	if(b==0) hEvents->Fill(5);

	if(dataset=="MC"){
	  // fill in the matched histograms with the Jet ID cuts:
	  if(subid!=0) continue;
	
	  Float_t Sumcand = chSum + phSum + neSum + muSum;

	  //if(eMax/Sumcand < 0.05) {
	    if(nentry%2==1) {
	      hpp_mcclosure_matrix->Fill(pfrefpt, pfpt, weight);
	      hpp_mcclosure_gen->Fill(pfrefpt, weight);
	    }
	    if(nentry%2==1) {
	      hpp_mcclosure_data->Fill(pfpt, weight);
	    }
	    //}
	  
	  
	  if(jet40 == 1 && jet60 == 0 && jet80 == 0){

	    //if(eMax/Sumcand < 0.05) {
	      if(nentry%2==1) {
		hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
		hpp_mcclosure_Jet40_gen->Fill(pfrefpt, weight);
	      }
	      if(nentry%2==1) {
		hpp_mcclosure_Jet40_data->Fill(pfpt, weight);
	      }
	      //}
	  
	  }

	  if(jet60 == 1 && jet80 == 0){

	    //if(eMax/Sumcand < 0.05) {
	      if(nentry%2==1) {
		hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
		hpp_mcclosure_Jet60_gen->Fill(pfrefpt, weight);
	      }
	      if(nentry%2==1) {
		hpp_mcclosure_Jet60_data->Fill(pfpt, weight);
	      }
	      //}
	  
	  
	  }

	  if(jet80==1){

	    //if(eMax/Sumcand < 0.05) {
	      if(nentry%2==1) {
		hpp_mcclosure_matrix_HLT->Fill(pfrefpt, pfpt, weight);
		hpp_mcclosure_Jet80_gen->Fill(pfrefpt, weight);
	      }
	      if(nentry%2==1) {
		hpp_mcclosure_Jet80_data->Fill(pfpt, weight);
	      }
	      //}
	  
	  
	  }
	}

	
      }// unmatched PF jets
      
      if(printDebug)cout<<"now going to find unmatched calo jets"<<endl;

      if(deltaR_calovsPF[0].size() == 0) continue;
      
      for(int a = 0;a<deltaR_calovsPF.size();++a){
	if(printDebug)cout<<"calo jet iteration "<<a<<endl;

	if(deltaR_calovsPF[a][0][16] == 1) continue;

	calopt = deltaR_calovsPF[a][0][3];
	deltar = deltaR_calovsPF[a][0][0];
	if(dataset=="MC"){
	  calorefpt = deltaR_calovsPF[a][0][39];
	  subid = deltaR_calovsPF[a][0][41]; 
	}
	calorawpt = deltaR_calovsPF[a][0][33]; 
	calojtpu = deltaR_calovsPF[a][0][34]; 
	chMax = deltaR_calovsPF[a][0][21];
	phMax = deltaR_calovsPF[a][0][22];
	neMax = deltaR_calovsPF[a][0][23];
	muMax = deltaR_calovsPF[a][0][24];
	eMax = deltaR_calovsPF[a][0][25];
	chSum = deltaR_calovsPF[a][0][26];
	phSum = deltaR_calovsPF[a][0][27];
	neSum = deltaR_calovsPF[a][0][28];
	muSum = deltaR_calovsPF[a][0][29];
	eSum = deltaR_calovsPF[a][0][30];
	caloeta = deltaR_calovsPF[a][0][37];
	calophi = deltaR_calovsPF[a][0][38];
	hcalSum = deltaR_calovsPF[a][0][31];
	ecalSum = deltaR_calovsPF[a][0][32];
	
	//unmatchCaloJets->Fill();

      }

    }// event loop 

  }// radius loop


  // matchJets->Write();
  // matchJets->Print();
  // unmatchPFJets->Write();
  // unmatchPFJets->Print();
  // unmatchCaloJets->Write();
  // unmatchCaloJets->Print();


  hpp_mcclosure_JetComb_data->Add(hpp_mcclosure_Jet80_data);
  hpp_mcclosure_JetComb_data->Add(hpp_mcclosure_Jet60_data);
  hpp_mcclosure_JetComb_data->Add(hpp_mcclosure_Jet40_data);

  hpp_mcclosure_JetComb_gen->Add(hpp_mcclosure_Jet80_gen);
  hpp_mcclosure_JetComb_gen->Add(hpp_mcclosure_Jet60_gen);
  hpp_mcclosure_JetComb_gen->Add(hpp_mcclosure_Jet40_gen);

  hpp_mcclosure_matrix_HLT->Write();
  hpp_mcclosure_matrix->Write();
  hpp_mcclosure_JetComb_data->Write();
  hpp_mcclosure_data->Write();
  hpp_mcclosure_Jet80_data->Write();
  hpp_mcclosure_Jet60_data->Write();
  hpp_mcclosure_Jet40_data->Write();
  hpp_mcclosure_JetComb_gen->Write();    
  hpp_mcclosure_gen->Write();    
  hpp_mcclosure_Jet80_gen->Write();
  hpp_mcclosure_Jet60_gen->Write();
  hpp_mcclosure_Jet40_gen->Write();
    

  hEvents->Write();

  timer.Stop();
  cout<<"Macro finished: "<<endl;
  cout<<"CPU time (min)  = "<<(Float_t)timer.CpuTime()/60<<endl;
  cout<<"Real time (min) = "<<(Float_t)timer.RealTime()/60<<endl;
  
}
//this code create the so-called 'PrintOuts' as done with the MT2tree::PrintOut() function
void PrintOutEvents(){

	bool savetofile = true;//save the printout to the file PrintOut.log, default = true
	bool onlyData = true;  //run only over data, default = true

//	TString  samples = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_MET_filter.dat";//only dummy
//	TString  samples = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_HT_filter.dat";//only dummy
	TString samples = "samples/samples_HTandMET_filter.dat";

	//event selection for which you want to have the printout - complicated stuff can also be done later
	std::ostringstream cutStream;
	std::ostringstream cutStreamBase;
	cutStream << " " 
	//	<< "NBJets40CSVM >= 3"		<< "&&"
		<< "NJetsIDLoose40 >= 2"		<< "&&"
		<< "NEles+NMuons+NTausIDLoose3Hits  ==0"<< "&&"
	//	<< "misc.MT2>=250"                      << "&&"
		<< "misc.Jet0Pass ==1"                      << "&&"
		<< "misc.Jet1Pass ==1"                      << "&&"
		<< "misc.Vectorsumpt < 70";
		cutStream  << "&& misc.MinMetJetDPhi4Pt40 >0.3";
//	cutStream << "&&misc.HT<750&&misc.HT>=450&&misc.MET>200";
//	cutStream << "&&misc.HT>=750&&misc.MET>30";
	cutStream << "&&((misc.HT<750&&misc.HT>=450&&misc.MET>200)||(misc.HT>=750&&misc.MET>30))";

	//Higgs
//	cutStream <<"&&NJetsIDLoose40 >= 4"<<"&&"
  //  		  <<"NBJetsCSVM>=2"<<"&&"
	//	  <<"GetSelBBMinv()>250";
	
	cutStreamBase << " " 
      << "misc.PassJet40ID ==1"                      << "&&"
      << "(misc.HBHENoiseFlag == 0 || misc.ProcessID==10)"  << "&&" // for rare SM samples
      << "misc.CSCTightHaloIDFlag == 0"             << "&&"
      << "misc.trackingFailureFlag==0"              << "&&"
      << "misc.eeBadScFlag==0"                      << "&&"
      << "misc.EcalDeadCellTriggerPrimitiveFlag==0" << "&&"
      << "misc.TrackingManyStripClusFlag==0"             << "&&"
      << "misc.TrackingTooManyStripClusFlag==0"          << "&&"
      << "misc.TrackingLogErrorTooManyClustersFlag==0"   << "&&"
      << "misc.CrazyHCAL==0";
	cutStreamBase << "&&misc.MET/misc.CaloMETRaw<=2.";
	cutStreamBase << "&&TOBTECTagger<=8&&ExtraBeamHaloFilter==0";// ONLY ON DATA
	TString cuts = cutStream.str().c_str();
	TString basecuts = cutStreamBase.str().c_str();

	load(samples.Data());

	//if have extremely many events can only select a random subset of those
	TRandom3 *random = new TRandom3(0);//somehow truly random with this seed
	vector<int> randvec; randvec.clear();
	for(int i =0; i<40;++i)
		randvec.push_back(random->Integer(7750));
	delete random;
	sort(randvec.begin(), randvec.end());
	//for(int i=0; i<randvec.size();++i) cout << "randvec["<<i<<"]="<<randvec[i] << endl;
	int counter1 = 0; int counter2 = 0;

	//don't run events twice - this vector makes that sure (in case event is in both MET and HT trigger stream)
	   vector<pair<int,pair<int,int> > > rls; rls.clear();


   	for(size_t i = 0; i < fSamples.size(); ++i){
        
   	    if(onlyData && fSamples[i].type!="data") continue;

	    MT2tree* fMT2tree = new MT2tree();
	    fSamples[i].tree->SetBranchAddress("MT2tree", &fMT2tree);
	    Long64_t nentries =  fSamples[i].tree->GetEntries();
	    Long64_t nbytes = 0, nb = 0;
	    int nev =0;
        
	    TString myCuts = cuts + "&&" + basecuts;
        
	    //if( fSamples[i].type=="data") myCuts += " && " + trigger; //cuts to be aplied only on data
        
	    cout << "sample " << fSamples[i].name << endl;
   	    cout << "Cuts for Flow: " << myCuts << endl;
   	    fSamples[i].tree->Draw(">>selList", myCuts);
        
	    TEventList *myEvtList = (TEventList*)gDirectory->Get("selList");
	    fSamples[i].tree->SetEventList(myEvtList);
	    int counter=0;
	    cout << "Filtering done, size=" <<myEvtList->GetN()  << endl;
	    if(myEvtList->GetSize()==0) continue;
		//run over selected events
        while(myEvtList->GetEntry(counter++) !=-1){	
		int jentry = myEvtList->GetEntry(counter-1);
            
		nb =  fSamples[i].tree->GetEntry(jentry);   nbytes += nb;
		fSamples[i].tree->SetBranchAddress("MT2tree", &fMT2tree);
		//implementation of running over random subset
//		if(counter1==randvec[counter2]){
//			++counter2;
//			fMT2tree->PrintOut(savetofile);
//		}

		pair <int,int> dummy1(fMT2tree->misc.LumiSection,fMT2tree->misc.Event);
		pair <int,pair<int,int> > dummy(fMT2tree->misc.Run, dummy1);
		bool newevt = true;
		for(int nn = 0; nn<rls.size(); ++nn){
			if(rls[nn].first==dummy.first && rls[nn].second.first==dummy.second.first && rls[nn].second.second==dummy.second.second) {newevt = false; break;}
		}
		if(newevt){
			rls.push_back(dummy);
			fMT2tree->PrintOut(savetofile);//safe the printout
			++counter1;
		}

	}
	delete fMT2tree;
	delete fSamples[i].tree;
	}
	cout << "Printed out " << counter1 << " events." << endl;
}
Exemple #15
0
void FitSignals(TTree * treeB, TCut cut, Int_t max){
  AliSignalProcesor proc;
  TF1 * f1 = proc.GetAsymGauss();
  TTreeSRedirector cstream("FitSignal.root");
  TFile *f = cstream.GetFile();

  char lname[100];
  sprintf(lname,"Fit%s", cut.GetTitle());
  TEventList *list = new TEventList(lname,lname);
  sprintf(lname,">>Fit%s", cut.GetTitle());
  treeB->Draw(lname,cut);
  treeB->SetEventList(list);
  Int_t nFits=0;
  for (Int_t ievent=0; ievent<list->GetN(); ievent++){
    if (nFits>max) break;
    if (nFits%50==0) printf("%d\n",nFits);
    char ename[100];
    sprintf(ename,"Fit%d", ievent);
    Double_t nsample = treeB->Draw("Graph.fY-Mean09:Graph.fX","","",1,ievent);
    Double_t * signal  = treeB->GetV1();
    Double_t * time  = treeB->GetV2();
    Double_t maxpos =0;
    Double_t max = 0;
    for (Int_t ipos = 0; ipos<nsample; ipos++){
      if (signal[ipos]>max){
	max    = signal[ipos];
	maxpos = ipos;
      }
    }

    Int_t first = TMath::Max(maxpos-10,0.);
    Int_t last  = TMath::Min(maxpos+60, nsample);
    //
    f->cd();
    TH1F his(ename,ename,last-first,first,last);
    for (Int_t ipos=0; ipos<last-first; ipos++){
      his.SetBinContent(ipos+1,signal[ipos+first]);
    }
    treeB->Draw("Sector:Row:Pad","","",1,ievent);
    Double_t sector = treeB->GetV1()[0];
    Double_t row    = treeB->GetV2()[0];
    Double_t pad    = treeB->GetV3()[0];
    //    TGraph  graph(last-first,&time[first],&signal[first]);
    f1->SetParameters(0.75*max,maxpos,1.1,0.8,0.25,0.2);
    //    TH1F * his = (TH1F*)graph.GetHistogram();
    his.Fit(f1,"q");
    his.Write(ename);
    gPad->Clear();
    his.Draw();
    gPad->Update();
    Double_t params[6];
    for (Int_t ipar=0; ipar<6; ipar++) params[ipar] = f1->GetParameters()[ipar];
    Double_t chi2 = TFitter::GetFitter()->Chisquare(6,params);
    TMatrixD cov(6,6);
    cov.SetMatrixArray(TFitter::GetFitter()->GetCovarianceMatrix());
    //
    // tail cancellation
    //
    Double_t x0[1000];
    Double_t x1[1000];
    Double_t x2[1000];
    for (Int_t ipos=0; ipos<last-first; ipos++){
      x0[ipos] = signal[ipos+first];
    }
    proc.TailCancelationALTRO1(x0,x1,0.85*0.339,0.09,last-first);
    proc.TailCancelationALTRO1(x1,x2,0.85,0.789,last-first);
    //
    sprintf(ename,"Cancel1_%d", ievent);
    TH1F his1(ename,ename,last-first,first,last);
    for (Int_t ipos=0; ipos<last-first; ipos++){
      his1.SetBinContent(ipos+1,x1[ipos]);
    }
    his1.Write(ename);
    sprintf(ename,"Cancel2_%d", ievent);
    TH1F his2(ename,ename,last-first,first,last);
    for (Int_t ipos=0; ipos<last-first; ipos++){
      his2.SetBinContent(ipos+1,x1[ipos]);
    }
    f1->SetParameters(0.75*max,maxpos,1.1,0.8,0.25,0.2);
    his2.Fit(f1,"q");
    his2.Write(ename);
    Double_t params2[6];
    for (Int_t ipar=0; ipar<6; ipar++) params2[ipar] = f1->GetParameters()[ipar];
    Double_t chi22 = TFitter::GetFitter()->Chisquare(6,params2);    
    TMatrixD cov2(6,6);
    cov2.SetMatrixArray(TFitter::GetFitter()->GetCovarianceMatrix());

    TGraph gr0(last-first, &time[first],x0);
    TGraph gr1(last-first, &time[first],x1);
    TGraph gr2(last-first, &time[first],x2);
    //
    cstream<<"Fit"<<
      "Sector="<<sector<<
      "Row="<<row<<
      "Pad="<<pad<<
      "First="<<first<<
      "Max="<<max<<
      "MaxPos="<<maxpos<<
      "chi2="<<chi2<<
      "chi22="<<chi22<<
      "Cov="<<&cov<<
      "Cov2="<<&cov2<<
      "gr0.="<<&gr0<<
      "gr1.="<<&gr1<<
      "gr2.="<<&gr2<<
      "p0="<<params[0]<<
      "p1="<<params[1]<<
      "p2="<<params[2]<<
      "p3="<<params[3]<<
      "p4="<<params[4]<<
      "p5="<<params[5]<<
      "p02="<<params2[0]<<
      "p12="<<params2[1]<<
      "p22="<<params2[2]<<
      "p32="<<params2[3]<<
      "p42="<<params2[4]<<
      "p52="<<params2[5]<<
      "\n";
    //    delete his;
    nFits++;
  }

}
void DrawPrototype3EMCalTower(                                                                                                                    //
    const TString infile = "/phenix/u/jinhuang/links/sPHENIX_work/Prototype_2017/Production_0216_UpdateCalib/beam_00003672-0000_DSTReader.root",  //
    bool plot_all = false, const double momentum = -16)
{
  beam_momentum_selection = momentum;

  SetOKStyle();
  gStyle->SetOptStat(0);
  gStyle->SetOptFit(1111);
  TVirtualFitter::SetDefaultFitter("Minuit2");
  gSystem->Load("libg4eval.so");
  gSystem->Load("libqa_modules.so");
  gSystem->Load("libPrototype3.so");

  //  gROOT->LoadMacro("Prototype3_DSTReader.C+");

  if (!_file0)
  {
    TString chian_str = infile;
    chian_str.ReplaceAll("ALL", "*");

    TChain *t = new TChain("T");
    const int n = t->Add(chian_str);

    cout << "Loaded " << n << " root files with " << chian_str << endl;
    assert(n > 0);

    T = t;

    _file0 = new TFile;
    _file0->SetName(infile);
  }

  assert(_file0);

  T->SetAlias("ActiveTower_LG",
              "TOWER_LG_CEMC[].get_binphi()<8 && TOWER_LG_CEMC[].get_bineta()<8");
  T->SetAlias("EnergySum_LG",
              "1*Sum$(TOWER_LG_CEMC[].get_energy() * ActiveTower_LG)");

  T->SetAlias("ActiveTower_HG",
              "TOWER_HG_CEMC[].get_binphi()<8 && TOWER_HG_CEMC[].get_bineta()<8");
  T->SetAlias("EnergySum_HG",
              "1*Sum$(TOWER_HG_CEMC[].get_energy() * ActiveTower_HG)");

  //  T->SetAlias("C2_Inner_e", "1*TOWER_RAW_C2[0].energy");
  T->SetAlias("C2_Inner_e", "1*(TOWER_CALIB_C2[2].energy)");
  T->SetAlias("C2_Outer_e", "1*(TOWER_CALIB_C2[3].energy)");
  T->SetAlias("C2_Sum_e", "C2_Inner_e + C2_Outer_e");
  T->SetAlias("C1", "0 + TOWER_CALIB_C1[0].energy");

  //  "TOWER_CALIB_CEMC.energy * ( Sum$( TOWER_CALIB_CEMC.get_column()==2 && TOWER_CALIB_CEMC.get_row()==1

  T->SetAlias("Average_column",
              "Sum$(TOWER_CALIB_CEMC.get_column() * TOWER_CALIB_CEMC.get_energy())/Sum$(TOWER_CALIB_CEMC.get_energy())");
  T->SetAlias("Average_row",
              "Sum$(TOWER_CALIB_CEMC.get_row() * TOWER_CALIB_CEMC.get_energy())/Sum$(TOWER_CALIB_CEMC.get_energy())");

  T->SetAlias("Average_HODO_VERTICAL",
              "Sum$(TOWER_CALIB_HODO_VERTICAL.towerid * (abs(TOWER_CALIB_HODO_VERTICAL.energy)>30) * abs(TOWER_CALIB_HODO_VERTICAL.energy))/Sum$((abs(TOWER_CALIB_HODO_VERTICAL.energy)>30) * abs(TOWER_CALIB_HODO_VERTICAL.energy))");
  T->SetAlias("Valid_HODO_VERTICAL",
              "Sum$(abs(TOWER_CALIB_HODO_VERTICAL.energy)>30) > 0");

  T->SetAlias("Average_HODO_HORIZONTAL",
              "Sum$(TOWER_CALIB_HODO_HORIZONTAL.towerid * (abs(TOWER_CALIB_HODO_HORIZONTAL.energy)>30) * abs(TOWER_CALIB_HODO_HORIZONTAL.energy))/Sum$((abs(TOWER_CALIB_HODO_HORIZONTAL.energy)>30) * abs(TOWER_CALIB_HODO_HORIZONTAL.energy))");
  T->SetAlias("Valid_HODO_HORIZONTAL",
              "Sum$(abs(TOWER_CALIB_HODO_HORIZONTAL.energy)>30) > 0");

  T->SetAlias("No_Triger_VETO",
              "Sum$(abs(TOWER_RAW_TRIGGER_VETO.energy)>15)==0");

  T->SetAlias("Energy_Sum_col1_row2_3x3",
              "Sum$( (abs(TOWER_CALIB_CEMC.get_column()-1)<=1 && abs(TOWER_CALIB_CEMC.get_row()-2)<=1 ) * TOWER_CALIB_CEMC.get_energy())");
  T->SetAlias("Energy_Sum_col1_row2_5x5",
              "Sum$( (abs(TOWER_CALIB_CEMC.get_column()-1)<=2 && abs(TOWER_CALIB_CEMC.get_row()-2)<=2 ) * TOWER_CALIB_CEMC.get_energy())");
  T->SetAlias("Energy_Sum_col2_row2_5x5",
              "Sum$( (abs(TOWER_CALIB_CEMC.get_column()-2)<=2 && abs(TOWER_CALIB_CEMC.get_row()-2)<=2 ) * TOWER_CALIB_CEMC.get_energy())");
  T->SetAlias("Energy_Sum_CEMC", "1*Sum$(TOWER_CALIB_CEMC.get_energy())");
  T->SetAlias("Energy_Sum_RAW_CEMC", "1*Sum$(TOWER_RAW_CEMC.get_energy())");

  // 12 GeV calibration
  //  EDM=9.83335e-18    STRATEGY= 1      ERROR MATRIX ACCURATE
  //EXT PARAMETER                                   STEP         FIRST
  //NO.   NAME      VALUE            ERROR          SIZE      DERIVATIVE
  //1  p0           1.19768e+01   7.30605e-02   3.76799e-05   4.24290e-09
  //2  p1           8.71776e+00   6.82987e-02   3.52240e-05   6.80808e-08

  //    T->SetAlias("Energy_Sum_Hadron_CEMC",
  //        "1*Sum$(TOWER_CALIB_CEMC.get_energy())"); // full bias
  T->SetAlias("Energy_Sum_Hadron_CEMC",
              "1.14*12./8.71776e+00*Sum$(TOWER_CALIB_CEMC.get_energy())");  // full bias
                                                                            //  T->SetAlias("Energy_Sum_Hadron_CEMC",
                                                                            //      "1.14*12./8.71776e+00*(16./6.93250e+00)*(28/33.3405)*Sum$(TOWER_CALIB_CEMC.get_energy())"); // half-gain bias
  T->SetAlias("CEMC_MIP", "Energy_Sum_Hadron_CEMC<0.7");

  // 12 GeV calibration
  //  FCN=9.63681 FROM HESSE     STATUS=OK             14 CALLS          56 TOTAL
  //                      EDM=1.49963e-17    STRATEGY= 1      ERROR MATRIX ACCURATE
  //   EXT PARAMETER                                   STEP         FIRST
  //   NO.   NAME      VALUE            ERROR          SIZE      DERIVATIVE
  //    1  p0           9.50430e+00   8.42691e-02   3.83666e-06   1.41105e-08
  //    2  p1           6.99727e+00   1.06583e-01   4.85258e-06   5.85631e-08

  //  T->SetAlias("Energy_Sum_Hadron_HCALIN",
  //      "1*Sum$(TOWER_CALIB_LG_HCALIN.get_energy())");
  //  T->SetAlias("HCALIN_MIP", "Energy_Sum_Hadron_HCALIN<0.5");
  //  T->SetAlias("Energy_Sum_Hadron_HCALOUT",
  //      "1*Sum$(TOWER_CALIB_LG_HCALOUT.get_energy())");
  T->SetAlias("Energy_Sum_Hadron_HCALIN",
              "12./6.99727e+00*Sum$(TOWER_CALIB_LG_HCALIN.get_energy())");
  T->SetAlias("HCALIN_MIP", "Energy_Sum_Hadron_HCALIN<0.5");
  T->SetAlias("Energy_Sum_Hadron_HCALOUT",
              "12./9.50430e+00*Sum$(TOWER_CALIB_LG_HCALOUT.get_energy())");

  T->SetAlias("MIP_Count_Col2",
              "Sum$( abs( TOWER_RAW_CEMC.get_energy() )>20 && abs( TOWER_RAW_CEMC.get_energy() )<200 && TOWER_CALIB_CEMC.get_column() == 2 )");
  T->SetAlias("Pedestal_Count_AllCEMC",
              "Sum$( abs( TOWER_RAW_CEMC.get_energy() )<20)");

  //
  TCut event_sel = "1*1";

  if (plot_all)
  {
    //      event_sel = "1*1";
    //      cuts = "_all_event";
    //      event_sel = "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL";
    //      cuts = "_Valid_HODO";
    event_sel =
        "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && No_Triger_VETO";
    cuts = "_Valid_HODO_Trigger_VETO";
  }
  else
  {
    if (0)
    {  // energy selection
      event_sel = Form("(beam_MTNRG_GeV == %f)", beam_momentum_selection);
      cuts = Form("_%.0fGeV", beam_momentum_selection);

      cout << "Build event selection of " << (const char *) event_sel
           << endl;

      T->Draw(">>EventListRunCut", event_sel);
      TEventList *elist = gDirectory->GetObjectChecked("EventListRunCut",
                                                       "TEventList");
      cout << elist->GetN() << " / " << T->GetEntriesFast()
           << " events selected" << endl;
      T->SetEventList(elist);
    }

    //      event_sel = "1*1";
    //      cuts = "_all_event";
    //      event_sel = "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL";
    //      cuts = "_Valid_HODO";
    event_sel =
        "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && No_Triger_VETO";
    cuts = "_Valid_HODO_Trigger_VETO";

    //      event_sel =
    //          event_sel
    //              + "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && No_Triger_VETO  && (C2_Sum_e<50)";
    //      cuts = cuts + "_Valid_HODO_Trigger_VETO_C2_Sum_Hadron";

    //      event_sel =
    //          event_sel
    //              + "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && No_Triger_VETO && CEMC_MIP && (C2_Sum_e<100)";
    //      cuts = cuts + "_Valid_HODO_Trigger_VETO_CEMC_MIP_C2_Sum_Hadron";

    //      event_sel = "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && (MIP_Count_Col2 == 8) && (Pedestal_Count_AllCEMC >= 64 - 8)";
    //      cuts = "_Valid_HODO_MIP_Col2_PedestalOther";

    //      event_sel = "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && Average_HODO_VERTICAL>1.5 && Average_HODO_VERTICAL<4.5 && Average_HODO_HORIZONTAL>3.5 && Average_HODO_HORIZONTAL<6.5";
    //      cuts = "_Valid_HODO_center_col1_row2";

    //      event_sel =
    //          "C2_Inner_e>100 && Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && Average_HODO_HORIZONTAL>1.5 && Average_HODO_HORIZONTAL<4.5 && Average_HODO_VERTICAL>3.5 && Average_HODO_VERTICAL<6.5";
    //      cuts = "_Valid_HODO_center_col1_row2_C2";

    //      event_sel = "abs(Average_column - 1)<.5 && abs(Average_row - 2) < .5";
    //      cuts = "_tower_center_col1_row2";
    //      event_sel = "Valid_HODO_HORIZONTAL && Valid_HODO_VERTICAL && abs(C2_Inner_e)<10";
    //      cuts = "_Valid_HODO_VetoC2";
  }

  cout << "Build event selection of " << (const char *) event_sel << endl;

  T->Draw(">>EventList", event_sel);
  TEventList *elist = gDirectory->GetObjectChecked("EventList", "TEventList");
  cout << elist->GetN() << " / " << T->GetEntriesFast() << " events selected"
       << endl;

  T->SetEventList(elist);

  //  int rnd = rand();
  //  gDirectory->mkdir(Form("dir_%d", rnd));
  //  gDirectory->cd(Form("dir_%d", rnd));
  //  if (plot_all)
  //    EMCDistribution_SUM("Energy_Sum_col1_row2_5x5");

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_ShowShape("C1");

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_SUM("Energy_Sum_CEMC", "C1");
  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  //  if (plot_all)
  EMCDistribution_SUM_RawADC("Energy_Sum_RAW_CEMC", "C2_Sum_e");

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_SUM("Energy_Sum_col2_row2_5x5", "C2_Sum_e");

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_HCalCalibration();

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_Fast();

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_Fast("RAW");
  //
  //  int rnd = rand();
  //  gDirectory->mkdir(Form("dir_%d", rnd));
  //  gDirectory->cd(Form("dir_%d", rnd));
  //  if (plot_all)
  //    EMCDistribution_PeakSample_Fast();

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_Fast("CALIB", true);

  int rnd = rand();
  gDirectory->mkdir(Form("dir_%d", rnd));
  gDirectory->cd(Form("dir_%d", rnd));
  if (plot_all)
    EMCDistribution_ADC();

  //  if (!plot_all)
  //    T->Process("Prototype3_DSTReader.C+",
  //        TString(_file0->GetName())
  //            + TString("_DrawPrototype3EMCalTower_Prototype3_DSTReader") + cuts
  //            + TString(".dat"));
}
Exemple #17
0
void RAA_HFVsValidation_MC(char *algo = "Vs", char *jet_type = "PF"){


  TStopwatch timer;
  timer.Start();
  
  TH1::SetDefaultSumw2();
  TH2::SetDefaultSumw2();

  gStyle->SetOptStat(0);

  cout<<"Running for Algorithm "<<algo<<" "<<jet_type<<endl;
 
  bool printDebug = true;
  TDatime date;

  const int nbins_pthat = 9;
  Double_t boundaries_pthat[nbins_pthat+1];
  char *fileName_pthat[nbins_pthat+1];
  Double_t xsection[nbins_pthat+1];
  Double_t entries[nbins_pthat]; 
  //there are two ways in which we can select the no of events we use to scale - it has to be between the pthat range. 
  //first file name - partial 50K statistics, second one is full statistics sample. 
  //similarly the entries number is for the small statistics. 
  
  // refer this twiki for the data and MC files: http://twiki.cern.ch/twiki/bin/viewauth/CMS/HiForestPA2014#PYTHIA_HYDJET_embedded_sample

  boundaries_pthat[0]=15;
  fileName_pthat[0] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat15_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[0] = "/export/d00/scratch/dav2105/badjets/bad15.root";
  xsection[0]= 2.034e-01;
  //entries[0] = ;//total - 48588
  
  boundaries_pthat[1]=30;
  fileName_pthat[1] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat30_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[1] = "/export/d00/scratch/dav2105/badjets/bad30.root";
  xsection[1]= 1.075e-02;
  // entries[1] = ;//total - 48428
  
  boundaries_pthat[2]=50;
  fileName_pthat[2] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat50_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[2] = "/export/d00/scratch/dav2105/badjets/bad50.root";
  xsection[2]= 1.025e-03;
  // entries[2] = ;//total - 50000
  
  boundaries_pthat[3]=80;
  fileName_pthat[3] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat80_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[3] = "/export/d00/scratch/dav2105/badjets/bad80.root";
  xsection[3]= 9.865e-05;
  // entries[3] = ;//total - 49500
  
  boundaries_pthat[4]=120;
  fileName_pthat[4] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat120_Track9_Jet30_matchEqR_merged_forest_0.root";  
  //fileName_pthat[4] = "/export/d00/scratch/dav2105/badjets/bad120.root";
  xsection[4]= 1.129e-05;
  // entries[4] = ;//total - 49500

  boundaries_pthat[5]=170;
  fileName_pthat[5] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat170_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[5] = "/export/d00/scratch/dav2105/badjets/bad120.root";
  xsection[5]= 1.465e-06;
  // entries[5] = ;//total - 49444

  boundaries_pthat[6]=220;
  fileName_pthat[6] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat220_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[6] = "/export/d00/scratch/dav2105/badjets/bad220.root";
  xsection[6]= 2.837e-07;
  // entries[6] = ;//total - 49460

  boundaries_pthat[7]=280;
  fileName_pthat[7] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat280_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[7] = "/export/d00/scratch/dav2105/badjets/bad280.root";
  xsection[7]= 5.323e-08;
  // entries[7] = ;//total - 49541

  boundaries_pthat[8]=370;
  fileName_pthat[8] = "/mnt/hadoop/cms/store/user/dgulhan/PYTHIA_HYDJET_Track9_Jet30_Pyquen_DiJet_TuneZ2_Unquenched_Hydjet1p8_2760GeV_merged/HiForest_PYTHIA_HYDJET_pthat370_Track9_Jet30_matchEqR_merged_forest_0.root";
  //fileName_pthat[8] = "/export/d00/scratch/dav2105/badjets/bad370.root";
  xsection[8]= 5.934e-09;
  // entries[8] = ;//total - 19031

  boundaries_pthat[9] = 2000;
  xsection[9] = 0.0;

  // Vertex & centrality reweighting for PbPb
  TF1 *fVz;
  fVz = new TF1("fVz","[0]+[1]*x+[2]*x*x+[3]*x*x*x+[4]*x*x*x*x");
  fVz->SetParameters(9.86748e-01, -8.91367e-03, 5.35416e-04, 2.67665e-06, -2.01867e-06);

  //get the centrality weight from the root file created in the plotting macro. 
  TFile *fcentin = TFile::Open("/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_20/src/Output/PbPb_DataMC_cent_ratio_20141117.root");
  TH1F *hCentWeight = (TH1F*)fcentin->Get("hCentRatio");


  TH2F *hSumpTvsHF[15];
  TH2F *hSumpTvsHF_cent[nbins_cent+1];
  TH2F *hSumpTvshiBin[15];
  TH2F *hSumpTvshiBin_cent[nbins_cent+1];
  TH2F *hNJetsvsSumpT[nbins_cent+1];
  TH2F *hNJetsvsSumpT_noHF[nbins_cent+1];
  TH2F *hNJetsvsSumpT_HF[nbins_cent+1];
  TH1F *hSumpT[nbins_cent+1];
  TH1F *hPsi[5][15][nbins_cent+1];
  //TH2F *hPsi_2d[5][15][nbins_cent];

  TH2F *hPsivsHF[5][15];
  TH2F *hPsivsHF_cent[5][nbins_cent+1];
  TH2F *hvnvsHF[5][15];
  TH2F *hvnvscent[5][nbins_cent+1];

  // UseFull histograms: Event Plane from HF for the official versus HF/Vs algorithm calculation of the Event Plane.
  // first [3] array elements - Psi_2, Psi_3, Psi_4  only in the HF for tonight. 
  // [3] - total, p - positive and n - negative in eta; based on what we have from the https://github.com/CmsHI/cmssw/blob/forest_CMSSW_5_3_20/RecoHI/HiEvtPlaneAlgos/interface/HiEvtPlaneList.h#L31 
  TH1F *hEP_HF_Official[3][3][nbins_cent+1];
  TH1F *hEP_HF_Vs[3][3][nbins_cent+1];
  TH2F *hEP_HF[3][3][nbins_cent+1];
  TH1F *hAngle_2_HF_Vs[nbins_cent+1];
  TH1F *hAngle_3_HF_Vs[nbins_cent+1];
  TH1F *hAngle_4_HF_Vs[nbins_cent+1];
  TH1F *hAngle_2_HF_Official[nbins_cent+1];
  TH1F *hAngle_3_HF_Official[nbins_cent+1];
  TH1F *hAngle_4_HF_Official[nbins_cent+1];
  TH1F *hMagnitude_2_HF_Vs[nbins_cent+1];
  TH1F *hMagnitude_3_HF_Vs[nbins_cent+1];
  TH1F *hMagnitude_4_HF_Vs[nbins_cent+1];
  TH2F *hSub_vs_SumpT[nbins_cent+1];
  TH2F *hVsAngle_EP[3][nbins_cent+1];

  for(int i = 0;i<nbins_cent+1;i++){
    
    for(int z = 0;z<3;z++){
      for(int x = 0;x<3;x++){
	hEP_HF_Official[z][x][i] = new TH1F(Form("hEP_HF_Official_Psi%d_%d_cent%d",z,x,i),"",630,-3.15,3.15);
	hEP_HF_Vs[z][x][i] = new TH1F(Form("hEP_HF_Vs_Psi%d_%d_cent%d",z,x,i),"",630,-3.15,3.15);
	hEP_HF[z][x][i] = new TH2F(Form("hEP_HF_Psi%d_%d_cent%d",z,x,i),"",630,-3.15,3.15,630,-3.15,3.15);
      }
    }

    hSumpTvsHF_cent[i] = new TH2F(Form("hSumpT_vsHF_cent%d",i),"",5000,0,100000,5000,0,100000);
    hSumpTvshiBin_cent[i] = new TH2F(Form("hSumpT_vshiBin_cent%d",i),"",5000,0,100000,200,0,200);
    hNJetsvsSumpT[i] = new TH2F(Form("hNJetsvsSumpT_cent%d",i),"",50,0,50,5000,0,100000);
    hNJetsvsSumpT_noHF[i] = new TH2F(Form("hNJetsvsSumpT_noHF_cent%d",i),"",50,0,50,5000,0,100000);
    hNJetsvsSumpT_HF[i] = new TH2F(Form("hNJetsvsSumpT_HF_cent%d",i),"",50,0,50,5000,0,100000);
    hAngle_2_HF_Vs[i] = new TH1F(Form("hAngle_2_HF_Vs_cent%d",i),"",30,-3.15,+3.15);
    hAngle_3_HF_Vs[i] = new TH1F(Form("hAngle_3_HF_Vs_cent%d",i),"",30,-3.15,+3.15);
    hAngle_4_HF_Vs[i] = new TH1F(Form("hAngle_4_HF_Vs_cent%d",i),"",30,-3.15,+3.15);
    hAngle_2_HF_Official[i] = new TH1F(Form("hAngle_2_HF_Official_cent%d",i),"",60,-3.15,+3.15);
    hAngle_3_HF_Official[i] = new TH1F(Form("hAngle_3_HF_Official_cent%d",i),"",60,-3.15,+3.15);
    hAngle_4_HF_Official[i] = new TH1F(Form("hAngle_4_HF_Official_cent%d",i),"",60,-3.15,+3.15);
    hSumpT[i] = new TH1F(Form("hSumpT_cent%d",i),"",5000,0,100000);
    hMagnitude_2_HF_Vs[i] = new TH1F(Form("hMagnitude_2_HF_Vs_cent%d",i),"",1000,0,1);
    hMagnitude_3_HF_Vs[i] = new TH1F(Form("hMagnitude_3_HF_Vs_cent%d",i),"",1000,0,1);
    hMagnitude_4_HF_Vs[i] = new TH1F(Form("hMagnitude_4_HF_Vs_cent%d",i),"",1000,0,1);
    hSub_vs_SumpT[i] = new TH2F(Form("hSub_vs_SumpT_cent%d",i),"",1200,0,12000,1200,0,12000);
    hVsAngle_EP[0][i] = new TH2F(Form("hVsAngle_EP_2_cent%d",i),"",60,-3.15,+3.15,60,-3.15,+3.15);
    hVsAngle_EP[1][i] = new TH2F(Form("hVsAngle_EP_3_cent%d",i),"",60,-3.15,+3.15,60,-3.15,+3.15);
    hVsAngle_EP[2][i] = new TH2F(Form("hVsAngle_EP_4_cent%d",i),"",60,-3.15,+3.15,60,-3.15,+3.15);

    /*
    for(int b = 0;b<5;b++){

      hPsivsHF_cent[b][i] = new TH2F(Form("hPsi%d_cent%d",b,i),"",630,-3.15,+3.15,5000,0,100000);
      hvnvsHF[b][i] = new TH2F(Form("hvn%d_HF_cent%d",b,i),"",100,0,1,5000,0,100000);
      //hvnvscent[b][i] = new TH2F
      for(int a = 0;a<15;a++){

	//hPsi[b][a][i] = new TH1F(Form("hPsi_n%d_eta%d_cent%d",b,a,i),"",630,-3.15,3.15);
	
      }
      
    }
    */
  }
  
  /*  
  // declare the histograms in loops:
  for(int a = 0;a<15;a++){
    
    hSumpTvsHF[a] = new TH2F(Form("hSumpT_eta%d_vsHF",a),"",5000,0,100000,5000,0,100000);
    hSumpTvshiBin[a] = new TH2F(Form("hSumpT_eta%d_vshiBin",a),"",5000,0,100000,200,0,200);
    
    for(int b = 0;b<5;b++){
      
      hPsivsHF[b][a] = new TH2F(Form("hPsi%d_etabin%d_HF",b,a),"",630,-3.15,+3.15,5000,0,100000);
      hvnvsHF[b][a] = new TH2F(Form("hvn%d_etabin%d_HF",b,a),"",100,0,1,5000,0,100000);
      
    }// no of flow components
    
  }// eta bin
  */
  TH1F *hPtHat[no_radius];
  TH1F *hPtHatRaw[no_radius];
  // Setup jet data branches - this will be 2D with [radius][pthat-file], but the histogram here is just 1D with [radius]
  JetData *data[no_radius][nbins_pthat]; 
  for(int k = 0;k<no_radius;k++){
    hPtHatRaw[k] = new TH1F(Form("hPtHatRaw_R%d",list_radius[k]),"",nbins_pthat,boundaries_pthat);
    hPtHat[k] = new TH1F(Form("hPtHat_R%d",list_radius[k]),"",nbins_pthat,boundaries_pthat);
    if(printDebug)cout<<"Radius = "<<list_radius[k]<<endl;
    if(printDebug)cout<<"reading all the pbpb mc files"<<endl;
    for (int h=0;h<nbins_pthat;h++) {
      //cout<<Form("ak%s%dJetAnalyzer/t",algo,list_radius[k])<<endl;
      data[k][h] = new JetData(fileName_pthat[h],Form("ak%s%d%sJetAnalyzer/t",algo,list_radius[k],jet_type),Form("ak%s%d%sJetAnalyzer/t",algo,list_radius[k],jet_type),0,1);
      //cout<<"A"<<endl;
      TH1F *hPtHatTmp = new TH1F("hPtHatTmp","",nbins_pthat,boundaries_pthat);
      //cout<<"B"<<endl;
      data[k][h]->tJet->Project("hPtHatTmp","pthat");
      //cout<<"C"<<endl;
      hPtHatRaw[k]->Add(hPtHatTmp);
      //cout<<"D"<<endl;
      delete hPtHatTmp;
    }// pthat loop
  }
  
  
  for(int k = 0;k<no_radius;k++){
    if(printDebug)cout<<"Filling MC for radius = "<<list_radius[k]<<endl;
    // fill PbPb MC 
    if(printDebug)cout<<"Filling PbPb MC"<<endl;
    
    for (int h=0;h<nbins_pthat;h++) {
      if (xsection[h]==0) continue;
      if(printDebug)cout <<"Loading pthat"<<boundaries_pthat[h]<<" sample, cross section = "<<xsection[h]<< Form(" pthat>%.0f&&pthat<%.0f",boundaries_pthat[h],boundaries_pthat[h+1])<<endl;
      
      //TCut pthatcut = Form("pthat>%d && pthat<%d",boundaries_pthat[h],boundaries_pthat[h+1]);
      //double fentries_test = data[k][h]->tJet->GetEntries(pthatcut);
      //cout<<"fentries_test = "<<fentries_test<<endl;
      
      //from Pawan's code: /net/hisrv0001/home/pawan/Validation/CMSSW_7_1_1/src/combinePtHatBins/pbpbJEC2014/condor/CondorPbPbCalJec.C
      TEventList *el = new TEventList("el","el");
      //double pthat_event = data[k][h]->pthat;
      //double pthat_lower = boundaries_pthat[h];
      double pthat_upper = boundaries_pthat[h+1];
      stringstream selection; selection<<"pthat<"<<pthat_upper;
      
      data[k][h]->tJet->Draw(">>el",selection.str().c_str());
      double fentries = el->GetN();
      if(printDebug)cout<<"tree entries: "<<data[k][h]->tJet->GetEntries()<<" elist: "<<fentries<<endl;
      delete el;
      int test_counter = 0; 
      
      for (Long64_t jentry=0; jentry<data[k][h]->tJet->GetEntries();jentry++) {
	//for (Long64_t jentry=0; jentry<10;jentry++) {
	
        //cout<<"hi"<<endl;
        data[k][h]->tEvt->GetEntry(jentry);
        data[k][h]->tJet->GetEntry(jentry);
        data[k][h]->tSkim->GetEntry(jentry);
        	
        int pthatBin = hPtHat[k]->FindBin(data[k][h]->pthat);
	
	double scale = (double)(xsection[pthatBin-1]-xsection[pthatBin])/fentries;
	
	if(!data[k][h]->pcollisionEventSelection) continue;
        int cBin = findBin(data[k][h]->bin);
        //int cBin = nbins_cent-1;
        double weight_cent=1;
        double weight_pt=1;
        double weight_vz=1;
	Float_t cent = cBin;
	
        weight_cent = hCentWeight->GetBinContent(hCentWeight->FindBin(data[k][h]->bin));
	if(fabs(data[k][h]->vz)>15) continue;
	
        weight_vz = fVz->Eval(data[k][h]->vz);
	
        if(scale*weight_cent*weight_vz <=0 ) {
	  cout<<"RED FLAG RED FLAG RED FLAG"<<endl;
	  continue;
	}
	
	int jetCounter = 0;//counts jets which are going to be used in the supernova cut rejection. 
	
	for(int j = 0;j<nbins_eta;j++){
	  
	  for(int g = 0;g<data[k][h]->njets;g++){
	    
	    if(data[k][h]->jteta[g] >= boundaries_eta[j][0] && data[k][h]->jteta[g] < boundaries_eta[j][1]){
	      //cout<<"jtpt = "<<data[k][h]->jtpt[g]<<endl;
	      if(data[k][h]->jtpt[g]>=50) jetCounter++;
	      
	    }// eta selection loop
	    
	  }//jet loop
	  
	}//eta bins loop

	//constructing the x-,y- and x+,y+ based on the following equation: 
	// x- = sumpt[0]*vn[2][0]*cos(2*vpsi[2][0]) y- = sumpt[0]*vn[2][0]*sin(2*vpsi[2][0])
	Float_t Vs_2_x_minus = data[k][h]->sumpT[0]*data[k][h]->v_n[2][0]*TMath::Cos(2*data[k][h]->psi_n[2][0]);
	Float_t Vs_2_x_plus = data[k][h]->sumpT[14]*data[k][h]->v_n[2][14]*TMath::Cos(2*data[k][h]->psi_n[2][14]);
	Float_t Vs_2_y_minus = data[k][h]->sumpT[0]*data[k][h]->v_n[2][0]*TMath::Sin(2*data[k][h]->psi_n[2][0]);
	Float_t Vs_2_y_plus = data[k][h]->sumpT[14]*data[k][h]->v_n[2][14]*TMath::Sin(2*data[k][h]->psi_n[2][14]);
	Float_t Vs_2_x = Vs_2_x_minus + Vs_2_x_plus;
	Float_t Vs_2_y = Vs_2_y_minus + Vs_2_y_plus;
	Float_t Vs_2_angle = TMath::ATan2(Vs_2_y,Vs_2_x);
	hAngle_2_HF_Vs[cBin]->Fill(Vs_2_angle);
	hAngle_2_HF_Vs[nbins_cent]->Fill(Vs_2_angle);
	//cout<<"Vs_2_angle = "<<Vs_2_angle<<endl;

	Float_t Vs_3_x_minus = data[k][h]->sumpT[0]*data[k][h]->v_n[3][0]*TMath::Cos(3*data[k][h]->psi_n[3][0]);
	Float_t Vs_3_x_plus = data[k][h]->sumpT[14]*data[k][h]->v_n[3][14]*TMath::Cos(3*data[k][h]->psi_n[3][14]);
	Float_t Vs_3_y_minus = data[k][h]->sumpT[0]*data[k][h]->v_n[3][0]*TMath::Sin(3*data[k][h]->psi_n[3][0]);
	Float_t Vs_3_y_plus = data[k][h]->sumpT[14]*data[k][h]->v_n[3][14]*TMath::Sin(3*data[k][h]->psi_n[3][14]);
	Float_t Vs_3_x = Vs_3_x_minus + Vs_3_x_plus;
	Float_t Vs_3_y = Vs_3_y_minus + Vs_3_y_plus;
	Float_t Vs_3_angle = TMath::ATan2(Vs_3_y,Vs_3_x);
	hAngle_3_HF_Vs[cBin]->Fill(Vs_3_angle);
	hAngle_3_HF_Vs[nbins_cent]->Fill(Vs_3_angle);
	//cout<<"Vs_3_angle = "<<Vs_3_angle<<endl;

	Float_t Vs_4_x_minus = data[k][h]->sumpT[0]*data[k][h]->v_n[4][0]*TMath::Cos(4*data[k][h]->psi_n[4][0]);
	Float_t Vs_4_x_plus = data[k][h]->sumpT[14]*data[k][h]->v_n[4][14]*TMath::Cos(4*data[k][h]->psi_n[4][14]);
	Float_t Vs_4_y_minus = data[k][h]->sumpT[0]*data[k][h]->v_n[4][0]*TMath::Sin(4*data[k][h]->psi_n[4][0]);
	Float_t Vs_4_y_plus = data[k][h]->sumpT[14]*data[k][h]->v_n[4][14]*TMath::Sin(4*data[k][h]->psi_n[4][14]);
	Float_t Vs_4_x = Vs_4_x_minus + Vs_4_x_plus;
	Float_t Vs_4_y = Vs_4_y_minus + Vs_4_y_plus;
	Float_t Vs_4_angle = TMath::ATan2(Vs_4_y,Vs_4_x);
	hAngle_4_HF_Vs[cBin]->Fill(Vs_4_angle);
	hAngle_4_HF_Vs[nbins_cent]->Fill(Vs_4_angle);
      	//cout<<"Vs_4_angle = "<<Vs_4_angle<<endl;

	//lets get the maginitude of the x,y here: 
	Float_t Vs_Mag_2 = TMath::Sqrt(Vs_2_x*Vs_2_x + Vs_2_y*Vs_2_y);
	Float_t Vs_Mag_3 = TMath::Sqrt(Vs_3_x*Vs_3_x + Vs_3_y*Vs_3_y);
	Float_t Vs_Mag_4 = TMath::Sqrt(Vs_4_x*Vs_4_x + Vs_4_y*Vs_4_y);
	// need to calculate the Total per event (pfPt - pfVsPt) versus sumpT[0]+sumpT[14];
	Float_t pfPt_Tot = 0;
	Float_t pfVsPt_Tot = 0;
	for(int i = 0;i<data[k][h]->nPFpart;i++){
	  pfPt_Tot += data[k][h]->pfPt[i];
	  pfVsPt_Tot += data[k][h]->pfVsPt[i];
	}
	Float_t sumpT_HF = data[k][h]->sumpT[0] + data[k][h]->sumpT[14];

	hMagnitude_2_HF_Vs[cBin]->Fill(Vs_Mag_2/sumpT_HF);
	hMagnitude_2_HF_Vs[nbins_cent]->Fill(Vs_Mag_2/sumpT_HF);
	hMagnitude_3_HF_Vs[cBin]->Fill(Vs_Mag_3/sumpT_HF);
	hMagnitude_3_HF_Vs[nbins_cent]->Fill(Vs_Mag_3/sumpT_HF);
	hMagnitude_4_HF_Vs[cBin]->Fill(Vs_Mag_4/sumpT_HF);
	hMagnitude_4_HF_Vs[nbins_cent]->Fill(Vs_Mag_4/sumpT_HF);
	//Float_t sub_ratio = (Float_t)(pfPt_Tot-pfVsPt_Tot)/sumpT_HF;
	hSub_vs_SumpT[cBin]->Fill(sumpT_HF,pfPt_Tot-pfVsPt_Tot);
	hSub_vs_SumpT[nbins_cent]->Fill(sumpT_HF,pfPt_Tot-pfVsPt_Tot);

	hVsAngle_EP[0][cBin]->Fill(Vs_2_angle,2*data[k][h]->hiEvtPlanes[21]);
	hVsAngle_EP[1][cBin]->Fill(Vs_3_angle,3*data[k][h]->hiEvtPlanes[24]);
	hVsAngle_EP[2][cBin]->Fill(Vs_4_angle,4*data[k][h]->hiEvtPlanes[27]);

	hVsAngle_EP[0][nbins_cent]->Fill(Vs_2_angle,2*data[k][h]->hiEvtPlanes[21]);
	hVsAngle_EP[1][nbins_cent]->Fill(Vs_3_angle,3*data[k][h]->hiEvtPlanes[24]);
	hVsAngle_EP[2][nbins_cent]->Fill(Vs_4_angle,4*data[k][h]->hiEvtPlanes[27]);

	//getting the event plane information for the Official and Vs calculations. 
	/*
	hEP_HF_Official[0][0][cBin]->Fill(data[k][h]->hiEvtPlanes[21],scale*weight_vz*weight_cent);
	hEP_HF_Official[0][1][cBin]->Fill(data[k][h]->hiEvtPlanes[22],scale*weight_vz*weight_cent);
	hEP_HF_Official[0][2][cBin]->Fill(data[k][h]->hiEvtPlanes[23],scale*weight_vz*weight_cent);

	hEP_HF_Official[1][0][cBin]->Fill(data[k][h]->hiEvtPlanes[24],scale*weight_vz*weight_cent);
	hEP_HF_Official[1][1][cBin]->Fill(data[k][h]->hiEvtPlanes[25],scale*weight_vz*weight_cent);
	hEP_HF_Official[1][2][cBin]->Fill(data[k][h]->hiEvtPlanes[26],scale*weight_vz*weight_cent);

	hEP_HF_Official[2][0][cBin]->Fill(data[k][h]->hiEvtPlanes[27],scale*weight_vz*weight_cent);
	hEP_HF_Official[2][1][cBin]->Fill(data[k][h]->hiEvtPlanes[28],scale*weight_vz*weight_cent);
	hEP_HF_Official[2][2][cBin]->Fill(data[k][h]->hiEvtPlanes[29],scale*weight_vz*weight_cent);

	hEP_HF_Vs[0][0][cBin]->Fill(data[k][h]->psi_n[2][0],scale*weight_vz*weight_cent);
	hEP_HF_Vs[0][0][cBin]->Fill(data[k][h]->psi_n[2][14],scale*weight_vz*weight_cent);
	hEP_HF_Vs[0][1][cBin]->Fill(data[k][h]->psi_n[2][0],scale*weight_vz*weight_cent);
	hEP_HF_Vs[0][2][cBin]->Fill(data[k][h]->psi_n[2][14],scale*weight_vz*weight_cent);

	hEP_HF_Vs[1][0][cBin]->Fill(data[k][h]->psi_n[3][0],scale*weight_vz*weight_cent);
	hEP_HF_Vs[1][0][cBin]->Fill(data[k][h]->psi_n[3][14],scale*weight_vz*weight_cent);
	hEP_HF_Vs[1][1][cBin]->Fill(data[k][h]->psi_n[3][0],scale*weight_vz*weight_cent);
	hEP_HF_Vs[1][2][cBin]->Fill(data[k][h]->psi_n[3][14],scale*weight_vz*weight_cent);

	hEP_HF_Vs[2][0][cBin]->Fill(data[k][h]->psi_n[4][0],scale*weight_vz*weight_cent);
	hEP_HF_Vs[2][0][cBin]->Fill(data[k][h]->psi_n[4][14],scale*weight_vz*weight_cent);
	hEP_HF_Vs[2][1][cBin]->Fill(data[k][h]->psi_n[4][0],scale*weight_vz*weight_cent);
	hEP_HF_Vs[2][2][cBin]->Fill(data[k][h]->psi_n[4][14],scale*weight_vz*weight_cent);
	
	hEP_HF[0][0][cBin]->Fill(data[k][h]->hiEvtPlanes[21],data[k][h]->psi_n[2][0],scale*weight_vz*weight_cent);
	hEP_HF[0][0][cBin]->Fill(data[k][h]->hiEvtPlanes[21],data[k][h]->psi_n[2][14],scale*weight_vz*weight_cent);
	hEP_HF[0][1][cBin]->Fill(data[k][h]->hiEvtPlanes[22],data[k][h]->psi_n[2][0],scale*weight_vz*weight_cent);
	hEP_HF[0][2][cBin]->Fill(data[k][h]->hiEvtPlanes[23],data[k][h]->psi_n[2][14],scale*weight_vz*weight_cent);

	hEP_HF[1][0][cBin]->Fill(data[k][h]->hiEvtPlanes[24],data[k][h]->psi_n[3][0],scale*weight_vz*weight_cent);
	hEP_HF[1][0][cBin]->Fill(data[k][h]->hiEvtPlanes[24],data[k][h]->psi_n[3][14],scale*weight_vz*weight_cent);
	hEP_HF[1][1][cBin]->Fill(data[k][h]->hiEvtPlanes[25],data[k][h]->psi_n[3][0],scale*weight_vz*weight_cent);
	hEP_HF[1][2][cBin]->Fill(data[k][h]->hiEvtPlanes[26],data[k][h]->psi_n[3][14],scale*weight_vz*weight_cent);

	hEP_HF[2][0][cBin]->Fill(data[k][h]->hiEvtPlanes[27],data[k][h]->psi_n[4][0],scale*weight_vz*weight_cent);
	hEP_HF[2][0][cBin]->Fill(data[k][h]->hiEvtPlanes[27],data[k][h]->psi_n[4][14],scale*weight_vz*weight_cent);
	hEP_HF[2][1][cBin]->Fill(data[k][h]->hiEvtPlanes[28],data[k][h]->psi_n[4][0],scale*weight_vz*weight_cent);
	hEP_HF[2][2][cBin]->Fill(data[k][h]->hiEvtPlanes[29],data[k][h]->psi_n[4][14],scale*weight_vz*weight_cent);
	*/
	
	float sumpTtotal = 0;
	for(int a = 0;a<15;a++){
	  
	  //hSumpTvsHF[a]->Fill(data[k][h]->sumpT[a],data[k][h]->hiHF,scale*weight_vz*weight_cent);
	  //hSumpTvshiBin[a]->Fill(data[k][h]->sumpT[a],data[k][h]->bin,scale*weight_vz*weight_cent);
	  sumpTtotal+= data[k][h]->sumpT[a];
	  //for(int b = 0;b<5;b++){
	    
	  //  hPsivsHF[b][a]->Fill(data[k][h]->psi_n[b][a],data[k][h]->hiHF,scale*weight_vz*weight_cent);
	  //  hvnvsHF[b][a]->Fill(data[k][h]->v_n[b][a],data[k][h]->hiHF,scale*weight_vz*weight_cent);
	    //hPsi[cBin]->Fill(data[k][h]->psi_n[b][a]);
	  
	  //}// no of flow components 
	}// eta bin

	//Float_t sumpT_HF = data[k][h]->sumpT[0] + data[k][h]->sumpT[14];
	Float_t sumpT_noHF = 0;

	for(int a = 1;a<14;a++){
	  sumpT_noHF+= data[k][h]->sumpT[a];
	}
	
	hNJetsvsSumpT[cBin]->Fill(jetCounter,sumpTtotal,scale*weight_vz*weight_cent);
	hNJetsvsSumpT[nbins_cent]->Fill(jetCounter,sumpTtotal,scale*weight_vz*weight_cent);
	hNJetsvsSumpT_noHF[cBin]->Fill(jetCounter,sumpT_noHF,scale*weight_vz*weight_cent);
	hNJetsvsSumpT_noHF[nbins_cent]->Fill(jetCounter,sumpT_noHF,scale*weight_vz*weight_cent);
	hNJetsvsSumpT_HF[cBin]->Fill(jetCounter,sumpT_HF,scale*weight_vz*weight_cent);
	hNJetsvsSumpT_HF[nbins_cent]->Fill(jetCounter,sumpT_HF,scale*weight_vz*weight_cent);
	
	hSumpTvsHF_cent[cBin]->Fill(sumpTtotal,data[k][h]->hiHF,scale*weight_vz*weight_cent);
	hSumpTvsHF_cent[nbins_cent]->Fill(sumpTtotal,data[k][h]->hiHF,scale*weight_vz*weight_cent);
	//hSumpTvshiBin_cent[cBin]->Fill(data[k][h]->sumpT[a],data[k][h]->hiHF);
	hSumpT[cBin]->Fill(sumpTtotal,scale*weight_vz*weight_cent);
	hSumpT[nbins_cent]->Fill(sumpTtotal,scale*weight_vz*weight_cent);
       
	
      }// event entry loop

    }// pthat loop

  }// radius loop

  TFile fout(Form("/net/hisrv0001/home/rkunnawa/WORK/RAA/CMSSW_5_3_20/src/Output/PbPb_MC_HFVsValidation_total_histograms_ak%s%s_%d.root",algo,jet_type,date.GetDate()),"RECREATE");
  fout.cd();

  for(int i = 0;i<=nbins_cent;i++){
    hNJetsvsSumpT[i]->Write();
    hNJetsvsSumpT_noHF[i]->Write();
    hNJetsvsSumpT_HF[i]->Write();
    hSumpTvsHF_cent[i]->Write();
    hSumpT[i]->Write();
    hAngle_2_HF_Vs[i]->Write();
    hAngle_3_HF_Vs[i]->Write();
    hAngle_4_HF_Vs[i]->Write();
    hMagnitude_2_HF_Vs[i]->Write();
    hMagnitude_3_HF_Vs[i]->Write();
    hMagnitude_4_HF_Vs[i]->Write();
    hSub_vs_SumpT[i]->Write();
    hVsAngle_EP[0][i]->Write();
    hVsAngle_EP[1][i]->Write();
    hVsAngle_EP[2][i]->Write();
  }

}
//GetBEfficiency input histograms for pt binned only (1d), pt and eta binned (2d), pt binned in eta slices (1d)
void GetBEfficiency_InputHistograms(){
	gROOT->ProcessLine(".x SetStyle_PRD.C");

	gROOT->SetStyle("Plain");
	gStyle->SetOptStat(0);

	bool runQCD   = false;//set false if want to save some time //useful if look at high MT2
	bool onlyQCD  = false;//set false if want to save some time //useful if look at high MT2
	bool calcsusy = true;//at the moment has no genflavour // skip it
	bool runData  = false;//set false if want to save some time //at the moment not used, only for xchecks

	bool fHT      = true;//to change  htskim
	bool fMET     = false; //to change metskim
	bool fChange  = true; //use this only if you want to change the skims by hand

	//not implemented here, yet
	bool ttbarxsecup   = false;
	bool ttbarxsecdown = false;
	bool wjetsxsecup   = false;
	bool wjetsxsecdown = false;

//	TString samples         = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_Stop_53X_0bMET30_corr.dat";//Dileptons
//	TString samples         = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_type1MET_CHS_53X_MET.dat";//MET
//	TString samples         = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_type1MET_CHS_53X_HT.dat";//HT
//	TString samples         = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_type1MET_CHS_53X_MET_newTTbar.dat";//MET
	TString samples         = "/dataLOCAL/paktinat/Projects/MT2/MT2_V02-03-02/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samplesMine.dat";//HT
//	TString samples         = "/shome/haweber/MT2Analysis_8TeV/Code/MT2AnalysisCode/RootMacros/samples/samples_type1MET_CHS_53X_METorHT.dat";//HT
	TString outputdir 	= "/dataLOCAL/paktinat/Projects/MT2/MT2_V02-03-02/MT2Analysis/Code/Efficiencies/InputHistos/";//if not empty end with slash
//	TString outputdir 	= "/shome/haweber/MT2Analysis_8TeV/Code/Efficiencies/test/InputHistos/";//if not empty end with slash
	Util::MakeOutputDir(outputdir);
//	TString outputname 	= "BEfficiencies_histos_DileptonicStop_CSVM.root";
//	TString outputname 	= "BEfficiencies_histos_ge2jets_0l_CSVM_HT750orMET200_MinDPhiPt40_noQCD.root";
//	TString outputname 	= "BEfficiencies_histos_ge2jets_0l_CSVM_HT750orMET200_MinDPhi4_noQCD.root";
//	TString outputname 	= "BEfficiencies_histos_ge2jets_CSVM_HT750orMET200_MinDPhiPt40_noQCD.root";
//	TString outputname 	= "BEfficiencies_histos_ge2jets_CSVM_HT750orMET200_MinDPhi4.root";
//	TString outputname 	= "BEfficiencies_histos_ge2jets_CSVM_HT450andMET200_MinDPhi4_newTTbar.root";
	TString outputname 	= "BEfficiencies_histos_ge2jets_CSVM_HT750andMET30_MinDPhi4_newTTbar_noQCD.root";

//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_0l_CSVM_allMT2_MinDPhi40.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_0l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_ge1l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge6jets_0l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge6jets_ge1l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_HT_eq2jets_0l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_HT_eq2jets_ge1l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_0l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_ge1l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge6jets_0l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge6jets_ge1l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_eq2jets_0l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_eq2jets_ge1l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_0l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge3jets_ge1l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge6jets_0l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_ge6jets_ge1l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_eq2jets_0l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_HT_eq2jets_ge1l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge3jets_0l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge3jets_ge1l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge6jets_0l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge6jets_ge1l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_MET_eq2jets_0l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_MET_eq2jets_ge1l_CSVM_allMT2.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge3jets_0l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge3jets_ge1l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge6jets_0l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge6jets_ge1l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_eq2jets_0l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_eq2jets_ge1l_CSVM_MT2lt125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge3jets_0l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge3jets_ge1l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge6jets_0l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_ge6jets_ge1l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_eq2jets_0l_CSVM_MT2ge125.root";
//	TString outputname 	= "BEfficiencies_histos_MET_eq2jets_ge1l_CSVM_MT2ge125.root";

	int btaggername = 4; //0: TCHE, 1: TCHP, 2: SSVHE, 3: SSVHP, 4: CSV, 5: JP
	//CSV: L: 0.244, M: 0.679, T: 0.898
	//JP:  L: 0.275, M: 0.545, T: 0.790
	//TCHPT: 3.41, SSVHEM: 1.74, SSVHPT: 2.00
	double bdiscr_value = 0.679;
	int WP = 1;// WP: 0: loose, 1: medium, 2: tight
	double bpt = 20.;
	double beta = 2.4;
	const int Nptbins   = 17; double ptbins[Nptbins+1]     = {20, 30, 40, 50, 60, 70, 80, 100, 120, 160, 210, 260, 320, 400, 500, 600, 800, 1000};
//	const int Nptbins   = 16; double ptbins[Nptbins+1]     = {20, 30, 40, 50, 60, 70, 80, 100, 120, 160, 210, 260, 320, 400, 500, 670, 750};
	const int NetabinsL =  4; double etabinsL[NetabinsL+1] = {0.0, 0.5, 1.0, 1.5, 2.4};
	const int NetabinsM =  3; double etabinsM[NetabinsM+1] = {0.0, 0.8, 1.6, 2.4};
	const int NetabinsT =  1; double etabinsT[NetabinsT+1] = {0.0, 2.4};

	map<string, TH2D*> histos2d;
	map<string, TH1D*> histospt;

	const int sampletypesize = 10;
	string sample_type[sampletypesize] = {"QCD", "WJets", "ZJets", "TTbar", "SingleTop", "Other", "mc", "mcNOqcd", "susy", "data"};//same as type in samples.dat

	const int prefixsize = 10;
	string prefix[10] = {"B", "C", "L", "NonB", "All", "BTaggedB", "BTaggedC", "BTaggedL", "BTaggedNonB", "BTaggedAll"};


	for(int is = 0; is<sampletypesize; ++is){
	   for(int js = 0; js<10; ++js){
		string hs = string("_") + sample_type[is];
		string mapname;
		mapname = prefix[js] + "Jet" + hs;
		if(WP==0 && histos2d.count(mapname) == 0 ) histos2d[mapname] = new TH2D((mapname+string("_2d")).c_str(), "eff", Nptbins, ptbins, NetabinsL, etabinsL);
		if(WP==1 && histos2d.count(mapname) == 0 ) histos2d[mapname] = new TH2D((mapname+string("_2d")).c_str(), "eff", Nptbins, ptbins, NetabinsM, etabinsM);
		if(WP==2 && histos2d.count(mapname) == 0 ) histos2d[mapname] = new TH2D((mapname+string("_2d")).c_str(), "eff", Nptbins, ptbins, NetabinsT, etabinsT);
		if(         histospt.count(mapname) == 0 ) histospt[mapname] = new TH1D( mapname.c_str(),                "eff", Nptbins, ptbins);
	   }
	}
	
	for(map<string,TH2D*>::iterator h=histos2d.begin(); h!=histos2d.end();++h){
		//cout << "Load " << h->first << endl;
		h->second->Sumw2();}
	for(map<string,TH1D*>::iterator h=histospt.begin(); h!=histospt.end();++h){
		//cout << "Load " << h->first << endl;
		h->second->Sumw2();}

	cout << "Histograms loaded" << endl;
	
	std::ostringstream cutStream;
	cutStream       << " " 	  
     << "(misc.ProcessID!=6||(misc.Event!=1689009&&misc.Event!=2275452&&misc.Event!=1946785&&misc.Event!=1936763&&misc.Event!=1890738&&misc.Event!=1757319))" << "&&" //summer QCD 53X
     << "(misc.ProcessID!=10||(Susy.MassChi==350&&Susy.MassLSP==50))" << "&&" // T2bb M_stop = 350, M_lsp = 50
 //    << "(misc.ProcessID!=10||(Susy.MassChi==600&&Susy.MassLSP==50))" << "&&" // T2bb M_stop = 600, M_lsp = 50

//	  << "misc.MT2 >=0"                                      << "&&" 
//	  << "misc.MT2 < 125"                                    << "&&" 
//	  << "misc.MT2 >=125"                                    << "&&" 
	  << "misc.MET>=30"                                      << "&&"
	  << "misc.HT>=450"                                      << "&&"
	  << "misc.Jet0Pass ==1"                                 << "&&"
	  << "misc.Jet1Pass ==1"                                 << "&&"
//	  << "misc.SecondJPt  >100"                              << "&&"
	  << "misc.PassJetID ==1"                                << "&&"
	  << "misc.Vectorsumpt < 70"                             << "&&"
//	  << "(NJetsIDLoose40 +NEles +NMuons)>=3"                << "&&"
	  << "misc.MinMetJetDPhi4>0.3"                           << "&&"
//	  << "misc.MinMetJetDPhiPt40>0.3"                        << "&&"
//        << "NBJetsCSVM     >=1"                                << "&&"
//        JetSkim
	  << "NJetsIDLoose40 >=2"                                << "&&"
//	  << "NJetsIDLoose40 >=3"                                << "&&"
//	  << "NJetsIDLoose40 >=6"                                << "&&"
//	  << "NJetsIDLoose40 ==2"                                << "&&"
//        HTskim
//	  << "misc.HT >=750"                                     << "&&" 
//        METskim
//	  << "misc.MET >=200"                                    << "&&"
//	  LeptonSkim
//	  << "(NEles+NMuons) ==0"                                << "&&"
//	  << "(NEles+NMuons) >=1"                                << "&&"
// Stop Skim -------------------------
//	  << "NJetsIDLoose40 >=2"                                << "&&"
//        << "(NEles+NMuons) >=2"                                << "&&"
//        << "NBJetsCSVM     >=1"                                << "&&"
//	  << "NJetsIDLoose40 >=3"                                << "&&" 
// Noise -- first 6 are official filters
	  << "( misc.ProcessID==10 || misc.HBHENoiseFlag == 0)"  << "&&"
	  << "misc.CSCTightHaloIDFlag == 0"                      << "&&"
	  << "(misc.ProcessID==10||misc.hcalLaserEventFlag==0)"  << "&&"
//	  << "(misc.isFastSim || misc.HBHENoiseFlag == 0)"       << "&&"
//	  << "(misc.isFastSim || misc.CSCTightHaloIDFlag == 0)"  << "&&"
//	  << "(misc.isFastSim || misc.hcalLaserEventFlag == 0)"  << "&&"
	  << "misc.trackingFailureFlag == 0"                     << "&&"
	  << "misc.eeBadScFlag == 0"                             << "&&"
	  << "misc.EcalDeadCellTriggerPrimitiveFlag == 0";

	TString cuts = cutStream.str().c_str();
/*
	std::ostringstream triggerStreamEE;
	triggerStreamEE << "( "
	  << "(trigger.HLT_DiElectrons==1)" << " )";
	TString triggerEE = triggerStreamEE.str().c_str();
	std::ostringstream triggerStreamEMu;
	triggerStreamEMu << "( "
	  << "(trigger.HLT_EMu==1)" << " )";
	TString triggerEMu = triggerStreamEMu.str().c_str();
	std::ostringstream triggerStreamMuMu;
	triggerStreamMuMu << "( "
	  << "(trigger.HLT_DiMuons==1)" << " )";
	TString triggerMuMu = triggerStreamMuMu.str().c_str();
*//*
	std::ostringstream triggerStream;
	triggerStream << "( "
			<< "trigger.HLT_PFHT650_v5 == 1 || trigger.HLT_PFHT650_v6 == 1 || trigger.HLT_PFHT650_v7 == 1 || "
			<< "trigger.HLT_PFHT650_v8 == 1 || trigger.HLT_PFHT650_v9 == 1 || "
			<< "trigger.HLT_PFNoPUHT650_v1 == 1 || trigger.HLT_PFNoPUHT650_v3 == 1)";
	
	TString trigger = triggerStream.str().c_str();
*/
	std::ostringstream triggerStream;
	triggerStream << "( "
			<< "trigger.HLT_PFMET150_v2 == 1 || trigger.HLT_PFMET150_v3 == 1 || trigger.HLT_PFMET150_v4 == 1 || "
			<< "trigger.HLT_PFMET150_v5 == 1 || trigger.HLT_PFMET150_v6 == 1 || trigger.HLT_PFMET150_v7 == 1 )";
	TString trigger = triggerStream.str().c_str();
  

	load(samples.Data());

	for(size_t i = 0; i < fSamples.size(); ++i){

   	    if(runData==false && fSamples[i].type=="data") continue;
	    if(calcsusy==false && fSamples[i].type=="susy") continue;
	    if(runQCD==false   && fSamples[i].sname=="QCD") continue;
	    if(onlyQCD==true   && fSamples[i].sname!="QCD" && runQCD) continue;

	    string sampletype = (string)fSamples[i].type;
	    bool METskim = false;
	    bool HTskim  = false;
	    TString path = fSamples[i].file->GetName();
	    if(path.Contains("METskim")) METskim = true;
	    if(path.Contains("HTskim"))  HTskim  = true;
	    if(fChange){
		if(fHT)  { HTskim = true;  METskim = false; }
		if(fMET) { HTskim = false; METskim = true;  }
	    	if(!(fMET || fHT)) { HTskim = false; METskim = false; }
	    }
//		cout << true << " " << path << " " << METskim << " " << HTskim << endl;
	    if(!(METskim || HTskim)) continue;
	    if(sampletype==(string)"mc"){
		if(fSamples[i].sname=="QCD") sampletype = (string)fSamples[i].sname;
		else if(fSamples[i].sname=="Wtolnu") sampletype = (string)"WJets";
		else if(fSamples[i].sname=="DY")     sampletype = (string)"ZJets";
		else if(fSamples[i].name=="TTbar")   sampletype = (string)"TTbar";
		else if(fSamples[i].name=="TTbar_Had")   sampletype = (string)"TTbar";
		else if(fSamples[i].name=="TTbar_SemiLep")   sampletype = (string)"TTbar";
		else if(fSamples[i].name=="TTbar_FullyLep")   sampletype = (string)"TTbar";
		else if(fSamples[i].sname=="TTbarV") sampletype = (string)"TTbar";
		else if(fSamples[i].sname=="Top")    sampletype = (string)"SingleTop";//no ttbar
		//else if(fSamples[i].sname=="VV" || fSamples[i].sname=="VVV") sampletype = (string)"VV/VVV";
		else sampletype = (string)"Other";
	    }
	//    if(sampletype==(string)"susy") sampletype=(string)"Stop";

	    Double_t sample_weight = fSamples[i].xsection * fSamples[i].kfact * fSamples[i].lumi / (fSamples[i].nevents);
	    if(fVerbose>2) cout << "B-Efficiency: looping over " << fSamples[i].name << endl;
	    if(fVerbose>2) cout << "              sample has weight " << sample_weight << " and " << fSamples[i].tree->GetEntries() << " entries" << endl; 
	    if(fVerbose>2 && fSamples[i].tree->GetEntries()==0) cout << "skip sample, has no entries" << endl;
            if(fSamples[i].tree->GetEntries()==0) continue;
	    MT2tree* fMT2tree = new MT2tree();
	    fSamples[i].tree->SetBranchAddress("MT2tree", &fMT2tree);
	    Long64_t nentries =  fSamples[i].tree->GetEntries();
	    Long64_t nbytes = 0, nb = 0;
	    int nev =0;

	    TString myCuts = cuts;
	    if(HTskim)  myCuts = myCuts + " && misc.HT>750";
	    if(METskim) myCuts = myCuts + " && misc.HT<=750 && misc.MET>200";//METskim excluding HTskim

	/*
	    if( fSamples[i].type=="data" && fSamples[i].sname=="EE-Data") { myCuts += " && " + triggerEE; }//cuts to be aplied only on data
	    else if( fSamples[i].type=="data" && fSamples[i].sname=="EMu-Data") { myCuts += " && " + triggerEMu; }//cuts to be aplied only on data
	    else if( fSamples[i].type=="data" && fSamples[i].sname=="MuMu-Data") { myCuts += " && " + triggerMuMu; } //cuts to be aplied only on data
	    else if(fSamples[i].type=="data") {cout << "data not usuable" << " type " << fSamples[i].type << " Sname " << fSamples[i].sname << endl; continue; }//not 
	*/
	    if( fSamples[i].type=="data") { myCuts += " && " + trigger; }

   	    cout << "Cuts for Flow: " << myCuts << endl;
   	    fSamples[i].tree->Draw(">>selList", myCuts);

	    TEventList *myEvtList = (TEventList*)gDirectory->Get("selList");

	    fSamples[i].tree->SetEventList(myEvtList);

	    int counter=0;
	    cout << "Filtering done, size=" <<myEvtList->GetN()  << endl;
	    if(myEvtList->GetSize()==0) continue;
        while(myEvtList->GetEntry(counter++) !=-1){	
      		int jentry = myEvtList->GetEntry(counter-1);
            
            nb =  fSamples[i].tree->GetEntry(jentry);   nbytes += nb;
            fSamples[i].tree->SetBranchAddress("MT2tree", &fMT2tree);
            
            if ( fVerbose>2 && counter % 50000 == 0 )  cout << "+++ Proccessing event " << counter << endl;


	    //if((fSamples[i].sname!="VVV"&&fSamples[i].sname!="TTbarV" && fSamples[i].type!="susy"&&sampletype!="Stop")  && fMT2tree->misc.HBHENoiseFlag!=0     ) continue;//test
	    //if((fSamples[i].sname!="VVV"&&fSamples[i].sname!="TTbarV" && fSamples[i].type!="susy"&&sampletype!="Stop")  && fMT2tree->misc.hcalLaserEventFlag!=0) continue;//test
            Double_t weight = sample_weight;
            if (!fMT2tree->misc.isData ) weight = weight * fMT2tree->pileUp.Weight; // pile-up reweighting for MC 
 /*           Bool_t recoedee   = false;// exact 2 ele, 0 muo
            Bool_t recoedemu  = false;// exact 1 ele, 1 muo
            Bool_t recoedmumu = false;// exact 0 ele, 2 muo
		//change this - might have some inefficiencies - three leptons with one not passing IDMedium==1
		//20-20 selection --> third lepton is 10 GeV 
            if(fMT2tree->NEles>=2 &&fMT2tree->ele[0].lv.Pt()>20&&fMT2tree->ele[1].lv.Pt()>20&&fMT2tree->ele[2].lv.Pt()<20&&(fMT2tree->NMuons==0||fMT2tree->muo[0].lv.Pt()<10) && fMT2tree->ele[0].IDMedium==1 && fMT2tree->ele[1].IDMedium==1) recoedee   = true;
            if(fMT2tree->NMuons>=2&&fMT2tree->muo[0].lv.Pt()>20&&fMT2tree->muo[1].lv.Pt()>20&&fMT2tree->muo[2].lv.Pt()<10&&(fMT2tree->NEles ==0||fMT2tree->ele[0].lv.Pt()<10)) recoedmumu = true;
            if(fMT2tree->NMuons>=1&&fMT2tree->muo[0].lv.Pt()>20&&fMT2tree->muo[1].lv.Pt()<10&&fMT2tree->NEles>=1 &&fMT2tree->ele[0].lv.Pt()>20&&fMT2tree->ele[1].lv.Pt()<10 && fMT2tree->ele[0].IDMedium==1) recoedemu  = true;//XXX change emu to 20/20 selection, left ee,mumu at 20/10 for now
	    //id cuts?

            Bool_t recoedosee   = false;// opposite sign
            Bool_t recoedosemu  = false;// opposite sign
            Bool_t recoedosmumu = false;// opposite sign
	    if(recoedee   && (fMT2tree->ele[0].Charge)*(fMT2tree->ele[1].Charge)==(-1)) recoedosee   = true;
	    if(recoedemu  && (fMT2tree->ele[0].Charge)*(fMT2tree->muo[0].Charge)==(-1)) recoedosemu  = true;
	    if(recoedmumu && (fMT2tree->muo[0].Charge)*(fMT2tree->muo[1].Charge)==(-1)) recoedosmumu = true;
            Bool_t recoedeenZ   = false;// off Z
            Bool_t recoedemunZ  = false;// off Z -> is not requirement, so this variable should be useless
            Bool_t recoedmumunZ = false;// off Z
	    if(recoedee   && ((fMT2tree->ele[0].lv + fMT2tree->ele[1].lv).M()<81 || (fMT2tree->ele[0].lv + fMT2tree->ele[1].lv).M()>101) ) recoedeenZ   = true;
	    if(recoedemu  && ((fMT2tree->ele[0].lv + fMT2tree->muo[0].lv).M()<81 || (fMT2tree->ele[0].lv + fMT2tree->muo[0].lv).M()>101) ) recoedemunZ  = true;
	    if(recoedmumu && ((fMT2tree->muo[0].lv + fMT2tree->muo[1].lv).M()<81 || (fMT2tree->muo[0].lv + fMT2tree->muo[1].lv).M()>101) ) recoedmumunZ = true;

	    if(!(recoedee)   && !(recoedemu)   && !(recoedmumu)  ) continue;//require dilepton
	    if(!(recoedosee) && !(recoedosemu) && !(recoedosmumu) ) continue;//require os-dilepton, maybe comment this for background est.

	    if(recoedee   && !(fMT2tree->misc.isData) ) weight = 0.960 * weight * 0.953366;//from SSb Florida
	    if(recoedemu  && !(fMT2tree->misc.isData) ) weight = 0.934 * weight;//from SSb Florida
	    if(recoedmumu && !(fMT2tree->misc.isData) ) weight = 0.875 * weight * 1.031213;//from SSb Florida
*/
	   	if(wjetsxsecup  ==true && fSamples[i].sname=="Wtolnu")	weight = weight*0.7;
	   	if(wjetsxsecdown==true && fSamples[i].sname=="Wtolnu")	weight = weight*1.3;
	   	if(ttbarxsecup  ==true && fSamples[i].name== "TTbar" )	weight = weight*0.85;
	   	if(ttbarxsecdown==true && fSamples[i].name== "TTbar" )	weight = weight*1.15;

		for(int k = 0; k<fMT2tree->NJets; ++k){
			if(fMT2tree->jet[k].isPFIDLoose==false) continue;
			if(fMT2tree->jet[k].Flavour<=-7777 && fMT2tree->misc.isData==false) continue;//MC sample veto if no btagging information
			if(abs(fMT2tree->jet[k].Flavour>100)) cout << "jet " << k << "has flavour " << fMT2tree->jet[k].Flavour << endl;
			float btagdiscr=-1;
			if(btaggername==0)      btagdiscr = fMT2tree->jet[k].bTagProbTCHE;
			else if(btaggername==1) btagdiscr = fMT2tree->jet[k].bTagProbTCHP;
			else if(btaggername==2) btagdiscr = fMT2tree->jet[k].bTagProbSSVHE;
			else if(btaggername==3) btagdiscr = fMT2tree->jet[k].bTagProbSSVHP;
			else if(btaggername==4) btagdiscr = fMT2tree->jet[k].bTagProbCSV;
			else if(btaggername==5) btagdiscr = fMT2tree->jet[k].bTagProbJProb;
			else                    btagdiscr = fMT2tree->jet[k].bTagProbCSV;
			float jetpt = fMT2tree->jet[k].lv.Pt();
			float jeteta= fabs(fMT2tree->jet[k].lv.Eta() );
			//float jetMT2= fMT2tree->misc.MT2;
			int jetabsflavour = abs(fMT2tree->jet[k].Flavour);
			if(jetpt<bpt)   continue;
			if(jeteta>beta) continue;
			histospt[string("AllJet_") + sampletype]->Fill(jetpt, weight );
			histos2d[string("AllJet_") + sampletype]->Fill(jetpt, jeteta, weight );
			if(jetabsflavour==5){
				histospt[string("BJet_") + sampletype]->Fill(jetpt, weight );
				histos2d[string("BJet_") + sampletype]->Fill(jetpt, jeteta, weight );
			}
			else if(jetabsflavour==4){
				histospt[string("CJet_") + sampletype]->Fill(jetpt, weight );
				histos2d[string("CJet_") + sampletype]->Fill(jetpt, jeteta, weight );
			}
			else{
				histospt[string("LJet_") + sampletype]->Fill(jetpt, weight );
				histos2d[string("LJet_") + sampletype]->Fill(jetpt, jeteta, weight );
			}
			if(btagdiscr>=bdiscr_value){
				histospt[string("BTaggedAllJet_") + sampletype]->Fill(jetpt, weight );
				histos2d[string("BTaggedAllJet_") + sampletype]->Fill(jetpt, jeteta, weight );
				if(jetabsflavour==5){
					histospt[string("BTaggedBJet_") + sampletype]->Fill(jetpt, weight );
					histos2d[string("BTaggedBJet_") + sampletype]->Fill(jetpt, jeteta, weight );
				}
				else if(jetabsflavour==4){
					histospt[string("BTaggedCJet_") + sampletype]->Fill(jetpt, weight );
					histos2d[string("BTaggedCJet_") + sampletype]->Fill(jetpt, jeteta, weight );
				}
				else{
					histospt[string("BTaggedLJet_") + sampletype]->Fill(jetpt, weight );
					histos2d[string("BTaggedLJet_") + sampletype]->Fill(jetpt, jeteta, weight );
				}
			}
		}//for(int k = 0; k<fMT2tree->NJets; ++k)
	   }
	   delete fMT2tree;
	}//for(size_t i = 0; i < fSamples.size(); ++i)

	cout << "add overflow bins" << endl;
	for(map<string,TH2D*>::iterator h=histos2d.begin(); h!=histos2d.end();++h){
		//there should not be any underflow, just look at overflow
		int nbinsx = h->second->GetNbinsX();
		int nbinsy = h->second->GetNbinsY();
		for(int ix = 1; ix<= nbinsx;++ix){
			h->second->SetBinContent(ix, nbinsy, 
						h->second->GetBinContent(ix,nbinsy) +
						h->second->GetBinContent(ix, nbinsy+1));
			h->second->SetBinError(ix, nbinsy, 
						sqrt(h->second->GetBinError(ix,nbinsy)*h->second->GetBinError(ix,nbinsy) +
						h->second->GetBinError(ix, nbinsy+1)*h->second->GetBinError(ix, nbinsy+1)) );
		}
		for(int iy = 1; iy<= nbinsy;++iy){
			h->second->SetBinContent(nbinsx, iy, 
						h->second->GetBinContent(nbinsx,iy) +
						h->second->GetBinContent(nbinsx+1, iy));
			h->second->SetBinError(nbinsx, iy, 
						sqrt(h->second->GetBinError(nbinsx,iy)*h->second->GetBinError(nbinsx,iy) +
						h->second->GetBinError(nbinsx+1, iy)*h->second->GetBinError(nbinsx+1, iy)) );
		}
		h->second->SetBinContent(nbinsx, nbinsy, 
						h->second->GetBinContent(nbinsx,nbinsy) +
						h->second->GetBinContent(nbinsx+1, nbinsy+1));
		h->second->SetBinError(nbinsx, nbinsy, 
					sqrt(h->second->GetBinError(nbinsx,nbinsy)*h->second->GetBinError(nbinsx,nbinsy) +
					h->second->GetBinError(nbinsx+1, nbinsy+1)*h->second->GetBinError(nbinsx+1, nbinsy+1)) );
	}
	for(map<string,TH1D*>::iterator h=histospt.begin(); h!=histospt.end();++h){
		//there should not be any underflow, just look at overflow
		int nbinsx = h->second->GetNbinsX();
		h->second->SetBinContent(nbinsx, h->second->GetBinContent(nbinsx) + h->second->GetBinContent(nbinsx+1));
		h->second->SetBinError(  nbinsx, h->second->GetBinError(nbinsx  )*h->second->GetBinError(nbinsx  ) +
                                                 h->second->GetBinError(nbinsx+1)*h->second->GetBinError(nbinsx+1) );
	}


	cout << "merge mc histograms into one" << endl;
	//fill mc histogram from the samples histograms
	for(int ists = 0; ists<sampletypesize; ++ists){
		if((sample_type[ists])==("data")) continue;
		if((sample_type[ists])==("susy")) continue;
		if((sample_type[ists])==("mc") ) continue;//have all mc subsamples only
		string helptype = string("_") + sample_type[ists];
		string helpmc = "_mc";
		string helpmcnoqcd = "_mcNOqcd";
		histospt[string("BJet")   + helpmc]->Add(histospt[string("BJet")   + helptype], 1.);
		histospt[string("CJet")   + helpmc]->Add(histospt[string("CJet")   + helptype], 1.);
		histospt[string("LJet")   + helpmc]->Add(histospt[string("LJet")   + helptype], 1.);
		histospt[string("AllJet") + helpmc]->Add(histospt[string("AllJet") + helptype], 1.);
		histos2d[string("BJet")   + helpmc]->Add(histos2d[string("BJet")   + helptype], 1.);
		histos2d[string("CJet")   + helpmc]->Add(histos2d[string("CJet")   + helptype], 1.);
		histos2d[string("LJet")   + helpmc]->Add(histos2d[string("LJet")   + helptype], 1.);
		histos2d[string("AllJet") + helpmc]->Add(histos2d[string("AllJet") + helptype], 1.);
		histospt[string("BTaggedBJet")   + helpmc]->Add(histospt[string("BTaggedBJet")   + helptype], 1.);
		histospt[string("BTaggedCJet")   + helpmc]->Add(histospt[string("BTaggedCJet")   + helptype], 1.);
		histospt[string("BTaggedLJet")   + helpmc]->Add(histospt[string("BTaggedLJet")   + helptype], 1.);
		histospt[string("BTaggedAllJet") + helpmc]->Add(histospt[string("BTaggedAllJet") + helptype], 1.);
		histos2d[string("BTaggedBJet")   + helpmc]->Add(histos2d[string("BTaggedBJet")   + helptype], 1.);
		histos2d[string("BTaggedCJet")   + helpmc]->Add(histos2d[string("BTaggedCJet")   + helptype], 1.);
		histos2d[string("BTaggedLJet")   + helpmc]->Add(histos2d[string("BTaggedLJet")   + helptype], 1.);
		histos2d[string("BTaggedAllJet") + helpmc]->Add(histos2d[string("BTaggedAllJet") + helptype], 1.);
		if(sample_type[ists]==string("QCD")) continue;
		histospt[string("BJet")   + helpmcnoqcd]->Add(histospt[string("BJet")   + helptype], 1.);
		histospt[string("CJet")   + helpmcnoqcd]->Add(histospt[string("CJet")   + helptype], 1.);
		histospt[string("LJet")   + helpmcnoqcd]->Add(histospt[string("LJet")   + helptype], 1.);
		histospt[string("AllJet") + helpmcnoqcd]->Add(histospt[string("AllJet") + helptype], 1.);
		histos2d[string("BJet")   + helpmcnoqcd]->Add(histos2d[string("BJet")   + helptype], 1.);
		histos2d[string("CJet")   + helpmcnoqcd]->Add(histos2d[string("CJet")   + helptype], 1.);
		histos2d[string("LJet")   + helpmcnoqcd]->Add(histos2d[string("LJet")   + helptype], 1.);
		histos2d[string("AllJet") + helpmcnoqcd]->Add(histos2d[string("AllJet") + helptype], 1.);
		histospt[string("BTaggedBJet")   + helpmcnoqcd]->Add(histospt[string("BTaggedBJet")   + helptype], 1.);
		histospt[string("BTaggedCJet")   + helpmcnoqcd]->Add(histospt[string("BTaggedCJet")   + helptype], 1.);
		histospt[string("BTaggedLJet")   + helpmcnoqcd]->Add(histospt[string("BTaggedLJet")   + helptype], 1.);
		histospt[string("BTaggedAllJet") + helpmcnoqcd]->Add(histospt[string("BTaggedAllJet") + helptype], 1.);
		histos2d[string("BTaggedBJet")   + helpmcnoqcd]->Add(histos2d[string("BTaggedBJet")   + helptype], 1.);
		histos2d[string("BTaggedCJet")   + helpmcnoqcd]->Add(histos2d[string("BTaggedCJet")   + helptype], 1.);
		histos2d[string("BTaggedLJet")   + helpmcnoqcd]->Add(histos2d[string("BTaggedLJet")   + helptype], 1.);
		histos2d[string("BTaggedAllJet") + helpmcnoqcd]->Add(histos2d[string("BTaggedAllJet") + helptype], 1.);

	}
	cout << "merge C and L histograms to NonB" << endl;
	for(int ists = 0; ists<sampletypesize; ++ists){
		string helptype = string("_") + sample_type[ists];
		histospt[string("NonBJet")   + helptype]->Add(histospt[string("CJet")   + helptype], 1.);
		histospt[string("NonBJet")   + helptype]->Add(histospt[string("LJet")   + helptype], 1.);
		histos2d[string("NonBJet")   + helptype]->Add(histos2d[string("CJet")   + helptype], 1.);
		histos2d[string("NonBJet")   + helptype]->Add(histos2d[string("LJet")   + helptype], 1.);
		histospt[string("BTaggedNonBJet")   + helptype]->Add(histospt[string("BTaggedCJet")   + helptype], 1.);
		histospt[string("BTaggedNonBJet")   + helptype]->Add(histospt[string("BTaggedLJet")   + helptype], 1.);
		histos2d[string("BTaggedNonBJet")   + helptype]->Add(histos2d[string("BTaggedCJet")   + helptype], 1.);
		histos2d[string("BTaggedNonBJet")   + helptype]->Add(histos2d[string("BTaggedLJet")   + helptype], 1.);
	}
	cout << "save histogram" << endl;
	TFile *fsavefile = new TFile(outputdir+outputname,"RECREATE");
	fsavefile->cd();
	for(map<string,TH2D*>::iterator h=histos2d.begin(); h!=histos2d.end();++h){
		h->second->Write();}
	for(map<string,TH1D*>::iterator h=histospt.begin(); h!=histospt.end();++h){
		h->second->Write();}
	fsavefile->Close();

	cout << "Saved histograms in " << outputdir << outputname << endl;

}//void GetBEfficiency_InputHistograms()
//call this macro via root -l -b -q AddBranchEventsMT2tree.C++
//This code takes a text file containing run:lumisection:event:taggervalue (tagger value is a new filter you want to add to your tree),
//an old MT2tree file that does not contain that tagger
// and creates a new MT2tree file, which is a copy of the old one and contains additionally that tagger.
void AddBranchEventsMT2tree() {
// Example of Root macro to copy a subset of a Tree to a new Tree
// Only selected entries are copied to the new Tree.
// The input file has been generated by the program in $ROOTSYS/test/Event
// with   Event 1000 1 99 1
//Author: Rene Brun
   
//modified: Hannsjoerg Weber, 28/08/2013

   //make cleaning
   // get eventlist to clean
   // vector contains <run, < <lumisection, event>, taggervalue > >
   vector<pair<pair<int,pair<int,int> >,float> > rls; rls.clear();
   char buffer[200];
   ifstream filterdat("/shome/haweber/AODFiles_MT2SR/taggerlist/ControlRegionSinglePhotonPart1.dat");
   while( filterdat.getline(buffer, 200, '\n') ){
	int rrun(-1), lls(-1), eevent(-1), d1(-1); float ttagger(-1);
	sscanf(buffer, "*\t%d\t*\t%d\t*\t%d\t*\t%d\t*\t%f", &d1, &eevent, &lls, &rrun, &ttagger);
	pair<int,int> t1(lls,eevent);
	pair<int,pair<int,int> > t2(rrun,t1);
        pair<pair<int,pair<int,int> >, float> t3(t2,ttagger);
	rls.push_back(t3);
   }
cout << "Events for filtering " << rls.size() << endl;

   // get the old rootfile including events that should be tagged and define new event file including tagger variable
   TString oldfilename = "/shome/haweber/MT2Analysis/MT2trees/MT2_V02-03-02/20130914_8TeV_1g_removed/lowHT/SinglePhoton-Run2012C-PromptReco-v2-2.root";
   TString newfilename = "/shome/haweber/MT2Analysis/MT2trees/MT2_V02-03-02/20130914_8TeV_1g_removed/lowHT/SinglePhoton-Run2012C-PromptReco-v2-2_Filter.root";

	// if you want to apply an additional event selection, define cuts here
	std::ostringstream cutStream;
	std::ostringstream cutStreamBase;
	cutStream << " " 
		<< "NTausIDLoose3Hits+NMuons+NEles==0"                   << "&&"
		<< "misc.Jet0Pass==1&&misc.Jet1Pass==1"                  << "&&"
		<< "misc.Vectorsumpt<70&& misc.MinMetJetDPhi4Pt40 >0.3";
		cutStream << "&&((misc.MET>200&&misc.HT<=750&&misc.HT>=450&&misc.MT2>200)||(misc.HT>750&&misc.MET>30&&misc.MT2>=100))";
	cutStreamBase << " " 
      << "misc.PassJet40ID ==1"                             << "&&"
      << "(misc.HBHENoiseFlag == 0 || misc.ProcessID==10)"  << "&&" // not there for fastsim (i.e. signal)
      << "misc.CSCTightHaloIDFlag == 0"                     << "&&"
      << "misc.trackingFailureFlag==0"                      << "&&"
      << "misc.eeBadScFlag==0"                              << "&&"
      << "misc.EcalDeadCellTriggerPrimitiveFlag==0"         << "&&"
      << "misc.TrackingManyStripClusFlag==0"                << "&&"
      << "misc.TrackingTooManyStripClusFlag==0"             << "&&"
      << "misc.TrackingLogErrorTooManyClustersFlag==0"      << "&&"
      << "misc.CrazyHCAL==0";

	TString cuts = cutStream.str().c_str();
	TString basecuts = cutStreamBase.str().c_str();
//	TString myCuts = cuts + "&&" + basecuts;// if cuts should be applied DO NOT comment this line
	TString myCuts = "";// if no cuts should be applied DO NOT comment this line

   //Get old file, old tree and set top branch address
   TFile *oldfile = new TFile(oldfilename.Data());
   TTree *oldtree = (TTree*)oldfile->Get("MassTree");

   MT2tree* fMT2tree = new MT2tree();
   oldtree->SetBranchAddress("MT2tree", &fMT2tree);
   Long64_t nentries =  oldtree->GetEntries();
   Long64_t nbytes = 0, nb = 0;
   int nev =0;

   //Create a new file + a clone of old tree in new file
   Float_t TOBTECTagger(-1);
   Float_t HOTagger(-1);
   Bool_t ExtraBeamHaloFilter(false);
   TFile *newfile = new TFile(newfilename.Data(),"RECREATE");
   TTree *newtree = oldtree->CloneTree(0);//clone all branches, but no event
   TBranch *newBranch  = newtree->Branch("TOBTECTagger", &TOBTECTagger, "TOBTECTagger/F");
   TBranch *newBranch2 = newtree->Branch("ExtraBeamHaloFilter", &ExtraBeamHaloFilter, "ExtraBeamHaloFilter/O");
   TBranch *newBranch3 = newtree->Branch("HOTagger", &HOTagger, "HOTagger/F");

   oldtree->Draw(">>selList", myCuts);
   TEventList *myEvtList = (TEventList*)gDirectory->Get("selList");
   oldtree->SetEventList(myEvtList);
   int counter=0;
   int numEvt = myEvtList->GetN();
   int printEvt = 100000;
   if(myEvtList->GetN()<1000000) printEvt = myEvtList->GetN()/25;
   cout << "Filtering done, size=" <<myEvtList->GetN()  << endl;
   while(myEvtList->GetEntry(counter++) !=-1){
	int jentry = myEvtList->GetEntry(counter-1);
	nb =  oldtree->GetEntry(jentry);   nbytes += nb;
	oldtree->SetBranchAddress("MT2tree", &fMT2tree);
	if(counter%printEvt==0) cout << "Process event " << counter << endl;	

	//make cleaning
	bool keep = true;
	int p=-1;
	for(int nn=0; nn<rls.size();++nn){
		if((rls[nn].first).first!=fMT2tree->misc.Run) continue; // --> run over matching 
		if(((rls[nn].first).second).first!=fMT2tree->misc.LumiSection) continue; // --> LS over matching 
		if(fMT2tree->misc.Event>0){
			if(((rls[nn].first).second).second==fMT2tree->misc.Event) { 
				TOBTECTagger = rls[nn].second;
				keep=false; p=nn; break;
			}
		}
		else{	//if event > INT_MAX correct overflow back.
			int evtt = ((rls[nn].first).second).second + INT_MAX;
			evtt = evtt - INT_MAX;
			if(evtt==fMT2tree->misc.Event) {keep=false; p=nn; break;}
		}
	}
	//two additional taggers
	bool beamhalo = false;
	float ho = fMT2tree->misc.MET/fMT2tree->misc.CaloMETRaw;
	if(fMT2tree->misc.CaloMETRaw<=0) ho=999.;
	HOTagger = ho;
	if(fMT2tree->jet[0].lv.DeltaPhi(fMT2tree->jet[1].lv)<0.2 && !(fMT2tree->jet[0].isPFIDMedium)) beamhalo = true;
	ExtraBeamHaloFilter = beamhalo;

	if(keep) TOBTECTagger = -1;
	newtree->Fill();
	if(!keep){
		//remove event from rls vector --> increases speed.
		int tt = p;
		rls.erase(rls.begin()+p);
	}
   }
   newtree->Print();
   newtree->AutoSave();
   delete oldfile;
   delete newfile;
}
Exemple #20
0
void KVEventListMaker::Process(){

if (!IsReady()) return;

//open file where tree is stored
TFile *file = new TFile(GetFileName().Data(),"update");
KVList *kevtlist = new KVList(); 

TTree *tt = NULL;

//just count the number of branches
KVString lname = GetBranchName();
Int_t  nbre=0;
lname.Begin(" ");
while (!lname.End()) {KVString stamp=lname.Next(); nbre+=1;}
if (nbre==0) return;

Int_t *variable = new Int_t[nbre];
KVString evtname;
Bool_t ok=kFALSE;
//check if the tree are there
if ( (tt = (TTree *)file->Get(GetTreeName().Data())) ){
	Int_t nentries = tt->GetEntries();
	printf("nbre d entree %d\n",nentries);
	TBranch* bb = NULL;
	
	nbre=0;
	lname.Begin(" ");
	//loop on branche names validity, if there is one wrong name
	//the program will exit
	while (!lname.End()) {
		KVString stamp = lname.Next();
		if ( (bb = tt->GetBranch(stamp.Data())) ){
			tt->SetBranchAddress(stamp.Data(),&variable[nbre]);
			nbre+=1;
			ok=kTRUE;
		}
	}

	if (!ok) return;
	
	TEventList *el = NULL;
	//loop on tree entries
	for (Int_t kk=0;kk<nentries;kk+=1){
		if (kk%10000==0) printf("%d evts lus\n",kk);

		tt->GetEntry(kk);
		evtname="";
		nbre=0;
		lname.Begin(" ");
		//compute the name of the TEventList
		//using branch name and branch value
		while (!lname.End()) {
			KVString stamp = lname.Next();
			if ( (bb = tt->GetBranch(stamp.Data())) ){
				KVString val; val.Form("%s_%d_",stamp.Data(),variable[nbre]);
				evtname+=val;
				nbre+=1;
			}
		}
		
		if ( !(el = (TEventList *)kevtlist->FindObject(evtname.Data())) ){
			printf("creation de %s \n",evtname.Data());
			kevtlist->Add(new TEventList(evtname.Data()));
			el = (TEventList *)kevtlist->Last();
		}
		el->Enter(kk);
	}
		
	//write TEventList created
	if (ktag_tree){
		for (Int_t nn=0;nn<kevtlist->GetEntries();nn+=1){
			KVString tampname;
			tampname.Form("%s_%s",GetTreeName().Data(),kevtlist->At(nn)->GetName());
			((TEventList*) kevtlist->At(nn))->SetName(tampname.Data());
			kevtlist->At(nn)->Write();
		}
	}
	else {	
		kevtlist->Write();
	}	
}
else printf("%s n existe pas\n",GetTreeName().Data());

delete [] variable;
//close the file
file->Close();

}
Exemple #21
0
void listMatchedEvents(std::string fullPath, bool matchesonly = false)
{
    // Essentially a sort of diff for reco and gen tree
    // May get slow for large trees as the search for the matching entry in the second tree
    // traverses the whole tree. This is because for merged trees the order is not guaranteed
    const int fVerbose(1);
    // Open file
    TFile *f = TFile::Open(fullPath.c_str());
    if (f==0)
    {
	cout << "File " << fullPath << " not found -- exiting" << endl;
	return;
    }
    if(fVerbose>0)
	cout << "Succesfully opened file " << fullPath << endl;
    // Get TTree with GenEvents
    TTree* tgen = (TTree*) f->Get("genevents");
    if(fVerbose>0) cout << "Got TTree with " << tgen->GetEntries() << " entries" << endl;
    // Do a cut, if needed
    //tgen->Draw(">>lst","ptmu1>3&&ptmu2>3&&TMath::Abs(etamu1)<2.5&&TMath::Abs(etamu2)<2.5");
    tgen->Draw(">>lst","");
    TEventList *lst;
    lst = (TEventList*)gDirectory->Get("lst");
    tgen->SetEventList(lst);
    if(fVerbose>0) cout << " After cuts: " << lst->GetN() << " entries" << endl;

    // Get TTree with iRecoEvents
    TTree* treco = (TTree*) f->Get("events");
    if(fVerbose>0) cout << "Got TTree with " << treco->GetEntries() << " entries" << endl;

    // set branch addresses
    int genrun, genls, genevt;
    tgen->SetBranchAddress("run",&genrun);
    tgen->SetBranchAddress("LS",&genls);
    tgen->SetBranchAddress("event",&genevt);

    int recorun, recols, recoevt;
    treco->SetBranchAddress("run",&recorun);
    treco->SetBranchAddress("LS",&recols);
    treco->SetBranchAddress("event",&recoevt);

    int mcmatch;
    treco->SetBranchAddress("isMCmatch",&mcmatch);

    double ptmu1, ptmu2, ptpr, ptpi;
    tgen->SetBranchAddress("ptmu1",&ptmu1);
    tgen->SetBranchAddress("ptmu2",&ptmu2);
    tgen->SetBranchAddress("ptpr",&ptpr);
    tgen->SetBranchAddress("ptpi",&ptpi);
    double etamu1, etamu2, etapr, etapi;
    tgen->SetBranchAddress("etamu1",&etamu1);
    tgen->SetBranchAddress("etamu2",&etamu2);
    tgen->SetBranchAddress("etapr",&etapr);
    tgen->SetBranchAddress("etapi",&etapi);
    double phimu1, phimu2, phipr, phipi;
    tgen->SetBranchAddress("phimu1",&phimu1);
    tgen->SetBranchAddress("phimu2",&phimu2);
    tgen->SetBranchAddress("phipr",&phipr);
    tgen->SetBranchAddress("phipi",&phipi);

    cout << "#      run         LS      event     genidx    recoidx" << endl;
    cout << "---------- ---------- ---------- ---------- ----------" << endl;

    TLorentzVector tlvmu1, tlvmu2, tlvpr, tlvpi;
    tmph1 = new TH1F ("tmph1","tmphisto",20,3.096,3.098);
    tmph2 = new TH1F ("tmph2","tmphisto",20,1.112,1.120);
    tmph3 = new TH1F ("tmph3","tmphisto",20,5.61,5.64);
    tmph4 = new TH2F ("tmph4","tmphisto",20,0,5,20,-2,8);

    // outer loop on gen events
    for (int i=0; i!=lst->GetN(); i++)
    {
	tgen->GetEntry(lst->GetEntry(i));
	tlvmu1.SetPtEtaPhiM(ptmu1,etamu1,phimu1,0.105658367);
	tlvmu2.SetPtEtaPhiM(ptmu2,etamu2,phimu2,0.105658367);
	tlvpr.SetPtEtaPhiM( ptpr, etapr, phipr ,0.938272013);
	tlvpi.SetPtEtaPhiM( ptpi, etapi, phipi ,0.13957018);
	tmph1->Fill((tlvmu1+tlvmu2).M());
	tmph2->Fill((tlvpr+tlvpi).M());
	tmph3->Fill((tlvmu1+tlvmu2+tlvpr+tlvpi).M());
	tmph4->Fill((tlvpr+tlvpi).P(),tlvpr.P()-tlvpi.P());
	//cout << (tlvmu1+tlvmu2).M() << " " << (tlvpr+tlvpi).M() << " " << (tlvmu1+tlvmu2+tlvpr+tlvpi).M() << endl;
	if (!matchesonly)
	    cout << setw(10) << genrun << " " << setw(10) << genls << " " << setw(10) << genevt << " " << setw(10) << lst->GetEntry(i) << " ";
	// inner loop on reco events
	int nfound(0);
	for (int j=0; j!=treco->GetEntries(); j++)
	{
	    treco->GetEntry(j);
	    if(genrun==recorun && genls==recols && genevt==recoevt)
	    {
		nfound++;
		if (matchesonly && nfound==1)
		    cout << setw(10) << genrun << " " << setw(10) << genls << " " << setw(10) << genevt << " " << setw(10) << lst->GetEntry(i) << " ";
		if(nfound>1) cout << "                                 " << setw(10) << lst->GetEntry(i) << " ";
		cout << setw(10) << j << " match: " << mcmatch << endl;
	    }
	}
	if (!matchesonly && nfound==0) cout << "         -" << endl;
    }
    c2 = new TCanvas();
    c2->Divide(2,2);
    c2->cd(1);
    tmph1->Draw();
    c2->cd(2);
    tmph2->Draw();
    c2->cd(3);
    tmph3->Draw();
    c2->cd(4);
    tmph4->Draw();
}
void TMVAClassificationApplication( TString myMethodList = "" ) 
{   
#ifdef __CINT__
   gROOT->ProcessLine( ".O0" ); // turn off optimization in CINT
#endif

   //---------------------------------------------------------------

   // This loads the library
   TMVA::Tools::Instance();

   // set verbosity
   //TMVA::Tools::Instance().Log().SetMinType(kINFO);

   // Default MVA methods to be trained + tested
   std::map<std::string,int> Use;

   Use["BDT"]             = 1; // uses Adaptive Boost
   Use["Category"]        = 1;

   std::cout << std::endl;
   std::cout << "==> Start TMVAClassificationApplication" << std::endl;

   // Select methods (don't look at this code - not of interest)
   if (myMethodList != "") {
      for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0;

      std::vector<TString> mlist = gTools().SplitString( myMethodList, ',' );
      for (UInt_t i=0; i<mlist.size(); i++) {
         std::string regMethod(mlist[i]);

         if (Use.find(regMethod) == Use.end()) {
            std::cout << "Method \"" << regMethod 
                      << "\" not known in TMVA under this name. Choose among the following:" << std::endl;
            for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) {
               std::cout << it->first << " ";
            }
            std::cout << std::endl;
            return;
         }
         Use[regMethod] = 1;
      }
   }

   // --------------------------------------------------------------------------------------------------

   // --- Create the Reader object

   TMVA::Reader *reader = new TMVA::Reader( "Color:!Silent" );    
   reader->SetMsgType(kINFO);


   // CMS STATS:
   //
   // Create a set of variables and declare them to the reader
   // - the variable names MUST corresponds in name and type to those given in the weight file(s) used
   Float_t met;
   Float_t HT;
   Float_t minMLB;
   Float_t leptonJetsMETSum;
   reader->AddVariable( "met",              &met );
   reader->AddVariable( "HT",               &HT );
   reader->AddVariable( "minMLB",           &minMLB );
   reader->AddVariable( "leptonJetsMETSum", &leptonJetsMETSum );



   // CMS STATS:
   // *** VERY IMPORTANT! ***
   // TMVA notoriously has problems with integer and other non-float branches.
   // Better not to use them at all and convert them to Float_t. If you happen
   // to have integer branches that you need, as in this example, you should create
   // corresponding float spectator variables and assign them in the event loop.
   // 
   // Spectator variables declared in the training have to be added to the reader, too
   //
   // Note that the corresponding branches are integer, so we create floats too!
   Int_t nBTag;
   Int_t nJets;
   Int_t nLeptons;
   Int_t isMuon1;
   Int_t isMuon2;
   Int_t isMuon3;
   Int_t isMuon4;
   Float_t nBTagFloat;
   Float_t nJetsFloat;
   Float_t nLeptonsFloat;
   Float_t isMuon1Float;
   Float_t isMuon2Float;
   Float_t isMuon3Float;
   Float_t isMuon4Float;
   Float_t leptonSumMass;
   reader->AddSpectator( "nBTag", &nBTagFloat );
   reader->AddSpectator( "nJets", &nJetsFloat );
   reader->AddSpectator( "nLeptons", &nLeptonsFloat );
   reader->AddSpectator( "isMuon1", &isMuon1Float );
   reader->AddSpectator( "isMuon2", &isMuon2Float );
   reader->AddSpectator( "isMuon3", &isMuon3Float );
   reader->AddSpectator( "isMuon4", &isMuon4Float );
   reader->AddSpectator( "leptonSumMass", &leptonSumMass );



   // CMS STATS:
   // cut definitions. Define categories and overall selection.
#include "TMVA_tprime_cuts.C"



   // Add artificial spectators for distinguishing categories
   Float_t Category_mycat1, Category_mycat2, Category_mycat3, Category_mycat4;
   TString sCat1("Category_cat1:=");
   TString sCat2("Category_cat2:=");
   TString sCat3("Category_cat3:=");
   TString sCat4("Category_cat4:=");
   sCat1.Append(cut_os_cat1);
   sCat2.Append(cut_os_cat2);
   sCat3.Append(cut_ss);
   sCat4.Append(cut_tri);
   reader->AddSpectator( sCat1, &Category_mycat1 );
   reader->AddSpectator( sCat2, &Category_mycat2 );
   reader->AddSpectator( sCat3, &Category_mycat3 );
   reader->AddSpectator( sCat4, &Category_mycat4 );


   // --- Book the MVA methods

   TString dir    = "weights/";
   TString prefix = "TMVAClassification";

   // Book method(s)
   for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) {
      if (it->second) {
         TString methodName = TString(it->first) + TString(" method");
         TString weightfile = dir + prefix + TString("_") + TString(it->first) + TString(".weights.xml");
         reader->BookMVA( methodName, weightfile ); 
      }
   }

   
   // Book output histograms
   UInt_t nbin = 100;
   TH1F * histBdt(0);
   TH1F * histCat(0);

   if (Use["BDT"])           histBdt     = new TH1F( "MVA_BDT",           "MVA_BDT",           nbin, -0.8, 0.8 );
   if (Use["Category"])      histCat     = new TH1F( "MVA_Category",      "MVA_Category",      nbin, -2., 2. );


   // Prepare input tree (this must be replaced by your data source)
   // in this example, there is a toy tree with signal and one with background events
   // we'll later on use only the "signal" events for the test in this example.
   //   
   TFile *input(0);


   // CMS STATS:
   // Specify files with data, for which you want to compute the classifier values
   TString fname = "./data/pass7_OS_test1/TTbar_MuMu/all.root";   
   //TString fname = "./data/pass7_TRI_test1/TTbar_MuMu/all.root";   


   if (!gSystem->AccessPathName( fname )) 
      input = TFile::Open( fname ); // check if file in local directory exists
   
   if (!input) {
      std::cout << "ERROR: could not open data file" << std::endl;
      exit(1);
   }
   std::cout << "--- TMVAClassificationApp    : Using input file: " << input->GetName() << std::endl;
   
   // --- Event loop

   // Prepare the event tree
   // - here the variable names have to corresponds to your tree
   // - you can use the same variables as above which is slightly faster,
   //   but of course you can use different ones and copy the values inside the event loop
   //
   std::cout << "--- Select signal sample" << std::endl;
   TTree* theTree = (TTree*)input->Get("MVA");
   //Float_t userVar1, userVar2;
   theTree->SetBranchAddress( "met",              &met );
   theTree->SetBranchAddress( "HT",               &HT );
   theTree->SetBranchAddress( "minMLB",           &minMLB );
   theTree->SetBranchAddress( "leptonJetsMETSum", &leptonJetsMETSum );


   // spectators
   theTree->SetBranchAddress( "leptonSumMass", &leptonSumMass );
   theTree->SetBranchAddress( "nJets", &nJets );
   theTree->SetBranchAddress( "nBTag", &nBTag );
   theTree->SetBranchAddress( "nLeptons", &nLeptons );
   theTree->SetBranchAddress( "isMuon1", &isMuon1 );
   theTree->SetBranchAddress( "isMuon2", &isMuon2 );
   theTree->SetBranchAddress( "isMuon3", &isMuon3 );
   theTree->SetBranchAddress( "isMuon4", &isMuon4 );


   std::vector<Float_t> vecVar(4); // vector for EvaluateMVA tests


   // CMS STATS:
   //       
   //       A little trick: loop over only selected events

   // make event list
   theTree->Draw(">>EvtList", mycut);
   TEventList * pEvtList = (TEventList *)gROOT->FindObject("EvtList");
   long int nEvents = pEvtList->GetN();

   //std::cout << "--- Processing: " << theTree->GetEntries() << " events" << std::endl;
   std::cout << "--- Processing: " << nEvents << " events" << std::endl;
   TStopwatch sw;
   sw.Start();
   //for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) {
   for (Long64_t ievt=0; ievt<nEvents; ++ievt) {

      if (ievt%1000 == 0) std::cout << "--- ... Processing event: " << ievt << std::endl;

      //theTree->GetEntry(ievt);
      theTree->GetEntry(pEvtList->GetEntry(ievt));


      // CMS STATS:
      // *** HERE we assign integer branches' values to float spectator variables
      //     Otherwise our category cuts would fail
      //
      nBTagFloat=(Float_t)nBTag;
      nJetsFloat=(Float_t)nJets;
      nLeptonsFloat=(Float_t)nLeptons;
      isMuon1Float  = (Float_t)isMuon1;
      isMuon2Float  = (Float_t)isMuon2;
      isMuon3Float  = (Float_t)isMuon3;
      isMuon4Float  = (Float_t)isMuon4;



      // --- Return the MVA outputs and fill into histograms

      if (Use["BDT"          ])   histBdt    ->Fill( reader->EvaluateMVA( "BDT method"           ) );
      if (Use["Category"     ])   histCat    ->Fill( reader->EvaluateMVA( "Category method"      ) );

   }

   // Get elapsed time
   sw.Stop();
   std::cout << "--- End of event loop: "; sw.Print();


   // --- Write histograms

   TFile *target  = new TFile( "TMVApp.root","RECREATE" );
   if (Use["BDT"          ])   histBdt    ->Write();
   if (Use["Category"     ])   histCat    ->Write();

   target->Close();

   std::cout << "--- Created root file: \"TMVApp.root\" containing the MVA output histograms" << std::endl;
  
   delete reader;
    
   std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl;
}