//2d reweighting of rho and its sigma void reweight_rhosigma(TH1F* weight_rho, TH1F* weight_rhoo,TH2F*weight_rhon,TH2F*weight_rho2o,TH2F* weight_rhonr, TH2F* weight_rho2,TH2F*weight_sigman,TH2F*weight_sigma2o,TH2F* weight_sigmanr, TH2F* weight_sigma2,RooDataSet **dset, RooDataSet *dsetdestination, bool deleteold){ if (!(*dset)) return; // TH2F *hnum = new TH2F("hnum","hnum",n_rhobins_forreweighting,rhobins_forreweighting,n_sigmabins_forreweighting,sigmabins_forreweighting); // TH2F *hden = new TH2F("hden","hden",n_rhobins_forreweighting,rhobins_forreweighting,n_sigmabins_forreweighting,sigmabins_forreweighting); TH2F *hnum = new TH2F("hnum","hnum",100,0,100,20,0,20); TH2F *hden = new TH2F("hden","hden",100,0,100,20,0,20); hnum->Sumw2(); hden->Sumw2(); for (int i=0; i<(*dset)->numEntries(); i++){ hden->Fill(fabs((*dset)->get(i)->getRealValue("roorho")),fabs((*dset)->get(i)->getRealValue("roosigma")),(*dset)->store()->weight(i)); } for (int i=0; i<dsetdestination->numEntries(); i++){ hnum->Fill(fabs(dsetdestination->get(i)->getRealValue("roorho")),fabs(dsetdestination->get(i)->getRealValue("roosigma")),dsetdestination->store()->weight(i)); } hnum->Scale(1.0/hnum->Integral()); hden->Scale(1.0/hden->Integral()); //data/MC hnum->Divide(hden); TH2F *h = hnum; RooDataSet *newdset = new RooDataSet(**dset,Form("%s_rhosigmarew",(*dset)->GetName())); newdset->reset(); for (int i=0; i<(*dset)->numEntries(); i++){ RooArgSet args = *((*dset)->get(i)); float oldw = (*dset)->store()->weight(i); float rho = args.getRealValue("roorho"); float sigma = args.getRealValue("roosigma"); float neww = oldw*h->GetBinContent(h->FindBin(rho,sigma)); if(debug){ weight_rho->Fill(neww); weight_rhoo->Fill(oldw); weight_rho2o->Fill(h->GetXaxis()->FindBin(rho),oldw); weight_rhon->Fill(h->GetXaxis()->FindBin(rho),neww); if(oldw!=0)weight_rhonr->Fill(h->GetXaxis()->FindBin(rho),oldw/neww); else {weight_rhonr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;} if(oldw!=0)weight_rho2->Fill(rho,oldw/neww); weight_sigma2o->Fill(h->GetYaxis()->FindBin(sigma),oldw); weight_sigman->Fill(h->GetYaxis()->FindBin(sigma),neww); if(oldw!=0)weight_sigmanr->Fill(h->GetYaxis()->FindBin(sigma),oldw/neww); else {weight_sigmanr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;} if(oldw!=0)weight_sigma2->Fill(sigma,oldw/neww); } newdset->add(args,neww); } newdset->SetName((*dset)->GetName()); newdset->SetTitle((*dset)->GetTitle()); delete hnum; delete hden; RooDataSet *old_dset = *dset; *dset=newdset; std::cout << "RhoSigma2D rew: norm from " << old_dset->sumEntries() << " to " << newdset->sumEntries() << std::endl; if (deleteold) delete old_dset; };
void makeNewTree(TTree *oldTree, TTree *newTree, TFile *outFile){ float bdtoutput, deltaMOverM, wt; oldTree->SetBranchAddress("bdtoutput",&bdtoutput); oldTree->SetBranchAddress("deltaMOverM",&deltaMOverM); oldTree->SetBranchAddress("wt",&wt); newTree->Branch("bdtoutput",&bdtoutput,"bdtoutput/F"); newTree->Branch("deltaMOverM",&deltaMOverM,"deltaMOverM/F"); newTree->Branch("wt",&wt,"wt/F"); string name = string(newTree->GetName()); TH1F *h_bdt = new TH1F(Form("h_bdt_%s",name.c_str()),Form("h_bdt_%s",name.c_str()),100,-1,1.); TH1F *h_dM = new TH1F(Form("h_dm_%s",name.c_str()),Form("h_dm_%s",name.c_str()),100,-0.1,0.1); TH2F *scat = new TH2F(Form("scat_%s",name.c_str()),Form("scat_%s",name.c_str()),100,-1.,1.,100,-.1,0.1); TH2F *scat_abs = new TH2F(Form("scat_abs_%s",name.c_str()),Form("scat_abs_%s",name.c_str()),100,-1.,1.,100,0,0.1); for (int i=0; i<oldTree->GetEntries(); i++){ oldTree->GetEntry(i); if (bdtoutput > -0.5 && deltaMOverM <= 0.02) { newTree->Fill(); h_bdt->Fill(bdtoutput); h_dM->Fill(deltaMOverM); scat->Fill(bdtoutput,deltaMOverM); scat_abs->Fill(bdtoutput,fabs(deltaMOverM)); } } outFile->cd(); h_bdt->Write(); h_dM->Write(); scat->Write(); scat_abs->Write(); }
void plotDeltaT() { Double_t nTopOfIce=1.4; Double_t ant1[3]={8,-5,-25}; Double_t ant2[3]={8,5,-30}; Double_t rho1=TMath::Sqrt(ant1[0]*ant1[0]+ant1[1]*ant1[1]); Double_t rho2=TMath::Sqrt(ant2[0]*ant2[0]+ant2[1]*ant2[1]); Double_t phi1=TMath::ATan2(ant1[1],ant1[0]); Double_t phi2=TMath::ATan2(ant2[1],ant2[0]); std::cout << phi1*TMath::RadToDeg() << "\t" << phi2*TMath::RadToDeg() << "\n"; TH2F *histDt = new TH2F("histDt","histDt",360,-180,180,180,-90,90); for(int binx=1;binx<=histDt->GetNbinsX();binx++) { Double_t phiWaveDeg=histDt->GetXaxis()->GetBinCenter(binx); for(int biny=1;biny<=histDt->GetNbinsY();biny++) { Double_t thetaWaveDeg=histDt->GetYaxis()->GetBinCenter(biny); Double_t phiWave=phiWaveDeg*TMath::DegToRad(); Double_t thetaWave=thetaWaveDeg*TMath::DegToRad(); Double_t d1=TMath::Cos(thetaWave)*(ant1[2]*TMath::Tan(thetaWave)+rho1*TMath::Cos(phi1-phiWave)); Double_t d2=TMath::Cos(thetaWave)*(ant2[2]*TMath::Tan(thetaWave)+rho2*TMath::Cos(phi2-phiWave)); Double_t t2t1=(d1-d2)*nTopOfIce/TMath::C(); t2t1*=1e9; histDt->Fill(phiWaveDeg,thetaWaveDeg,t2t1); } } histDt->Draw("colz"); }
int main(int argc, char** argv) { // Build histogram of chi^2 values over many files // Write out to a new rootfile chiout.root TFile file("chiout.root", "recreate"); TH2F* histogram = new TH2F("chisquared", "chisquared values of pedestal fit", 52, 0, 52, 1000, 0, 2000); for(int i=1; i<argc; i++) { TFile fin(argv[i]); TTree* tin=(TTree*)fin.Get("slowTree"); double chi2vals[52]; tin->SetBranchAddress("fit_chi2perndf", &chi2vals); tin->GetEvent(0); for(int j=0; j<52; j++) { histogram->Fill(j, chi2vals[j]); if( chi2vals[j] > 500 ) { std::cout << "Chi^2 high on pmt: " << j << " file:[" << argv[i] << "]\n"; } } } file.Write(); return 0; }
void display_magfield(){ FILE *pFile = fopen("magfield.table", "r"); // FILE *pFile = fopen( // "../MUSIC-3D-filed-map/MUSIC-FILL-map1-X=+-2000-Y=0-1000-Z=-1000-5000.table", "r"); TFile *outFile = new TFile("magfield.root", "RECREATE"); TTree *outTree = new TTree("bfield", "bfield"); bfield2d myfield; outTree->Branch("field", &myfield, "x/F:z:bx:bz"); TH2F *bhist = new TH2F("Bfield", "Bfield", 200, -2000, 2000, 300, -1000, 5000); float y, by, junk; char dat_format [] = "%f %f %f %e %e %e %e"; char line [150]; int linecount = 0; while (fgets(line, 150, pFile) != NULL) { ++ linecount; if (linecount < 10) continue; sscanf(line, dat_format, &myfield.x, &y, &myfield.z, &myfield.bx, &by, &myfield.bz, &myfield.bmod); if (y < 5) continue; // take only the y = 0 slice outTree->Fill(); bhist->Fill(myfield.x, myfield.z, myfield.bmod); } // bhist->Draw("SURF2"); bhist->Draw("CONT1"); }
void ECALEndcapCorrectionFactorCalculator() { std::string detectorModel("90"); std::string recoVar("71"); TString rootFilesToCompare("/r04/lc/sg568/HCAL_Optimisation_Studies/Calibration/Detector_Model_" + detectorModel + "/Reco_Stage_" + recoVar + "/MuonCalibration/RootFiles/*Photon*.root"); std::string resultsFileName("ECALEndcapCorrectionFactorCalculator_DetectorModel" + detectorModel + "_RecoStage" + recoVar + ".txt"); std::ofstream resultsFile; resultsFile.open (resultsFileName.c_str()); float ecalTotalCaloHitEnergy(-1.f); std::vector<float> *pPfoTargetCosTheta(NULL); TChain *pTChain = new TChain("PfoAnalysisTree"); pTChain->Add(rootFilesToCompare); pTChain->SetBranchAddress("ECalTotalCaloHitEnergy",&ecalTotalCaloHitEnergy); pTChain->SetBranchAddress("pfoTargetCosTheta",&pPfoTargetCosTheta); TCanvas *pTCanvas = new TCanvas("PhotonDistPic", "PhotonDistPic"); TH2F *pPhotonDist = new TH2F("PhotonDist","PhotonDist",100,0,1,150,0,15); pPhotonDist->GetXaxis()->SetTitle("abs( cos (#theta_{#gamma}) )"); pPhotonDist->GetYaxis()->SetTitle("ECal Calo Hit Energy [GeV]"); for (int entry = 0; entry < pTChain->GetEntries(); entry++) { // std::cout << "Reading entry " << entry << std::endl; pTChain->GetEvent(entry); if (!pPfoTargetCosTheta->empty()) { // std::cout << "Target cos theta : " << pPfoTargetCosTheta.at(0) << std::endl; pPhotonDist->Fill(TMath::Abs(pPfoTargetCosTheta->at(0)),ecalTotalCaloHitEnergy); } } TF1 *barrelFit = new TF1("BarrelFit","[0]",0.1,0.7); barrelFit->SetLineColor(kGray); barrelFit->SetLineWidth(4); TF1 *endcapFit = new TF1("EndcapFit","[0]",0.85,0.95); endcapFit->SetLineColor(kGray); endcapFit->SetLineWidth(4); pTCanvas->cd(); pPhotonDist->Draw("COLZ"); pPhotonDist->Fit(barrelFit,"QR+"); pPhotonDist->Fit(endcapFit,"QR+"); resultsFile << "For the barrel the best fit is : " << barrelFit->GetParameter(0) << std::endl; resultsFile << "For the endcap the best fit is : " << endcapFit->GetParameter(0) << std::endl; resultsFile << "ECALEndcapCorrectionFactorCalculator -> " << (barrelFit->GetParameter(0))/(endcapFit->GetParameter(0)) << std::endl; resultsFile.close(); TString picName = "ECALEndcapCorrectionFactorCalculator_DetectorModel" + detectorModel + "_RecoStage" + recoVar + ".pdf"; pTCanvas->SaveAs(picName); }
TCanvas *earth(){ //this tutorial illustrate the special contour options // "AITOFF" : Draw a contour via an AITOFF projection // "MERCATOR" : Draw a contour via an Mercator projection // "SINUSOIDAL" : Draw a contour via an Sinusoidal projection // "PARABOLIC" : Draw a contour via an Parabolic projection // //Author: Olivier Couet (from an original macro sent by Ernst-Jan Buis) gStyle->SetPalette(57); gStyle->SetOptTitle(1); gStyle->SetOptStat(0); TCanvas *c1 = new TCanvas("c1","earth_projections",700,700); c1->Divide(2,2); TH2F *ha = new TH2F("ha","Aitoff", 180, -180, 180, 179, -89.5, 89.5); TH2F *hm = new TH2F("hm","Mercator", 180, -180, 180, 161, -80.5, 80.5); TH2F *hs = new TH2F("hs","Sinusoidal",180, -180, 180, 181, -90.5, 90.5); TH2F *hp = new TH2F("hp","Parabolic", 180, -180, 180, 181, -90.5, 90.5); TString dat = gSystem->UnixPathName(__FILE__); dat.ReplaceAll("C","dat"); dat.ReplaceAll("/./","/"); ifstream in; in.open(dat.Data()); Float_t x,y; while (1) { in >> x >> y; if (!in.good()) break; ha->Fill(x,y, 1); hm->Fill(x,y, 1); hs->Fill(x,y, 1); hp->Fill(x,y, 1); } in.close(); c1->cd(1); ha->Draw("aitoff"); c1->cd(2); hm->Draw("mercator"); c1->cd(3); hs->Draw("sinusoidal"); c1->cd(4); hp->Draw("parabolic"); return c1; }
void Correlation::DrawMatrix(){ map<TString, map<TString,double> >::iterator it1 = results.begin(); map<TString, double>::iterator it2 = ((*it1).second).begin(); int nvars = (int) results.size(); TH2F* hmatrix = new TH2F("matrix","",nvars,0,nvars,nvars,0,nvars); hmatrix->SetStats(0); int counter1= 1; for(it1 = results.begin(); it1!= results.end(); ++it1){ TString var1 = (*it1).first; var1.ReplaceAll("_both_mix_merge",""); hmatrix->GetXaxis()->SetBinLabel(counter1,var1); counter1++; int counter2=1; map<TString, double> results2 = (*it1).second; map<TString, double>::iterator it2 = results2.begin(); for(it2 = results2.begin(); it2!=results2.end(); ++it2){ TString var2 = (*it2).first; var2.ReplaceAll("_both_mix_merge",""); //cout << counter2 << " " << var2 << endl; if ( counter1==1) hmatrix->GetYaxis()->SetBinLabel(counter2,var2); counter2++; double value = abs((*it2).second); //cout << var1 << " " << var2 << " " << value << endl; hmatrix->Fill(var1,var2,value); if(var1!=var2) hmatrix->Fill(var2,var1,value); } } TCanvas* c = new TCanvas("c","",700,700); hmatrix->GetXaxis()->SetLabelSize(0.03); hmatrix->GetYaxis()->SetLabelSize(0.03); c->SetLeftMargin(0.2); c->SetBottomMargin(0.2); hmatrix->Draw("colz"); c->SaveAs("results/matrix.pdf"); c->SaveAs("results/matrix.eps"); }
void display_magfield(){ // FILE *pFile = fopen("../../PION-DIPOLE-bfield/Dipole fring Bmap_XZ_X-2000-0_Z0-2000.table", "r"); // FILE *pFile = fopen("../../PION-DIPOLE-bfield/Dipole Bmap_XZ_X0-220_Z0-500.table", "r"); // FILE *pFile = fopen("../input/Bfield_roi.table", "r"); FILE *pFile = fopen("../output/vec_field_out.table", "r"); // FILE *pFile = fopen( // "../../MUSIC-3D-filed-map/MUSIC-FILL-map1-X=+-2000-Y=0-1000-Z=-1000-5000.table", "r"); TFile *outFile = new TFile("magfield.root", "RECREATE"); TTree *outTree = new TTree("bfield", "bfield"); bfield2d myfield; outTree->Branch("field", &myfield, "x/F:z:bx:bz"); // TH2F *bhist = new TH2F("Bfield", "Bfield", 200, -2000, 2000, // 300, -1000, 5000); // TH2F *bhist = new TH2F("Bfield", "Bfield", 55, 500, 1600, // 55, 3080, 4180); TH2F *bhist = new TH2F("Bfield", "Bfield", 54, -540, 540, 54, -540, 540); // TH2F *bhist = new TH2F("Bfield", "Bfield", 55, 460, 1560, // 54, 3240, 4320); // TH2F *bhist = new TH2F("Bfield", "Bfield", 54, -540, 540, // 54, -540, 540); float y, by, junk; char dat_format [] = "%f %f %f %e %e %e %e"; char line [150]; int linecount = 0; float max_bfield = 0; int test =0; while (fgets(line, 150, pFile) != NULL) { ++ linecount; // if (linecount < 10) continue; sscanf(line, dat_format, &myfield.x, &y, &myfield.z, &myfield.bx, &by, &myfield.bz, &myfield.bmod); if (myfield.bmod > max_bfield) max_bfield = myfield.bmod; if (y > 15) continue; // take only the y = 0 slice ++test; outTree->Fill(); bhist->Fill(myfield.x, myfield.z, myfield.bmod); } outFile->Write(); // bhist->Draw("SURF2"); bhist->SetTitle("Magnetic dipole fringe field"); // bhist->SetTitle("Magnetic field in simulated region"); // bhist-> // bhist->Draw("CONT1"); bhist->Draw("COLZ"); cout << "Max magnetic field: "<<max_bfield << endl; cout << "Number of lines read in: "<<test << endl; cout << "REMEMBER: if using an 'output' file from the simulation - uncomment the ignore lines code"<<endl; }
TH2F* Bin2DTree::fillHistogram() /*****************************************************************/ { if(!m_gridConstraint) { cerr<<"ERROR: Bin2DLeaf.fillHistogram(): Trying to fill histogram, but the binning is unknown. Define first the gridConstraint.\n"; exit(1); } TH2F* histo = (TH2F*)m_gridConstraint->Clone("histoFromTree"); int nbinsx = histo->GetNbinsX(); int nbinsy = histo->GetNbinsY(); map<Bin2DLeaf*, vector< pair<int,int> > > binsInLeaf; // First find the list of TH2 bins for each Bin2DLeaf bin for(int bx=1;bx<nbinsx+1;bx++) { for(int by=1;by<nbinsy+1;by++) { histo->SetBinContent(bx,by,0); histo->SetBinError(bx,by,0); double x = histo->GetXaxis()->GetBinCenter(bx); double y = histo->GetYaxis()->GetBinCenter(by); Bin2DLeaf* leaf = getLeaf(x,y); if(binsInLeaf.find(leaf)==binsInLeaf.end()) { vector< pair<int,int> > empty; binsInLeaf[leaf] = empty; } binsInLeaf[leaf].push_back(make_pair(bx,by)); } } // Then all the TH2 bins are filled according to the entries in the Bin2DLeaf bins map<Bin2DLeaf*, vector< pair<int,int> > >::iterator it = binsInLeaf.begin(); map<Bin2DLeaf*, vector< pair<int,int> > >::iterator itE = binsInLeaf.end(); for(;it!=itE;++it) { Bin2DLeaf* leaf = it->first; vector< pair<int,int> > bins = it->second; vector< vector<double> > entries = leaf->getEntries(); int nbins = bins.size(); for(int b=0;b<nbins;b++) { int bx = bins[b].first; int by = bins[b].second; double x = histo->GetXaxis()->GetBinCenter(bx); double y = histo->GetYaxis()->GetBinCenter(by); for(unsigned int e=0;e<entries.size();e++) { double value = entries[e][2]/(double)nbins; histo->Fill(x,y,value); } } } return histo; }
TCanvas *earth(){ gStyle->SetPalette(1); gStyle->SetOptTitle(1); gStyle->SetOptStat(0); TCanvas *c1 = new TCanvas("c1","earth_projections",700,700); c1->Divide(2,2); TH2F *ha = new TH2F("ha","Aitoff", 180, -180, 180, 179, -89.5, 89.5); TH2F *hm = new TH2F("hm","Mercator", 180, -180, 180, 161, -80.5, 80.5); TH2F *hs = new TH2F("hs","Sinusoidal",180, -180, 180, 181, -90.5, 90.5); TH2F *hp = new TH2F("hp","Parabolic", 180, -180, 180, 181, -90.5, 90.5); TString dat = gSystem->UnixPathName(__FILE__); dat.ReplaceAll(".C",".dat"); dat.ReplaceAll("/./","/"); ifstream in; in.open(dat.Data()); Float_t x,y; while (1) { in >> x >> y; if (!in.good()) break; ha->Fill(x,y, 1); hm->Fill(x,y, 1); hs->Fill(x,y, 1); hp->Fill(x,y, 1); } in.close(); c1->cd(1); ha->Draw("aitoff"); c1->cd(2); hm->Draw("mercator"); c1->cd(3); hs->Draw("sinusoidal"); c1->cd(4); hp->Draw("parabolic"); return c1; }
void QAnalysis::PlotVelocityDistribution(int phi) { TTree* tree = ReadTree(file); int zbin = 60; int rbin = 19; TH2F* hist = new TH2F("quenchv", "quenchv", zbin, 0, 60, rbin, 0, 19); for (int i=0; i<tree->GetEntries(); i++) { tree->GetEntry(i); if ( time==70. && posID[1]==phi ) hist->Fill(posID[0], posID[2], qchTime); } hist->SetTitle("; Z; R; Quenched Time [sec]"); hist->Draw("colz"); }
void QAnalysis::PlotTemperatureDistribution(double qtime, int numPhi, bool scale) { int zbin = 60; int rbin = 19; TH2F* hist = new TH2F(Form("tempDis%.1f", qtime), Form("tempDis%.1f", qtime), zbin, 0, 60, rbin, 0, 19); TTree* tree = ReadTree(file); for (int i=0; i<tree->GetEntries(); i++) { tree->GetEntry(i); if ( time==qtime && posID[1]==numPhi ) hist->Fill(posID[0], posID[2], temp); } if (scale==true) hist->GetZaxis()->SetRangeUser(0., GetMaximum("temp")); hist->SetTitle(Form("time = %.1f [sec]; Z; R; Temperature [K]", qtime)); hist->Draw("colz"); }
void drawRes(TString in="data/scan7/res_all.root"){ glx_savepath = "data/drawRes"; gStyle->SetOptStat(0); gStyle->SetPalette(55); gStyle->SetNumberContours(99); TChain ch("reco"); ch.Add(in); Double_t sep,esep,spr,mom,theta,phi,nph; ch.SetBranchAddress("theta",&theta); ch.SetBranchAddress("phi",&phi); ch.SetBranchAddress("sep",&sep); ch.SetBranchAddress("esep",&esep); ch.SetBranchAddress("spr",&spr); ch.SetBranchAddress("mom",&mom); ch.SetBranchAddress("nph",&nph); TH2F *hSep_pol = new TH2F("hSep",";#theta [deg];#varphi [deg]",72,0,360,(11.4-1.2)/0.2+1+6,0,11.4); TH2F *hSep = new TH2F("hSep",";#theta [deg];#varphi [deg]",(11.4-1.2)/0.2+1,1.2,11.4,36,-170,10); for(Int_t i=0; i<ch.GetEntries(); i++){ ch.GetEvent(i); hSep->Fill(theta,phi,sep); hSep_pol->Fill(180-phi,theta,sep); } // // interpolate emptiness // double pval; // for(int i=0; i<hSep_pol->GetNbinsX()*hSep_pol->GetNbinsX(); i++){ // double val = hSep_pol->GetBinContent(i); // if(val<0.001 && ) hSep_pol->SetBinContent(i,pval); // else pval=val; // } Int_t colors[]={1,kGreen+1,kRed+2,kRed,4,5,6,7,8,9,10}; glx_canvasAdd("hSep_pol",800,800); gPad->SetTheta(90.); gPad->SetPhi(0.); hSep_pol->Draw("lego2 polz"); glx_canvasAdd("hSep",800,500); hSep->Draw("colz"); glx_canvasSave(0,0); }
void scatterPloteta(){ gROOT->Reset(); gStyle->SetOptStat(1); ifstream data; float valueX; float valueY; string name = "eta"; data.open((name+".txt").c_str()); TH2F * histo = new TH2F("histo",name.c_str(),1000,-2.4,2.4,100,-2.4,2.4); //eta TH1F * histo1D = new TH1F("histo1D",name.c_str(),1000,-2.4,2.4); //eta // float pi = 3.14159265; // TH2F * histo = new TH2F("histo",name.c_str(),1000,-1*pi,pi,1000,-1*pi,pi); //phi // TH1F * histo1D = new TH1F("histo1D",name.c_str(),1000,-1*pi,pi); //phi while(!data.eof()){ data >>valueX>>valueY; cout<<valueX<<" "<<valueY<<endl; histo->Fill(valueX,valueY); histo1D->Fill(valueX-valueY); } TCanvas * Ca0 = new TCanvas("Ca0","Canvas",1200,800); histo->SetLineWidth(3); TFile * theFile = new TFile("eta.root","RECREATE"); theFile->cd(); histo->Draw(); histo1D->DrawNormalized("same"); histo->GetXaxis()->SetTitle(("RPC"+name).c_str()); histo->GetYaxis()->SetTitle(("CSC"+name).c_str()); Ca0->SaveAs((name+".png").c_str()); histo1D->Write(); histo->Write(); theFile->Save(); theFile->Close(); }
void generate_sample(string OutFilePath="out.txt", string unusedArgument="") { if(OutFilePath == "")return; FILE* OutputFile = fopen(OutFilePath.c_str(), "w"); float mu=0.5; float sigma=0.1; float nb_events=1000000; TRandom3 rand(12345); TFile* OutputHisto = new TFile((OutFilePath+".root").c_str(),"RECREATE"); OutputHisto->cd(); TH2F* HGen = new TH2F("pdf", "pdf;x;y", 100,0,1, 100, 0, 1 ); int i=0; while(i<nb_events){ double x = rand.Uniform(); double y = rand.Uniform(); // double r=0.5+rand.Uniform()* 0.2; //rand.Gaus(0.2, 0.1); // double phi=rand.Uniform() * 2.0 * 3.1415; // double x=r*cos(phi); // double y=r*sin(phi); double eps=0.1; double fct=1.0+eps*(2.0*y); double max_weight=1.0+2*eps; // if(fct>max_weight*rand.Uniform()){ if(true){ fprintf(OutputFile, "%8f %8f \n", x, y ); HGen->Fill(x,y); i++; } } fclose(OutputFile); HGen->Write(); }
void gauss2D() { TH2F * h = new TH2F("h", "h", 41, -20.5, 20.5, 41, -20.5, 20.5); /* for (int i=0;i<50000;++i) { h->Fill(gRandom->Gaus(-1.5, 2.0), gRandom->Gaus(2.0, 4.0)); } */ double x, y, r; for (int i=0;i<100000;++i) { x = gRandom->Uniform(-5, 5); y = gRandom->Uniform(-5, 5); r = TMath::Sqrt(x*x+y*y); if (r>5) continue; h->Fill(x, y); } h->Draw("lego2"); TF2 *f2 = new TF2("f2", func_, -20.5, 20.5, -20.5, 20.5, 5); f2->SetParameter(0, 1000); f2->SetParameter(1, 0); f2->SetParameter(2, 1); f2->SetParameter(3, 0); f2->SetParameter(4, 1); h->Fit(f2); //f2->Draw("surf"); /* std::ofstream ofile("gauss2Ddump.txt"); for (int bx=1;bx<=41;++bx) { for (int by=1;by<=41;++by) { ofile << h->GetXaxis()->GetBinCenter(bx) << "\t" << h->GetXaxis()->GetBinCenter(bx) << "\t" << h->GetBinContent(bx, by) << std::endl; } } */ }
void DynamicSlice() { // Create a new canvas. c1 = new TCanvas("c1","Dynamic Slice Example",10,10,700,500); c1->SetFillColor(42); c1->SetFrameFillColor(33); //create a 2-d histogram, fill and draw it TH2F *hpxpy = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4); hpxpy->SetStats(0); Double_t px,py; for (Int_t i = 0; i < 50000; i++) { gRandom->Rannor(px,py); hpxpy->Fill(px,py); } hpxpy->Draw("col"); //Add a TExec object to the canvas c1->AddExec("dynamic","DynamicExec()"); }
void drawLoad(TString infile="../build/hits.root"){ gStyle->SetOptStat(0); fSavePath = "load"; PrtInit(infile,0); //digi TH2F* hHits = new TH2F("hHits",";x, [mm];y, [mm]",500,-40,350,500,-100,100); Int_t angle(0), step(0); Double_t test(0); PrtHit fHit; for (Int_t ievent=0; ievent<fCh->GetEntries(); ievent++){ PrtNextEvent(ievent,1000); if(ievent==0){ angle = fEvent->GetAngle() + 0.01; test = fEvent->GetTest1(); fInfo += fEvent->PrintInfo(); } for(Int_t h=0; h<fEvent->GetHitSize(); h++){ fHit = fEvent->GetHit(h); Int_t mcpid = fHit.GetMcpId(); Int_t pixid = fHit.GetPixelId()-1; TVector3 pos = fHit.GetGlobalPos(); Double_t time = fHit.GetLeadTime(); hHits->Fill(pos.X(),pos.Y()); } } canvasAdd(Form("load_%d",angle),800,500); hHits->SetStats(0); hHits->GetXaxis()->SetTitleOffset(0.85); hHits->GetYaxis()->SetTitleOffset(0.85); hHits->GetXaxis()->SetTitleSize(0.05); hHits->GetYaxis()->SetTitleSize(0.05); //hHits->SetTitle(Form("#theta_{track} = %d#circ",angle)); hHits->Draw("colz"); drawPrism(prismShift,0); canvasSave(1,0); }
void FakeLeptonPlotter::fill(unsigned int iSample, unsigned int iSubSample) { if( iSample < nSamples && iSubSample < configContainer.sampleContainer.sampleNames[iSample].size() ) { // if( configContainer.sampleContainer.sampleType[iSample] == SampleType::DATA ) // { // for( unsigned int iVar = 0, iHist = 0; iVar < nVariables; ++iVar, ++iHist ) // { // if( configContainer.variableContainer.is2D[iVar] ) // { // TH2F* h = (TH2F*) histogramContainers[iHist].histograms[iSample]; // h->Fill( functionVector[iVar](), functionVector[iVar+1](), globalWeight[iSample][iSubSample] ); // apply global weight for trigger luminosity // iVar++; // } // else // histogramContainers[iHist].histograms[iSample]->Fill( functionVector[iVar](), globalWeight[iSample][iSubSample] ); // } // } // else // { for( unsigned int iVar = 0, iHist = 0; iVar < nVariables; ++iVar, ++iHist ) { if( configContainer.variableContainer.is2D[iVar] ) { TH2F* h = (TH2F*) histogramContainers[iHist].histograms[iSample]; h->Fill( functionVector[iVar](), functionVector[iVar+1](), globalWeight[iSample][iSubSample]*eventWeightFunction() ); iVar++; } else histogramContainers[iHist].histograms[iSample]->Fill( functionVector[iVar](), globalWeight[iSample][iSubSample]*eventWeightFunction() ); } // } } else { cerr << "Indices for sample or subsample out of range in the FakeLeptonPlotter::fill function." << endl; throw 1; } }
TCanvas *hlabels2() { const Int_t nx = 12; const Int_t ny = 20; const char *month[nx] = {"January","February","March","April","May", "June","July","August","September","October","November", "December"}; const char *people[ny] = {"Jean","Pierre","Marie","Odile","Sebastien", "Fons","Rene","Nicolas","Xavier","Greg","Bjarne","Anton", "Otto","Eddy","Peter","Pasha","Philippe","Suzanne","Jeff", "Valery"}; TCanvas *c1 = new TCanvas("c1","demo bin labels",10,10,600,600); c1->SetGrid(); c1->SetLeftMargin(0.15); c1->SetBottomMargin(0.15); TH2F *h = new TH2F("h","test",3,0,3,2,0,2); h->SetCanExtend(TH1::kAllAxes); h->SetStats(0); gRandom->SetSeed(); for (Int_t i=0;i<15000;i++) { Int_t rx = gRandom->Rndm()*nx; Int_t ry = gRandom->Rndm()*ny; h->Fill(people[ry],month[rx],1); } h->LabelsDeflate("X"); h->LabelsDeflate("Y"); h->LabelsOption("v"); h->Draw("text"); TPaveText *pt = new TPaveText(0.6,0.85,0.98,0.98,"brNDC"); pt->SetFillColor(18); pt->SetTextAlign(12); pt->AddText("Use the axis Context Menu LabelsOption"); pt->AddText(" \"a\" to sort by alphabetic order"); pt->AddText(" \">\" to sort by decreasing values"); pt->AddText(" \"<\" to sort by increasing values"); pt->Draw(); return c1; }
void plotjets(){ TFile *f = TFile::Open("/store/user/qixu/flow/STEGwithnf/pPbDataV205m100/Varmults10b10/vndata_50k_0.root"); int ievent = 1000; int n; float etag[10000]; float phig[10000]; float ptg[10000]; TH2F* hetaphi = new TH2F("hetaphi","",100,-4,4,200,0,6.5); TTree *t = f->Get("tree"); t->SetBranchAddress("n",&n); t->SetBranchAddress("etag",&etag); t->SetBranchAddress("phig",&phig); t->GetEntry(ievent); for(int ip = 0;ip<n;ip++){ hetaphi->Fill(etag[ip],phig[ip]); } hetaphi->GetXaxis()->SetTitle("#eta"); hetaphi->GetYaxis()->SetTitle("#phi"); TCanvas *c1 = new TCanvas(); //c1->SetLogy(); hetaphi->Draw("colz"); c1->Print("hetaphi.png"); }
TH1F * CheckEnabledChannels(Int_t run, Bool_t checkROEff = kTRUE, const Char_t *dbString = "raw://") { /* init */ AliCDBManager *cdb = AliCDBManager::Instance(); cdb->SetDefaultStorage(dbString); cdb->SetRun(run); AliTOFcalib calib; calib.Init(); TH2F *hEnabledMap = new TH2F("hEnabledMap", "Enabled channel map;sector;strip", 72, 0., 18., 91, 0., 91.); TH1F *hEnabledFlag = new TH1F("hEnabledFlag", "Enabled channel flag;index;flag", 157248, 0., 157248.); AliTOFcalibHisto calibhisto; calibhisto.LoadCalibHisto(); calibhisto.LoadCalibStat(); /* temp */ Int_t sector, sectorStrip, padx, fea; Float_t hitmapx, hitmapy; /* loop over channels */ for (Int_t ich = 0; ich < 157248; ich++) { if (!calib.IsChannelEnabled(ich, checkROEff)) continue; sector = calibhisto.GetCalibMap(AliTOFcalibHisto::kSector, ich); sectorStrip = calibhisto.GetCalibMap(AliTOFcalibHisto::kSectorStrip, ich); padx = calibhisto.GetCalibMap(AliTOFcalibHisto::kPadX, ich); fea = padx / 12; hitmapx = sector + ((Double_t)(3 - fea) + 0.5) / 4.; hitmapy = sectorStrip; hEnabledMap->Fill(hitmapx, hitmapy); hEnabledFlag->SetBinContent(ich + 1, 1); } hEnabledMap->DrawCopy("colz"); return hEnabledFlag; }
void PlotYields(const std::string& name, std::map<double, double> yields, TLegend* legend) { static int pass = 0; int colors[] = {kBlue, kRed, kGreen, kOrange, kBlack}; int lastColor = sizeof(colors)/sizeof(colors[0])-1; double miny = std::min_element(yields.begin(), yields.end(), [](std::pair<double, double> p, std::pair<double, double> q) { return p.second < q.second; })->second; double maxy = std::max_element(yields.begin(), yields.end(), [](std::pair<double, double> p, std::pair<double, double> q) { return p.second < q.second; })->second; std::string canvasName = "Yields " + name; // TCanvas * c = new TCanvas(canvasName.c_str(), canvasName.c_str(), 900, 700); SetAtlasStyle(); //c->SetLogy(); TH2F* hist = new TH2F(canvasName.c_str(), canvasName.c_str(), 20, 200, 1100, 200, miny * 0.9, maxy * 1.1); hist->SetMarkerStyle(21+pass); hist->SetMarkerColor(pass > lastColor ? lastColor : colors[pass]); for (const std::pair<double, double>& p : yields) { // don't plot background yields if (p.first < 100) { continue; } hist->Fill(p.first, p.second); } if (pass == 0) { hist->Draw("p"); } else { hist->Draw("same"); } legend->AddEntry(hist, name.c_str(), "lp"); //c->Print(outputFolder + "yields.pdf"); ++pass; }
// inputs data file and event in file to display (default is to integrate all) void dqmDisplay(TString fdat, int ndisplay = -1){ gStyle->SetOptStat(0); TFile *f = new TFile(fdat); if (f->IsZombie()){ cout << "Cannot open file: " << fdat << endl; return; } TBEvent *event = new TBEvent(); TTree *t1041 = (TTree*)f->Get("t1041"); TBranch *bevent = t1041->GetBranch("tbevent"); bevent->SetAddress(&event); Bool_t singleEvent = (ndisplay >= 0); Mapper * mapper = Mapper::Instance(); TH2F * hModU = (TH2F*)moduleHistogram(true, "RO", threshold, 2500, singleEvent); TH2F * hModD = (TH2F*)moduleHistogram(false, "RO", threshold, 2500, singleEvent); TH2F * hChanU = (TH2F*)channelHistogram(true, "RO", threshold, 2500, singleEvent); TH2F * hChanD = (TH2F*)channelHistogram(false, "RO", threshold, 2500, singleEvent); TH2F * hModU_time = (TH2F*)moduleHistogram(true, "Timing", 0, -1, singleEvent); TH2F * hModD_time = (TH2F*)moduleHistogram(false, "Timing", 0, -1, singleEvent); TH2F * hChanU_time = (TH2F*)channelHistogram(true, "Timing", 0, -1, singleEvent); TH2F * hChanD_time = (TH2F*)channelHistogram(false, "Timing", 0, -1, singleEvent); int nPerMod = t1041->GetEntries() / 16; int nPerFiber = t1041->GetEntries() / 64; TH2F * hModU_nhits = (TH2F*)moduleHistogram(true, "nHits", nPerMod * .85, nPerMod * 1.1, singleEvent); TH2F * hModD_nhits = (TH2F*)moduleHistogram(false, "nHits", nPerMod * .85, nPerMod * 1.1, singleEvent); TH2F * hChanU_nhits = (TH2F*)channelHistogram(true, "nHits", nPerFiber * .25, nPerFiber * 1.1, singleEvent); TH2F * hChanD_nhits = (TH2F*)channelHistogram(false, "nHits", nPerFiber * .25, nPerFiber * 1.1, singleEvent); TH2F * hModU_ntriggers = (TH2F*)moduleHistogram(true, "nTriggers", nPerMod * .95, nPerMod * 1.3, singleEvent); TH2F * hModD_ntriggers = (TH2F*)moduleHistogram(false, "nTriggers", nPerMod * .95, nPerMod * 1.3, singleEvent); TH2F * hChanU_ntriggers = (TH2F*)channelHistogram(true, "nTriggers", nPerFiber * .95, nPerFiber * 1.3, singleEvent); TH2F * hChanD_ntriggers = (TH2F*)channelHistogram(false, "nTriggers", nPerFiber * .95, nPerFiber * 1.3, singleEvent); Int_t start = 0; Int_t end = t1041->GetEntries(); if (singleEvent) { start = ndisplay; end = ndisplay + 1; } for (Int_t i=start; i < end; i++) { t1041->GetEntry(i); for (Int_t j = 0; j < event->NPadeChan(); j++){ PadeChannel pch = event->GetPadeChan(j); UShort_t max = pch.GetMax(); Int_t maxTime = pch.GetPeak(); if (max>MAXADC) continue; // skip channels with bad adc readings (should be RARE) int channelID=pch.GetChannelID(); // boardID*100+channelNum in PADE int moduleID,fiberID; mapper->ChannelID2ModuleFiber(channelID,moduleID,fiberID); // get module and fiber IDs float xm,ym,xf,yf; mapper->ModuleXY(moduleID,xm,ym); mapper->FiberXY(fiberID, xf, yf); if(moduleID < 0) { hModU_ntriggers->Fill(xm, ym); hChanU_ntriggers->Fill(xf, yf); } else { hModD_ntriggers->Fill(xm, ym); hChanD_ntriggers->Fill(xf, yf); } if(max <= threshold) continue; if (moduleID < 0) { hModU->Fill(xm, ym, max); hModU_time->Fill(xm, ym, maxTime); hModU_nhits->Fill(xm, ym); hChanU->Fill(xf, yf, max); hChanU_time->Fill(xf, yf, maxTime); hChanU_nhits->Fill(xf, yf); } else { hModD->Fill(xm, ym, max); hModD_time->Fill(xm, ym, maxTime); hModD_nhits->Fill(xm, ym); hChanD->Fill(xf, yf, max); hChanD_time->Fill(xf, yf, maxTime); hChanD_nhits->Fill(xf, yf); } } } hModD->Divide(hModD_nhits); hModU->Divide(hModU_nhits); hChanD->Divide(hChanD_nhits); hChanU->Divide(hChanU_nhits); hModD_time->Divide(hModD_nhits); hModU_time->Divide(hModU_nhits); hChanD_time->Divide(hChanD_nhits); hChanU_time->Divide(hChanU_nhits); drawCalorimeterPlot("AvgPeakHeight", hModU, hModD, hChanU, hChanD, t1041->GetEntries(), ndisplay); drawCalorimeterPlot("AvgPeakTiming", hModU_time, hModD_time, hChanU_time, hChanD_time, t1041->GetEntries(), ndisplay); drawCalorimeterPlot("NHits", hModU_nhits, hModD_nhits, hChanU_nhits, hChanD_nhits, t1041->GetEntries(), ndisplay); drawCalorimeterPlot("NTriggers", hModU_ntriggers, hModD_ntriggers, hChanU_ntriggers, hChanD_ntriggers, t1041->GetEntries(), ndisplay); }
int main( int argc, const char* argv[] ){ // List of arguments: // 0: The executable itself // 1: The number of times JetMET is smeared (not smeared if equal to 1) // 2: The scale and type of JES shift (if fabs(x) < 0.5, shift by eta, else absolute // fixme: Depracated float JES_JetMET = 1.0; string xmlFileName = string ("./MyMassAnalysis.xml"); for (int i=1;i<argc;++i) { if (strncmp(argv[i],"-c",2)==0) xmlFileName = string(argv[i+1]); if (strncmp(argv[i],"-h",2)==0) { cout << " -c xm_config_file\n"; exit(1); } } cout<<"#########################"<<endl; cout<<"Beginning of the program"<<endl; cout<<"#########################"<<endl; ////////////////////// //Global variables ////////////////////// // GEN TH1F * histoGenTopRapidity1 = new TH1F("GenTopRapidity1", "GenTopRapidity1", 100, -5, 5); TH1F * histoGenTopRapidity2 = new TH1F("GenTopRapidity2", "GenTopRapidity2", 100, -5, 5); TH1F * histoGenTopMass1 = new TH1F("GenTopMass1", "GenTopMass1", 200, 0, 200); TH1F * histoGenTopMass2 = new TH1F("GenTopMass2", "GenTopMass2", 200, 0, 200); TH2F * histoGenTopMass1VsTopMass2 = new TH2F("GenTopMass1VsTopMass2", "GenTopMass1VsTopMass2", 200, 0, 200, 200, 0, 200); TH1F * histoGenDelta_y = new TH1F("GenDelta_y", "GenDelta_y", 400, -2, 2); TH1F * histoGenTTRapidity = new TH1F("GenTTRapidity", "GenTTRapidity", 500, -2.5, 2.5); TH1F * histoGenTTPt = new TH1F("GenTTPt", "GenTTPt", 250, 0, 250); TH1F * histoGenTTMass = new TH1F("GenTTMass", "GenTTMass", 100, 0, 1000); TH2F * histoGenDelta_yVsTTRapidity = new TH2F("GenDelta_yVsTTRapidity", "GenDelta_yVsTTRapidity", 10, -2, 2, 5, -2.5, 2.5); TH2F * histoGenDelta_yVsTTPt = new TH2F("GenDelta_yVsTTPt", "GenDelta_yVsTTPt", 10, -2, 2, 5, 0, 250); TH2F * histoGenDelta_yVsTTMass = new TH2F("GenDelta_yVsTTMass", "GenDelta_yVsTTMass", 10, -2, 2, 5, 0, 1000); TH1F * histoGenN_plusTTRapidity = new TH1F("GenN_plusTTRapidity", "GenN_plusTTRapidity", 20, -2.5, 2.5); histoGenN_plusTTRapidity->Sumw2(); TH1F * histoGenN_plusTTPt = new TH1F("GenN_plusTTPt", "GenN_plusTTPt", 20, 0, 250); histoGenN_plusTTPt->Sumw2(); TH1F * histoGenN_plusTTMass = new TH1F("GenN_plusTTMass", "GenN_plusTTMass", 20, 0, 1000); histoGenN_plusTTMass->Sumw2(); TH1F * histoGenN_minusTTRapidity = new TH1F("GenN_minusTTRapidity", "GenN_minusTTRapidity", 20, -2.5, 2.5); histoGenN_minusTTRapidity->Sumw2(); TH1F * histoGenN_minusTTPt = new TH1F("GenN_minusTTPt", "GenN_minusTTPt", 20, 0, 250); histoGenN_minusTTPt->Sumw2(); TH1F * histoGenN_minusTTMass = new TH1F("GenN_minusTTMass", "GenN_minusTTMass", 20, 0, 1000); histoGenN_minusTTMass->Sumw2(); TH1F * histoGenN_plusMinusN_minusTTRapidity = new TH1F("GenN_plusMinusN_minusTTRapidity", "GenN_plusMinusN_minusTTRapidity", 20, -2.5, 2.5); histoGenN_plusMinusN_minusTTRapidity->Sumw2(); TH1F * histoGenN_plusPlusN_minusTTRapidity = new TH1F("GenN_plusPlusN_minusTTRapidity", "GenN_plusPlusN_minusTTRapidity", 20, -2.5, 2.5); histoGenN_plusPlusN_minusTTRapidity->Sumw2(); TH1F * histoGenN_plusMinusN_minusTTPt = new TH1F("GenN_plusMinusN_minusTTPt", "GenN_plusMinusN_minusTTPt", 20, 0, 250); histoGenN_plusMinusN_minusTTPt->Sumw2(); TH1F * histoGenN_plusPlusN_minusTTPt = new TH1F("GenN_plusPlusN_minusTTPt", "GenN_plusPlusN_minusTTPt", 20, 0, 250); histoGenN_plusPlusN_minusTTPt->Sumw2(); TH1F * histoGenN_plusMinusN_minusTTMass = new TH1F("GenN_plusMinusN_minusTTMass", "GenN_plusMinusN_minusTTMass", 20, 0, 1000); histoGenN_plusMinusN_minusTTMass->Sumw2(); TH1F * histoGenN_plusPlusN_minusTTMass = new TH1F("GenN_plusPlusN_minusTTMass", "GenN_plusPlusN_minusTTMass", 20, 0, 1000); histoGenN_plusPlusN_minusTTMass->Sumw2(); TH1F * histoGenA_cTTRapidity = new TH1F("GenA_cTTRapidity", "GenA_cTTRapidity", 20, -2.5, 2.5); histoGenA_cTTRapidity->Sumw2(); TH1F * histoGenA_cTTPt = new TH1F("GenA_cTTPt", "GenA_cTTPt", 20, 0, 250); histoGenA_cTTPt->Sumw2(); TH1F * histoGenA_cTTMass = new TH1F("GenA_cTTMass", "GenA_cTTMass", 20, 0, 1000); histoGenA_cTTMass->Sumw2(); // Fine binning TH2F * histoFineBinning_GenDelta_yVsTTRapidity = new TH2F("FineBinning_GenDelta_yVsTTRapidity", "FineBinning_GenDelta_yVsTTRapidity", 200, -2, 2, 500, -2.5, 2.5); TH2F * histoFineBinning_GenDelta_yVsTTPt = new TH2F("FineBinning_GenDelta_yVsTTPt", "FineBinning_GenDelta_yVsTTPt", 200, -2, 2, 250, 0, 250); TH2F * histoFineBinning_GenDelta_yVsTTMass = new TH2F("FineBinning_GenDelta_yVsTTMass", "FineBinning_GenDelta_yVsTTMass", 200, -2, 2, 100, 0, 1000); TH1F * histoFineBinning_GenN_plusTTRapidity = new TH1F("FineBinning_GenN_plusTTRapidity", "FineBinning_GenN_plusTTRapidity", 500, -2.5, 2.5); histoFineBinning_GenN_plusTTRapidity->Sumw2(); TH1F * histoFineBinning_GenN_plusTTPt = new TH1F("FineBinning_GenN_plusTTPt", "FineBinning_GenN_plusTTPt", 250, 0, 250); histoFineBinning_GenN_plusTTPt->Sumw2(); TH1F * histoFineBinning_GenN_plusTTMass = new TH1F("FineBinning_GenN_plusTTMass", "FineBinning_GenN_plusTTMass", 100, 0, 1000); histoFineBinning_GenN_plusTTMass->Sumw2(); TH1F * histoFineBinning_GenN_minusTTRapidity = new TH1F("FineBinning_GenN_minusTTRapidity", "FineBinning_GenN_minusTTRapidity", 500, -2.5, 2.5); histoFineBinning_GenN_minusTTRapidity->Sumw2(); TH1F * histoFineBinning_GenN_minusTTPt = new TH1F("FineBinning_GenN_minusTTPt", "FineBinning_GenN_minusTTPt", 250, 0, 250); histoFineBinning_GenN_minusTTPt->Sumw2(); TH1F * histoFineBinning_GenN_minusTTMass = new TH1F("FineBinning_GenN_minusTTMass", "FineBinning_GenN_minusTTMass", 100, 0, 1000); histoFineBinning_GenN_minusTTMass->Sumw2(); TH1F * histoFineBinning_GenN_plusMinusN_minusTTRapidity = new TH1F("FineBinning_GenN_plusMinusN_minusTTRapidity", "FineBinning_GenN_plusMinusN_minusTTRapidity", 500, -2.5, 2.5); histoFineBinning_GenN_plusMinusN_minusTTRapidity->Sumw2(); TH1F * histoFineBinning_GenN_plusPlusN_minusTTRapidity = new TH1F("FineBinning_GenN_plusPlusN_minusTTRapidity", "FineBinning_GenN_plusPlusN_minusTTRapidity", 500, -2.5, 2.5); histoFineBinning_GenN_plusPlusN_minusTTRapidity->Sumw2(); TH1F * histoFineBinning_GenN_plusMinusN_minusTTPt = new TH1F("FineBinning_GenN_plusMinusN_minusTTPt", "FineBinning_GenN_plusMinusN_minusTTPt", 250, 0, 250); histoFineBinning_GenN_plusMinusN_minusTTPt->Sumw2(); TH1F * histoFineBinning_GenN_plusPlusN_minusTTPt = new TH1F("FineBinning_GenN_plusPlusN_minusTTPt", "FineBinning_GenN_plusPlusN_minusTTPt", 250, 0, 250); histoFineBinning_GenN_plusPlusN_minusTTPt->Sumw2(); TH1F * histoFineBinning_GenN_plusMinusN_minusTTMass = new TH1F("FineBinning_GenN_plusMinusN_minusTTMass", "FineBinning_GenN_plusMinusN_minusTTMass", 100, 0, 1000); histoFineBinning_GenN_plusMinusN_minusTTMass->Sumw2(); TH1F * histoFineBinning_GenN_plusPlusN_minusTTMass = new TH1F("FineBinning_GenN_plusPlusN_minusTTMass", "FineBinning_GenN_plusPlusN_minusTTMass", 100, 0, 1000); histoFineBinning_GenN_plusPlusN_minusTTMass->Sumw2(); TH1F * histoFineBinning_GenA_cTTRapidity = new TH1F("FineBinning_GenA_cTTRapidity", "FineBinning_GenA_cTTRapidity", 500, -2.5, 2.5); histoFineBinning_GenA_cTTRapidity->Sumw2(); TH1F * histoFineBinning_GenA_cTTPt = new TH1F("FineBinning_GenA_cTTPt", "FineBinning_GenA_cTTPt", 250, 0, 250); histoFineBinning_GenA_cTTPt->Sumw2(); TH1F * histoFineBinning_GenA_cTTMass = new TH1F("FineBinning_GenA_cTTMass", "FineBinning_GenA_cTTMass", 100, 0, 1000); histoFineBinning_GenA_cTTMass->Sumw2(); // RECO TH1F * histoRecoTopRapidity1 = new TH1F("RecoTopRapidity1", "RecoTopRapidity1", 100, -5, 5); TH1F * histoRecoTopRapidity2 = new TH1F("RecoTopRapidity2", "RecoTopRapidity2", 100, -5, 5); TH1F * histoRecoLeptonRapidity1 = new TH1F("RecoLeptonRapidity1", "RecoLeptonRapidity1", 100, -5, 5); TH1F * histoRecoLeptonRapidity2 = new TH1F("RecoLeptonRapidity2", "RecoLeptonRapidity2", 100, -5, 5); TH1F * histoRecoTopMass1 = new TH1F("RecoTopMass1", "RecoTopMass1", 300, 0, 300); TH1F * histoRecoTopMass2 = new TH1F("RecoTopMass2", "RecoTopMass2", 300, 0, 300); TH2F * histoRecoTopMass1VsTopMass2 = new TH2F("RecoTopMass1VsTopMass2", "RecoTopMass1VsTopMass2", 300, 0, 300, 300, 0, 300); TH1F * histoRecoDelta_y = new TH1F("RecoDelta_y", "RecoDelta_y", 400, -2, 2); TH1F * histoRecoTTRapidity = new TH1F("RecoTTRapidity", "RecoTTRapidity", 500, -2.5, 2.5); TH1F * histoRecoTTPt = new TH1F("RecoTTPt", "RecoTTPt", 250, 0, 250); TH1F * histoRecoTTMass = new TH1F("RecoTTMass", "RecoTTMass", 100, 0, 1000); TH2F * histoRecoDelta_yVsTTRapidity = new TH2F("RecoDelta_yVsTTRapidity", "RecoDelta_yVsTTRapidity", 10, -2, 2, 5, -2.5, 2.5); TH2F * histoRecoDelta_yVsTTPt = new TH2F("RecoDelta_yVsTTPt", "RecoDelta_yVsTTPt", 10, -2, 2, 5, 0, 250); TH2F * histoRecoDelta_yVsTTMass = new TH2F("RecoDelta_yVsTTMass", "RecoDelta_yVsTTMass", 10, -2, 2, 5, 0, 1000); TH1F * histoRecoN_plusTTRapidity = new TH1F("RecoN_plusTTRapidity", "RecoN_plusTTRapidity", 20, -2.5, 2.5); histoRecoN_plusTTRapidity->Sumw2(); TH1F * histoRecoN_plusTTPt = new TH1F("RecoN_plusTTPt", "RecoN_plusTTPt", 20, 0, 250); histoRecoN_plusTTPt->Sumw2(); TH1F * histoRecoN_plusTTMass = new TH1F("RecoN_plusTTMass", "RecoN_plusTTMass", 20, 0, 1000); histoRecoN_plusTTMass->Sumw2(); TH1F * histoRecoN_minusTTRapidity = new TH1F("RecoN_minusTTRapidity", "RecoN_minusTTRapidity", 20, -2.5, 2.5); histoRecoN_minusTTRapidity->Sumw2(); TH1F * histoRecoN_minusTTPt = new TH1F("RecoN_minusTTPt", "RecoN_minusTTPt", 20, 0, 250); histoRecoN_minusTTPt->Sumw2(); TH1F * histoRecoN_minusTTMass = new TH1F("RecoN_minusTTMass", "RecoN_minusTTMass", 20, 0, 1000); histoRecoN_minusTTMass->Sumw2(); TH1F * histoRecoN_plusMinusN_minusTTRapidity = new TH1F("RecoN_plusMinusN_minusTTRapidity", "RecoN_plusMinusN_minusTTRapidity", 20, -2.5, 2.5); histoRecoN_plusMinusN_minusTTRapidity->Sumw2(); TH1F * histoRecoN_plusPlusN_minusTTRapidity = new TH1F("RecoN_plusPlusN_minusTTRapidity", "RecoN_plusPlusN_minusTTRapidity", 20, -2.5, 2.5); histoRecoN_plusPlusN_minusTTRapidity->Sumw2(); TH1F * histoRecoN_plusMinusN_minusTTPt = new TH1F("RecoN_plusMinusN_minusTTPt", "RecoN_plusMinusN_minusTTPt", 20, 0, 250); histoRecoN_plusMinusN_minusTTPt->Sumw2(); TH1F * histoRecoN_plusPlusN_minusTTPt = new TH1F("RecoN_plusPlusN_minusTTPt", "RecoN_plusPlusN_minusTTPt", 20, 0, 250); histoRecoN_plusPlusN_minusTTPt->Sumw2(); TH1F * histoRecoN_plusMinusN_minusTTMass = new TH1F("RecoN_plusMinusN_minusTTMass", "RecoN_plusMinusN_minusTTMass", 20, 0, 1000); histoRecoN_plusMinusN_minusTTMass->Sumw2(); TH1F * histoRecoN_plusPlusN_minusTTMass = new TH1F("RecoN_plusPlusN_minusTTMass", "RecoN_plusPlusN_minusTTMass", 20, 0, 1000); histoRecoN_plusPlusN_minusTTMass->Sumw2(); TH1F * histoRecoA_cTTRapidity = new TH1F("RecoA_cTTRapidity", "RecoA_cTTRapidity", 20, -2.5, 2.5); histoRecoA_cTTRapidity->Sumw2(); TH1F * histoRecoA_cTTPt = new TH1F("RecoA_cTTPt", "RecoA_cTTPt", 20, 0, 250); histoRecoA_cTTPt->Sumw2(); TH1F * histoRecoA_cTTMass = new TH1F("RecoA_cTTMass", "RecoA_cTTMass", 20, 0, 1000); histoRecoA_cTTMass->Sumw2(); // Fine binning TH2F * histoFineBinning_RecoDelta_yVsTTRapidity = new TH2F("FineBinning_RecoDelta_yVsTTRapidity", "FineBinning_RecoDelta_yVsTTRapidity", 200, -2, 2, 500, -2.5, 2.5); TH2F * histoFineBinning_RecoDelta_yVsTTPt = new TH2F("FineBinning_RecoDelta_yVsTTPt", "FineBinning_RecoDelta_yVsTTPt", 200, -2, 2, 250, 0, 250); TH2F * histoFineBinning_RecoDelta_yVsTTMass = new TH2F("FineBinning_RecoDelta_yVsTTMass", "FineBinning_RecoDelta_yVsTTMass", 200, -2, 2, 100, 0, 1000); TH1F * histoFineBinning_RecoN_plusTTRapidity = new TH1F("FineBinning_RecoN_plusTTRapidity", "FineBinning_RecoN_plusTTRapidity", 500, -2.5, 2.5); histoFineBinning_RecoN_plusTTRapidity->Sumw2(); TH1F * histoFineBinning_RecoN_plusTTPt = new TH1F("FineBinning_RecoN_plusTTPt", "FineBinning_RecoN_plusTTPt", 250, 0, 250); histoFineBinning_RecoN_plusTTPt->Sumw2(); TH1F * histoFineBinning_RecoN_plusTTMass = new TH1F("FineBinning_RecoN_plusTTMass", "FineBinning_RecoN_plusTTMass", 100, 0, 1000); histoFineBinning_RecoN_plusTTMass->Sumw2(); TH1F * histoFineBinning_RecoN_minusTTRapidity = new TH1F("FineBinning_RecoN_minusTTRapidity", "FineBinning_RecoN_minusTTRapidity", 500, -2.5, 2.5); histoFineBinning_RecoN_minusTTRapidity->Sumw2(); TH1F * histoFineBinning_RecoN_minusTTPt = new TH1F("FineBinning_RecoN_minusTTPt", "FineBinning_RecoN_minusTTPt", 250, 0, 250); histoFineBinning_RecoN_minusTTPt->Sumw2(); TH1F * histoFineBinning_RecoN_minusTTMass = new TH1F("FineBinning_RecoN_minusTTMass", "FineBinning_RecoN_minusTTMass", 100, 0, 1000); histoFineBinning_RecoN_minusTTMass->Sumw2(); TH1F * histoFineBinning_RecoN_plusMinusN_minusTTRapidity = new TH1F("FineBinning_RecoN_plusMinusN_minusTTRapidity", "FineBinning_RecoN_plusMinusN_minusTTRapidity", 500, -2.5, 2.5); histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Sumw2(); TH1F * histoFineBinning_RecoN_plusPlusN_minusTTRapidity = new TH1F("FineBinning_RecoN_plusPlusN_minusTTRapidity", "FineBinning_RecoN_plusPlusN_minusTTRapidity", 500, -2.5, 2.5); histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Sumw2(); TH1F * histoFineBinning_RecoN_plusMinusN_minusTTPt = new TH1F("FineBinning_RecoN_plusMinusN_minusTTPt", "FineBinning_RecoN_plusMinusN_minusTTPt", 250, 0, 250); histoFineBinning_RecoN_plusMinusN_minusTTPt->Sumw2(); TH1F * histoFineBinning_RecoN_plusPlusN_minusTTPt = new TH1F("FineBinning_RecoN_plusPlusN_minusTTPt", "FineBinning_RecoN_plusPlusN_minusTTPt", 250, 0, 250); histoFineBinning_RecoN_plusPlusN_minusTTPt->Sumw2(); TH1F * histoFineBinning_RecoN_plusMinusN_minusTTMass = new TH1F("FineBinning_RecoN_plusMinusN_minusTTMass", "FineBinning_RecoN_plusMinusN_minusTTMass", 100, 0, 1000); histoFineBinning_RecoN_plusMinusN_minusTTMass->Sumw2(); TH1F * histoFineBinning_RecoN_plusPlusN_minusTTMass = new TH1F("FineBinning_RecoN_plusPlusN_minusTTMass", "FineBinning_RecoN_plusPlusN_minusTTMass", 100, 0, 1000); histoFineBinning_RecoN_plusPlusN_minusTTMass->Sumw2(); TH1F * histoFineBinning_RecoA_cTTRapidity = new TH1F("FineBinning_RecoA_cTTRapidity", "FineBinning_RecoA_cTTRapidity", 500, -2.5, 2.5); histoFineBinning_RecoA_cTTRapidity->Sumw2(); TH1F * histoFineBinning_RecoA_cTTPt = new TH1F("FineBinning_RecoA_cTTPt", "FineBinning_RecoA_cTTPt", 250, 0, 250); histoFineBinning_RecoA_cTTPt->Sumw2(); TH1F * histoFineBinning_RecoA_cTTMass = new TH1F("FineBinning_RecoA_cTTMass", "FineBinning_RecoA_cTTMass", 100, 0, 1000); histoFineBinning_RecoA_cTTMass->Sumw2(); // RECO vs GEN TH2F * histoRecoVsGenTopRapidity1 = new TH2F("RecoVsGenTopRapidity1", "RecoVsGenTopRapidity1", 100, -5, 5, 100, -5, 5); TH2F * histoRecoVsGenTopRapidity2 = new TH2F("RecoVsGenTopRapidity2", "RecoVsGenTopRapidity2", 100, -5, 5, 100, -5, 5); TH2F * histoRecoVsGenTopMass1 = new TH2F("RecoVsGenTopMass1", "RecoVsGenTopMass1", 300, 0, 300, 200, 0, 200); TH2F * histoRecoVsGenTopMass2 = new TH2F("RecoVsGenTopMass2", "RecoVsGenTopMass2", 300, 0, 300, 200, 0, 200); TH1F * histoRecoMinusGenDivGenTopRapidity1 = new TH1F("RecoMinusGenDivGenTopRapidity1", "RecoMinusGenDivGenTopRapidity1", 100, -3, 3); TH1F * histoRecoMinusGenDivGenTopRapidity2 = new TH1F("RecoMinusGenDivGenTopRapidity2", "RecoMinusGenDivGenTopRapidity2", 100, -3, 3); TH1F * histoRecoMinusGenDivGenLeptonRapidity1 = new TH1F("RecoMinusGenDivGenLeptonRapidity1", "RecoMinusGenDivGenLeptonRapidity1", 100, -3, 3); TH1F * histoRecoMinusGenDivGenLeptonRapidity2 = new TH1F("RecoMinusGenDivGenLeptonRapidity2", "RecoMinusGenDivGenLeptonRapidity2", 100, -3, 3); TH1F * histoRecoMinusGenDivGenTopMass1 = new TH1F("RecoMinusGenDivGenTopMass1", "RecoMinusGenDivGenTopMass1", 100, -3, 3); TH1F * histoRecoMinusGenDivGenTopMass2 = new TH1F("RecoMinusGenDivGenTopMass2", "RecoMinusGenDivGenTopMass2", 100, -3, 3); TH2F * histoFineBinning_RecoVsGenDelta_y = new TH2F("FineBinning_RecoVsGenDelta_y", "FineBinning_RecoVsGenDelta_y", 400, -2, 2, 400, -2, 2); // Migration Matrix TH2F * histoRecoVsGenDelta_y = new TH2F("RecoVsGenDelta_y", "RecoVsGenDelta_y", 8, -2, 2, 16, -2, 2); // Migration Matrix TH1F * histoRecoMinusGenDivGenDelta_y = new TH1F("RecoMinusGenDivGenDelta_y", "RecoMinusGenDivGenDelta_y", 100, -3, 3); TH2F * histoRecoVsGenTTRapidity = new TH2F("RecoVsGenTTRapidity", "RecoVsGenTTRapidity", 500, -2.5, 2.5, 500, -2.5, 2.5); TH1F * histoRecoMinusGenDivGenTTRapidity = new TH1F("RecoMinusGenDivGenTTRapidity", "RecoMinusGenDivGenTTRapidity", 100, -3, 3); TH2F * histoRecoVsGenTTPt = new TH2F("RecoVsGenTTPt", "RecoVsGenTTPt", 250, 0, 250, 250, 0, 250); TH1F * histoRecoMinusGenDivGenTTPt = new TH1F("RecoMinusGenDivGenTTPt", "RecoMinusGenDivGenTTPt", 100, -3, 3); TH2F * histoRecoVsGenTTMass = new TH2F("RecoVsGenTTMass", "RecoVsGenTTMass", 100, 0, 1000, 100, 0, 1000); TH1F * histoRecoMinusGenDivGenTTMass = new TH1F("RecoMinusGenDivGenTTMass", "RecoMinusGenDivGenTTMass", 100, -3, 3); TH1F * histoDelta_yEfficiencyN = new TH1F("Delta_yEfficiencyN", "Delta_yEfficiencyN", 10, -2, 2); TH1F * histoDelta_yEfficiencyD = new TH1F("Delta_yEfficiencyD", "Delta_yEfficiencyD", 10, -2, 2); TH1F * histoDelta_yEfficiency = new TH1F("Delta_yEfficiency", "Delta_yEfficiency", 10, -2, 2); TH2F * histoDelta_yVsTTRapidityEfficiency = new TH2F("Delta_yVsTTRapidityEfficiency", "Delta_yVsTTRapidityEfficiency", 10, -2, 2, 5, -2.5, 2.5); TH2F * histoDelta_yVsTTPtEfficiency = new TH2F("Delta_yVsTTPtEfficiency", "Delta_yVsTTPtEfficiency", 10, -2, 2, 5, 0, 250); TH2F * histoDelta_yVsTTMassEfficiency = new TH2F("Delta_yVsTTMassEfficiency", "Delta_yVsTTMassEfficiency", 10, -2, 2, 5, 0, 1000); // Fine binning TH1F * histoFineBinning_Delta_yEfficiencyN = new TH1F("FineBinning_Delta_yEfficiencyN", "FineBinning_Delta_yEfficiencyN", 200, -2, 2); TH1F * histoFineBinning_Delta_yEfficiencyD = new TH1F("FineBinning_Delta_yEfficiencyD", "FineBinning_Delta_yEfficiencyD", 200, -2, 2); TH1F * histoFineBinning_Delta_yEfficiency = new TH1F("FineBinning_Delta_yEfficiency", "FineBinning_Delta_yEfficiency", 200, -2, 2); TH2F * histoFineBinning_Delta_yVsTTRapidityEfficiency = new TH2F("FineBinning_Delta_yVsTTRapidityEfficiency", "FineBinning_Delta_yVsTTRapidityEfficiency", 200, -2, 2, 500, -2.5, 2.5); TH2F * histoFineBinning_Delta_yVsTTPtEfficiency = new TH2F("FineBinning_Delta_yVsTTPtEfficiency", "FineBinning_Delta_yVsTTPtEfficiency", 200, -2, 2, 250, 0, 250); TH2F * histoFineBinning_Delta_yVsTTMassEfficiency = new TH2F("FineBinning_Delta_yVsTTMassEfficiency", "FineBinning_Delta_yVsTTMassEfficiency", 200, -2, 2, 100, 0, 1000); vector < Dataset > datasets; DiLeptonSelection sel; float Luminosity = 0; // 0: MC - 1: Data - 2 Data & MC int DataType = 0; int verbosity = -1; // Analysis variables int step; //4-vectors vector < TLorentzVector > nu1; vector < TLorentzVector > nu2; // TLorentzVector lvTop1_aux; //TLorentzVector lvTop2_aux; ////////////////////// ////////////////////// // Initialisation ////////////////////// AnalysisEnvironmentLoader anaEL (xmlFileName); anaEL.LoadSamples (datasets); // now the list of datasets written in the xml file is known anaEL.LoadDiLeptonSelection (sel); // now the parameters for the selection are given to the selection anaEL.LoadGeneralInfo(DataType, Luminosity, verbosity ); float weight_MC; int nEvents; int firstEvent; int initialEvents; anaEL.LoadAnalysisInfo("Run", "firstEvent", firstEvent); anaEL.LoadAnalysisInfo("Run", "nEvents", nEvents); anaEL.LoadAnalysisInfo("Run", "initialEvents", initialEvents); string channelName; anaEL.LoadAnalysisInfo("MassAnalysis", "ChannelName", channelName); anaEL.LoadWeight (sel); // now the parameters for SFBweight are initialized (for b-tag!) //****************************************** //Load Scale Factors for lepton efficiencies //****************************************** sel.LoadElScaleFactors(); sel.LoadMuScaleFactors(); sel.InitJESUnc(); bool nonskimmed = false; TopTree::NTEvent * event = 0; TFile * TupleFile = new TFile("TupleFileSkimmed_TTbarSemileptonicPowheg.root","RECREATE"); float mttbar_rec, mttbar_gen; float diffysquare_rec, diffysquare_gen; float diffabseta_rec, diffabseta_gen; float weight; float pt_ttbar, pt_ttbar_gen; float pz_ttbar, pz_ttbar_gen; float eta_ttbar_rec, eta_ttbar_gen; float y_ttbar_rec, y_ttbar_gen; float diffabsy_rec, diffabsy_gen; TTree *tree = new TTree("Tuple","Tuple"); tree->Branch("mttbar_rec",&mttbar_rec,"mttbar_rec/F"); tree->Branch("mttbar_gen",&mttbar_gen,"mttbar_gen/F"); tree->Branch("diffysquare_rec",&diffysquare_rec,"diffysquare_rec/F"); tree->Branch("diffysquare_gen",&diffysquare_gen,"diffysquare_gen/F"); tree->Branch("diffabseta_rec",&diffabseta_rec,"diffabseta_rec/F"); tree->Branch("diffabseta_gen",&diffabseta_gen,"diffabseta_gen/F"); tree->Branch("weight",&weight,"weight/F"); tree->Branch("pt_ttbar",&pt_ttbar,"pt_ttbar/F"); tree->Branch("pt_ttbar_gen",&pt_ttbar_gen,"pt_ttbar_gen/F"); tree->Branch("pz_ttbar",&pz_ttbar,"pz_ttbar/F"); tree->Branch("pz_ttbar_gen",&pz_ttbar_gen,"pz_ttbar_gen/F"); tree->Branch("eta_ttbar_rec",&eta_ttbar_rec,"eta_ttbar_rec/F"); tree->Branch("eta_ttbar_gen",&eta_ttbar_gen,"eta_ttbar_gen/F"); tree->Branch("y_ttbar_rec",&y_ttbar_rec,"y_ttbar_rec/F"); tree->Branch("y_ttbar_gen",&y_ttbar_gen,"y_ttbar_gen/F"); tree->Branch("diffabsy_rec",&diffabsy_rec,"diffabsy_rec/F"); tree->Branch("diffabsy_gen",&diffabsy_gen,"diffabsy_gen/F"); ////////////////////// //LOOP OVER THE DATASETS ////////////////////// if(verbosity>0) { cout<<"#########################"<<endl; cout<<" Loop over the datasets "<<endl; cout<<"#########################"<<endl; } float num_mttbar_eff = 0.; float den_mttbar_eff = 0.; for (unsigned int d = 0; d < datasets.size (); d++) { weight_MC = datasets[d].NormFactor()*Luminosity; if(datasets[d].isData() == true) weight_MC = 1.; cout << "isDATA" << endl; AMWT amwt(anaEL, datasets[d].isData()); TString sample_name(datasets[d].Name()); bool isData = datasets[d].isData (); datasets[d].eventTree ()->SetBranchAddress ("NTEvent",&event); cout << "Sample : " << sample_name<< endl; cout << "Data : " << isData<< endl; unsigned int nEventsSample = (int) (datasets[d].eventTree ()->GetEntries ()); unsigned int endEventToRun; if (firstEvent>nEventsSample) firstEvent = nEventsSample; if ((nEvents==-1)||((nEvents+firstEvent)>nEventsSample)) endEventToRun = nEventsSample; else endEventToRun = nEvents+firstEvent; cout << "Events to run: number / first / last / all: " << endEventToRun-firstEvent << " / " << firstEvent << " / " << endEventToRun << " / " << nEventsSample << endl; // Standard parameters for doFullSelection: bool applyEEScale = false; float EEScaleParam = 1.; bool applyEEResol = false; float EEResolParam = 1.; bool applyMEScale = false; float MEScaleParam = 1.; bool applyMEResol = false; float MEResolParam = 1.; bool applyMETS = false; float METScale = 1.; bool applyJES = false; float JESParam = 1.; bool applyJER = false; float JERFactor = 0.; ////////////////////// //LOOP OVER THE EVENTS ////////////////////// float N_plus_reco = 0; float N_minus_reco = 0; float N_plus_gen = 0; float N_minus_gen = 0; mttbar_rec = 0; mttbar_gen = 0; diffysquare_rec = 0; diffysquare_gen = 0; diffabseta_rec = 0; diffabseta_gen = 0; weight = weight_MC; pt_ttbar = 0; pt_ttbar_gen = 0; pz_ttbar = 0; pz_ttbar_gen = 0; eta_ttbar_rec = 0; eta_ttbar_gen = 0; y_ttbar_rec = 0; y_ttbar_gen = 0; diffabsy_rec = 0; diffabsy_gen = 0; for (unsigned int ievt = firstEvent; ievt < endEventToRun; ievt++) { // for (unsigned int ievt = 0; ievt < 10; ievt++) { datasets[d].eventTree ()->GetEntry (ievt); if(ievt%1000 == 0) cout << "number of processed events " << ievt << endl; if (verbosity >= 1) cout << "Event : "<< event->runNb<<" , " << event->lumiblock <<" , " << event->eventNb<<endl; if(!(event->TMEME == 10010 || event->TMEME == 10001 || event->TMEME == 1 || event->TMEME == 10 || event->TMEME == 10000 || event->TMEME == 11000 || event->TMEME == 10100 )) continue; string candType; vector<NTElectron> candElec; vector<NTMuon> candMuon; //Load event for the selection sel.LoadEvent(event); int finalCut = sel.doFullSelection(&(datasets[d]), channelName, false, /*print*/ verbosity, false, false, -1., -1., applyJES, JESParam, applyEEScale, EEScaleParam, applyEEResol, EEResolParam, applyMEScale, MEScaleParam, applyJER, JERFactor, applyMETS, METScale); TLorentzVector lvTop1_gen; TLorentzVector lvTop2_gen; TLorentzVector lvTop1plusTop2_gen; float yt_gen = 0.; float ytbar_gen = 0.; float Delta_y_gen = 0.; if(datasets[d].Name() == "TTJets_Sig"){ lvTop1_gen = (event->topAndDecays)[0].p4_t_gen; lvTop2_gen = (event->topAndDecays)[1].p4_t_gen; lvTop1plusTop2_gen = lvTop1_gen + lvTop2_gen; ///////////////////////// //// GENERATOR LEVEL //// ///////////////////////// histoGenTopRapidity1->Fill(lvTop1_gen.Rapidity()); histoGenTopRapidity2->Fill(lvTop2_gen.Rapidity()); histoGenTopMass1->Fill(lvTop1_gen.M()); histoGenTopMass2->Fill(lvTop2_gen.M()); histoGenTopMass1VsTopMass2->Fill(lvTop1_gen.M(),lvTop2_gen.M()); yt_gen = lvTop1_gen.Rapidity(); if(yt_gen<0.) yt_gen = (-1)*yt_gen; ytbar_gen = lvTop2_gen.Rapidity(); if(ytbar_gen<0.) ytbar_gen = (-1)*ytbar_gen; Delta_y_gen = yt_gen - ytbar_gen; // cout << "Delta_y_gen:" << Delta_y_gen << endl; histoGenDelta_y->Fill(Delta_y_gen); histoDelta_yEfficiencyD->Fill(Delta_y_gen); histoFineBinning_Delta_yEfficiencyD->Fill(Delta_y_gen); if(Delta_y_gen>0.){ N_plus_gen++; histoGenN_plusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity()); histoGenN_plusTTPt->Fill(lvTop1plusTop2_gen.Perp()); histoGenN_plusTTMass->Fill(lvTop1plusTop2_gen.M()); histoFineBinning_GenN_plusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity()); histoFineBinning_GenN_plusTTPt->Fill(lvTop1plusTop2_gen.Perp()); histoFineBinning_GenN_plusTTMass->Fill(lvTop1plusTop2_gen.M()); } if(Delta_y_gen<0.){ N_minus_gen++; histoGenN_minusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity()); histoGenN_minusTTPt->Fill(lvTop1plusTop2_gen.Perp()); histoGenN_minusTTMass->Fill(lvTop1plusTop2_gen.M()); histoFineBinning_GenN_minusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity()); histoFineBinning_GenN_minusTTPt->Fill(lvTop1plusTop2_gen.Perp()); histoFineBinning_GenN_minusTTMass->Fill(lvTop1plusTop2_gen.M()); } histoGenTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity()); histoGenTTPt->Fill(lvTop1plusTop2_gen.Perp()); histoGenTTMass->Fill(lvTop1plusTop2_gen.M()); histoGenDelta_yVsTTRapidity->Fill(Delta_y_gen, lvTop1plusTop2_gen.Rapidity()); histoGenDelta_yVsTTPt->Fill(Delta_y_gen, lvTop1plusTop2_gen.Perp()); histoGenDelta_yVsTTMass->Fill(Delta_y_gen, lvTop1plusTop2_gen.M()); histoFineBinning_GenDelta_yVsTTRapidity->Fill(Delta_y_gen, lvTop1plusTop2_gen.Rapidity()); histoFineBinning_GenDelta_yVsTTPt->Fill(Delta_y_gen, lvTop1plusTop2_gen.Perp()); histoFineBinning_GenDelta_yVsTTMass->Fill(Delta_y_gen, lvTop1plusTop2_gen.M()); if(nonskimmed == true){ mttbar_gen = lvTop1plusTop2_gen.M(); diffysquare_gen = yt_gen*yt_gen - ytbar_gen*ytbar_gen; diffabseta_gen = fabs(lvTop1_gen.Eta()) - fabs(lvTop2_gen.Eta()); pt_ttbar_gen = lvTop1plusTop2_gen.Perp(); pz_ttbar_gen = lvTop1plusTop2_gen.Pz(); eta_ttbar_gen = lvTop1plusTop2_gen.Eta(); y_ttbar_gen = lvTop1plusTop2_gen.Rapidity(); diffabsy_gen = fabs(lvTop1_gen.Rapidity()) - fabs(lvTop2_gen.Rapidity()); } } if (finalCut >6) { if(nonskimmed == false){ if(datasets[d].Name() == "TTJets_Sig"){ mttbar_gen = lvTop1plusTop2_gen.M(); diffysquare_gen = yt_gen*yt_gen - ytbar_gen*ytbar_gen; diffabseta_gen = fabs(lvTop1_gen.Eta()) - fabs(lvTop2_gen.Eta()); pt_ttbar_gen = lvTop1plusTop2_gen.Perp(); pz_ttbar_gen = lvTop1plusTop2_gen.Pz(); eta_ttbar_gen = lvTop1plusTop2_gen.Eta(); y_ttbar_gen = lvTop1plusTop2_gen.Rapidity(); diffabsy_gen = fabs(lvTop1_gen.Rapidity()) - fabs(lvTop2_gen.Rapidity()); } } sel.GetLeptonPair(candMuon, candElec, candType); for(unsigned int i=0; i<candMuon.size(); i++){ if(candMuon[i].Charge == +1) histoRecoLeptonRapidity1->Fill(candMuon[i].p4.Rapidity()); if(candMuon[i].Charge == -1) histoRecoLeptonRapidity2->Fill(candMuon[i].p4.Rapidity()); } for(unsigned int j=0; j<candElec.size(); j++){ if(candElec[j].Charge == +1) histoRecoLeptonRapidity1->Fill(candElec[j].p4.Rapidity()); if(candElec[j].Charge == -1) histoRecoLeptonRapidity2->Fill(candElec[j].p4.Rapidity()); } TLorentzVector lvTop1_reco; TLorentzVector lvTop2_reco; TLorentzVector lvTop1plusTop2_reco; TopMassVariables * tmv = amwt.findMass(sel, lvTop1_reco, lvTop2_reco); lvTop1plusTop2_reco = lvTop1_reco + lvTop2_reco; //////////////////// /// RECO LEVEL ///// //////////////////// histoRecoTopRapidity1->Fill(lvTop1_reco.Rapidity()); histoRecoTopRapidity2->Fill(lvTop2_reco.Rapidity()); histoRecoTopMass1->Fill(lvTop1_reco.M()); histoRecoTopMass2->Fill(lvTop2_reco.M()); histoRecoTopMass1VsTopMass2->Fill(lvTop1_reco.M(),lvTop2_reco.M()); float yt_reco = lvTop1_reco.Rapidity(); if(yt_reco<0.) yt_reco = (-1)*yt_reco; float ytbar_reco = lvTop2_reco.Rapidity(); if(ytbar_reco<0.) ytbar_reco = (-1)*ytbar_reco; float Delta_y_reco = yt_reco - ytbar_reco; // cout << "Delta_y_reco:" << Delta_y_reco << endl; histoRecoDelta_y->Fill(Delta_y_reco); histoDelta_yEfficiencyN->Fill(Delta_y_reco); histoFineBinning_Delta_yEfficiencyN->Fill(Delta_y_reco); if(Delta_y_reco>0.){ N_plus_reco++; histoRecoN_plusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity()); histoRecoN_plusTTPt->Fill(lvTop1plusTop2_reco.Perp()); histoRecoN_plusTTMass->Fill(lvTop1plusTop2_reco.M()); histoFineBinning_RecoN_plusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity()); histoFineBinning_RecoN_plusTTPt->Fill(lvTop1plusTop2_reco.Perp()); histoFineBinning_RecoN_plusTTMass->Fill(lvTop1plusTop2_reco.M()); } if(Delta_y_reco<0.){ N_minus_reco++; histoRecoN_minusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity()); histoRecoN_minusTTPt->Fill(lvTop1plusTop2_reco.Perp()); histoRecoN_minusTTMass->Fill(lvTop1plusTop2_reco.M()); histoFineBinning_RecoN_minusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity()); histoFineBinning_RecoN_minusTTPt->Fill(lvTop1plusTop2_reco.Perp()); histoFineBinning_RecoN_minusTTMass->Fill(lvTop1plusTop2_reco.M()); } histoRecoTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity()); histoRecoTTPt->Fill(lvTop1plusTop2_reco.Perp()); histoRecoTTMass->Fill(lvTop1plusTop2_reco.M()); histoRecoDelta_yVsTTRapidity->Fill(Delta_y_reco, lvTop1plusTop2_reco.Rapidity()); histoRecoDelta_yVsTTPt->Fill(Delta_y_reco, lvTop1plusTop2_reco.Perp()); histoRecoDelta_yVsTTMass->Fill(Delta_y_reco, lvTop1plusTop2_reco.M()); histoFineBinning_RecoDelta_yVsTTRapidity->Fill(Delta_y_reco, lvTop1plusTop2_reco.Rapidity()); histoFineBinning_RecoDelta_yVsTTPt->Fill(Delta_y_reco, lvTop1plusTop2_reco.Perp()); histoFineBinning_RecoDelta_yVsTTMass->Fill(Delta_y_reco, lvTop1plusTop2_reco.M()); if(nonskimmed == false){ mttbar_rec = lvTop1plusTop2_reco.M(); diffysquare_rec = yt_reco*yt_reco - ytbar_reco*ytbar_reco; diffabseta_rec = fabs(lvTop1_reco.Eta()) - fabs(lvTop2_reco.Eta()); pt_ttbar = lvTop1plusTop2_reco.Perp(); pz_ttbar = lvTop1plusTop2_reco.Pz(); eta_ttbar_rec = lvTop1plusTop2_reco.Eta(); y_ttbar_rec = lvTop1plusTop2_reco.Rapidity(); diffabsy_rec = fabs(lvTop1_reco.Rapidity()) - fabs(lvTop2_reco.Rapidity()); } //////////////////////// // RECO VS GEN LEVEL /// //////////////////////// if(datasets[d].Name() == "TTJets_Sig"){ histoRecoVsGenTopRapidity1->Fill(lvTop1_reco.Rapidity(), lvTop1_gen.Rapidity()); histoRecoVsGenTopRapidity2->Fill(lvTop2_reco.Rapidity(), lvTop2_gen.Rapidity()); histoRecoVsGenTopMass1->Fill(lvTop1_reco.M(), lvTop1_gen.M()); histoRecoVsGenTopMass2->Fill(lvTop2_reco.M(), lvTop2_gen.M()); histoRecoMinusGenDivGenTopRapidity1->Fill((lvTop1_reco.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity()); histoRecoMinusGenDivGenTopRapidity2->Fill((lvTop2_reco.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity()); for(unsigned int i=0; i<candMuon.size(); i++){ if(candMuon[i].Charge == +1) histoRecoMinusGenDivGenLeptonRapidity1->Fill((candMuon[i].p4.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity()); if(candMuon[i].Charge == -1) histoRecoMinusGenDivGenLeptonRapidity2->Fill((candMuon[i].p4.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity()); } for(unsigned int j=0; j<candElec.size(); j++){ if(candElec[j].Charge == +1) histoRecoMinusGenDivGenLeptonRapidity1->Fill((candElec[j].p4.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity()); if(candElec[j].Charge == -1) histoRecoMinusGenDivGenLeptonRapidity2->Fill((candElec[j].p4.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity()); } histoRecoMinusGenDivGenTopMass1->Fill((lvTop1_reco.M() - lvTop1_gen.M())/lvTop1_gen.M()); histoRecoMinusGenDivGenTopMass2->Fill((lvTop2_reco.M() - lvTop2_gen.M())/lvTop2_gen.M()); histoRecoVsGenDelta_y->Fill(Delta_y_reco, Delta_y_gen); histoFineBinning_RecoVsGenDelta_y->Fill(Delta_y_reco, Delta_y_gen); histoRecoMinusGenDivGenDelta_y->Fill((Delta_y_reco - Delta_y_gen)/Delta_y_gen); histoRecoVsGenTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity(),lvTop1plusTop2_gen.Rapidity()); histoRecoMinusGenDivGenTTRapidity->Fill((lvTop1plusTop2_reco.Rapidity() - lvTop1plusTop2_gen.Rapidity())/lvTop1plusTop2_gen.Rapidity()); histoRecoVsGenTTPt->Fill(lvTop1plusTop2_reco.Perp(),lvTop1plusTop2_gen.Perp()); histoRecoMinusGenDivGenTTPt->Fill((lvTop1plusTop2_reco.Perp() - lvTop1plusTop2_gen.Perp())/lvTop1plusTop2_gen.Perp()); histoRecoVsGenTTMass->Fill(lvTop1plusTop2_reco.M(),lvTop1plusTop2_gen.M()); histoRecoMinusGenDivGenTTMass->Fill((lvTop1plusTop2_reco.M() - lvTop1plusTop2_gen.M())/lvTop1plusTop2_gen.M()); } // tmv->printAll(); delete tmv; if(nonskimmed == false && mttbar_rec > 60.){ tree->Fill(); num_mttbar_eff += weight_MC;} if(nonskimmed == false) den_mttbar_eff += weight_MC; } if(nonskimmed == true) tree->Fill(); } // end of loop over evts float A_C_reco = (N_plus_reco - N_minus_reco)/(N_plus_reco + N_minus_reco); float A_C_gen = (N_plus_gen - N_minus_gen)/(N_plus_gen + N_minus_gen); cout << "A_C_gen:" << A_C_gen << endl; cout << "A_C_reco:" << A_C_reco << endl; histoGenN_plusMinusN_minusTTRapidity->Add(histoGenN_plusTTRapidity); histoGenN_plusMinusN_minusTTRapidity->Add(histoGenN_minusTTRapidity,-1); histoGenN_plusPlusN_minusTTRapidity->Add(histoGenN_plusTTRapidity); histoGenN_plusPlusN_minusTTRapidity->Add(histoGenN_minusTTRapidity); histoGenA_cTTRapidity->Divide(histoGenN_plusMinusN_minusTTRapidity, histoGenN_plusPlusN_minusTTRapidity); histoGenN_plusMinusN_minusTTPt->Add(histoGenN_plusTTPt); histoGenN_plusMinusN_minusTTPt->Add(histoGenN_minusTTPt,-1); histoGenN_plusPlusN_minusTTPt->Add(histoGenN_plusTTPt); histoGenN_plusPlusN_minusTTPt->Add(histoGenN_minusTTPt); histoGenA_cTTPt->Divide(histoGenN_plusMinusN_minusTTPt, histoGenN_plusPlusN_minusTTPt); histoGenN_plusMinusN_minusTTMass->Add(histoGenN_plusTTMass); histoGenN_plusMinusN_minusTTMass->Add(histoGenN_minusTTMass,-1); histoGenN_plusPlusN_minusTTMass->Add(histoGenN_plusTTMass); histoGenN_plusPlusN_minusTTMass->Add(histoGenN_minusTTMass); histoGenA_cTTMass->Divide(histoGenN_plusMinusN_minusTTMass, histoGenN_plusPlusN_minusTTMass); histoRecoN_plusMinusN_minusTTRapidity->Add(histoRecoN_plusTTRapidity); histoRecoN_plusMinusN_minusTTRapidity->Add(histoRecoN_minusTTRapidity,-1); histoRecoN_plusPlusN_minusTTRapidity->Add(histoRecoN_plusTTRapidity); histoRecoN_plusPlusN_minusTTRapidity->Add(histoRecoN_minusTTRapidity); histoRecoA_cTTRapidity->Divide(histoRecoN_plusMinusN_minusTTRapidity, histoRecoN_plusPlusN_minusTTRapidity); histoRecoN_plusMinusN_minusTTPt->Add(histoRecoN_plusTTPt); histoRecoN_plusMinusN_minusTTPt->Add(histoRecoN_minusTTPt,-1); histoRecoN_plusPlusN_minusTTPt->Add(histoRecoN_plusTTPt); histoRecoN_plusPlusN_minusTTPt->Add(histoRecoN_minusTTPt); histoRecoA_cTTPt->Divide(histoRecoN_plusMinusN_minusTTPt, histoRecoN_plusPlusN_minusTTPt); histoRecoN_plusMinusN_minusTTMass->Add(histoRecoN_plusTTMass); histoRecoN_plusMinusN_minusTTMass->Add(histoRecoN_minusTTMass,-1); histoRecoN_plusPlusN_minusTTMass->Add(histoRecoN_plusTTMass); histoRecoN_plusPlusN_minusTTMass->Add(histoRecoN_minusTTMass); histoRecoA_cTTMass->Divide(histoRecoN_plusMinusN_minusTTMass, histoRecoN_plusPlusN_minusTTMass); histoFineBinning_GenN_plusMinusN_minusTTRapidity->Add(histoFineBinning_GenN_plusTTRapidity); histoFineBinning_GenN_plusMinusN_minusTTRapidity->Add(histoFineBinning_GenN_minusTTRapidity,-1); histoFineBinning_GenN_plusPlusN_minusTTRapidity->Add(histoFineBinning_GenN_plusTTRapidity); histoFineBinning_GenN_plusPlusN_minusTTRapidity->Add(histoFineBinning_GenN_minusTTRapidity); histoFineBinning_GenA_cTTRapidity->Divide(histoFineBinning_GenN_plusMinusN_minusTTRapidity, histoFineBinning_GenN_plusPlusN_minusTTRapidity); histoFineBinning_GenN_plusMinusN_minusTTPt->Add(histoFineBinning_GenN_plusTTPt); histoFineBinning_GenN_plusMinusN_minusTTPt->Add(histoFineBinning_GenN_minusTTPt,-1); histoFineBinning_GenN_plusPlusN_minusTTPt->Add(histoFineBinning_GenN_plusTTPt); histoFineBinning_GenN_plusPlusN_minusTTPt->Add(histoFineBinning_GenN_minusTTPt); histoFineBinning_GenA_cTTPt->Divide(histoFineBinning_GenN_plusMinusN_minusTTPt, histoFineBinning_GenN_plusPlusN_minusTTPt); histoFineBinning_GenN_plusMinusN_minusTTMass->Add(histoFineBinning_GenN_plusTTMass); histoFineBinning_GenN_plusMinusN_minusTTMass->Add(histoFineBinning_GenN_minusTTMass,-1); histoFineBinning_GenN_plusPlusN_minusTTMass->Add(histoFineBinning_GenN_plusTTMass); histoFineBinning_GenN_plusPlusN_minusTTMass->Add(histoFineBinning_GenN_minusTTMass); histoFineBinning_GenA_cTTMass->Divide(histoFineBinning_GenN_plusMinusN_minusTTMass, histoFineBinning_GenN_plusPlusN_minusTTMass); histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Add(histoFineBinning_RecoN_plusTTRapidity); histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Add(histoFineBinning_RecoN_minusTTRapidity,-1); histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Add(histoFineBinning_RecoN_plusTTRapidity); histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Add(histoFineBinning_RecoN_minusTTRapidity); histoFineBinning_RecoA_cTTRapidity->Divide(histoFineBinning_RecoN_plusMinusN_minusTTRapidity, histoFineBinning_RecoN_plusPlusN_minusTTRapidity); histoFineBinning_RecoN_plusMinusN_minusTTPt->Add(histoFineBinning_RecoN_plusTTPt); histoFineBinning_RecoN_plusMinusN_minusTTPt->Add(histoFineBinning_RecoN_minusTTPt,-1); histoFineBinning_RecoN_plusPlusN_minusTTPt->Add(histoFineBinning_RecoN_plusTTPt); histoFineBinning_RecoN_plusPlusN_minusTTPt->Add(histoFineBinning_RecoN_minusTTPt); histoFineBinning_RecoA_cTTPt->Divide(histoFineBinning_RecoN_plusMinusN_minusTTPt, histoFineBinning_RecoN_plusPlusN_minusTTPt); histoFineBinning_RecoN_plusMinusN_minusTTMass->Add(histoFineBinning_RecoN_plusTTMass); histoFineBinning_RecoN_plusMinusN_minusTTMass->Add(histoFineBinning_RecoN_minusTTMass,-1); histoFineBinning_RecoN_plusPlusN_minusTTMass->Add(histoFineBinning_RecoN_plusTTMass); histoFineBinning_RecoN_plusPlusN_minusTTMass->Add(histoFineBinning_RecoN_minusTTMass); histoFineBinning_RecoA_cTTMass->Divide(histoFineBinning_RecoN_plusMinusN_minusTTMass, histoFineBinning_RecoN_plusPlusN_minusTTMass); histoDelta_yEfficiency->Divide(histoDelta_yEfficiencyN, histoDelta_yEfficiencyD); histoFineBinning_Delta_yEfficiency->Divide(histoFineBinning_Delta_yEfficiencyN, histoFineBinning_Delta_yEfficiencyD); for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) { for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) { float value = histoRecoDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2); histoDelta_yVsTTRapidityEfficiency->SetBinContent(bin_index1, bin_index2, value); float value_fb = histoFineBinning_RecoDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2); histoFineBinning_Delta_yVsTTRapidityEfficiency->SetBinContent(bin_index1, bin_index2, value_fb); } } for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) { for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) { float value = histoRecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2); histoDelta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value); float value_fb = histoFineBinning_RecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2); histoFineBinning_Delta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value_fb); } } for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) { for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) { float value = histoRecoDelta_yVsTTMass->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTMass->GetBinContent(bin_index1,bin_index2); histoDelta_yVsTTMassEfficiency->SetBinContent(bin_index1, bin_index2, value); float value_fb = histoFineBinning_RecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2); histoFineBinning_Delta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value_fb); } } } // end of loop over the datasets // if(verbosity>0) { cout<<"#########################"<<endl; cout<<" End of the program "<<endl; cout<<"#########################"<<endl; // } tree->Print(); TupleFile->Write(); TupleFile->Close(); TFile * fileCA = new TFile("ChargeAsymmetryResults_Skimmed_TTbarSemileptonicPowheg.root","RECREATE"); // fileCA->cd(); // GEN histoGenTopRapidity1->Write(); histoGenTopRapidity2->Write(); histoGenTopMass1->Write(); histoGenTopMass2->Write(); histoGenTopMass1VsTopMass2->Write(); histoGenDelta_y->Write(); histoGenTTRapidity->Write(); histoGenTTPt->Write(); histoGenTTMass->Write(); histoGenDelta_yVsTTRapidity->Write(); histoGenDelta_yVsTTPt->Write(); histoGenDelta_yVsTTMass->Write(); histoGenN_plusTTRapidity->Write(); histoGenN_plusTTPt->Write(); histoGenN_plusTTMass->Write(); histoGenN_minusTTRapidity->Write(); histoGenN_minusTTPt->Write(); histoGenN_minusTTMass->Write(); histoGenN_plusMinusN_minusTTRapidity->Write(); histoGenN_plusPlusN_minusTTRapidity->Write(); histoGenN_plusMinusN_minusTTPt->Write(); histoGenN_plusPlusN_minusTTPt->Write(); histoGenN_plusMinusN_minusTTMass->Write(); histoGenN_plusPlusN_minusTTMass->Write(); histoGenA_cTTRapidity->Write(); histoGenA_cTTPt->Write(); histoGenA_cTTMass->Write(); histoFineBinning_GenDelta_yVsTTRapidity->Write(); histoFineBinning_GenDelta_yVsTTPt->Write(); histoFineBinning_GenDelta_yVsTTMass->Write(); histoFineBinning_GenN_plusTTRapidity->Write(); histoFineBinning_GenN_plusTTPt->Write(); histoFineBinning_GenN_plusTTMass->Write(); histoFineBinning_GenN_minusTTRapidity->Write(); histoFineBinning_GenN_minusTTPt->Write(); histoFineBinning_GenN_minusTTMass->Write(); histoFineBinning_GenN_plusMinusN_minusTTRapidity->Write(); histoFineBinning_GenN_plusPlusN_minusTTRapidity->Write(); histoFineBinning_GenN_plusMinusN_minusTTPt->Write(); histoFineBinning_GenN_plusPlusN_minusTTPt->Write(); histoFineBinning_GenN_plusMinusN_minusTTMass->Write(); histoFineBinning_GenN_plusPlusN_minusTTMass->Write(); histoFineBinning_GenA_cTTRapidity->Write(); histoFineBinning_GenA_cTTPt->Write(); histoFineBinning_GenA_cTTMass->Write(); // RECO histoRecoTopRapidity1->Write(); histoRecoTopRapidity2->Write(); histoRecoLeptonRapidity1->Write(); histoRecoLeptonRapidity2->Write(); histoRecoTopMass1->Write(); histoRecoTopMass2->Write(); histoRecoTopMass1VsTopMass2->Write(); histoRecoDelta_y->Write(); histoRecoTTRapidity->Write(); histoRecoTTPt->Write(); histoRecoTTMass->Write(); histoRecoDelta_yVsTTRapidity->Write(); histoRecoDelta_yVsTTPt->Write(); histoRecoDelta_yVsTTMass->Write(); histoRecoN_plusTTRapidity->Write(); histoRecoN_plusTTPt->Write(); histoRecoN_plusTTMass->Write(); histoRecoN_minusTTRapidity->Write(); histoRecoN_minusTTPt->Write(); histoRecoN_minusTTMass->Write(); histoRecoN_plusMinusN_minusTTRapidity->Write(); histoRecoN_plusPlusN_minusTTRapidity->Write(); histoRecoN_plusMinusN_minusTTPt->Write(); histoRecoN_plusPlusN_minusTTPt->Write(); histoRecoN_plusMinusN_minusTTMass->Write(); histoRecoN_plusPlusN_minusTTMass->Write(); histoRecoA_cTTRapidity->Write(); histoRecoA_cTTPt->Write(); histoRecoA_cTTMass->Write(); histoFineBinning_RecoDelta_yVsTTRapidity->Write(); histoFineBinning_RecoDelta_yVsTTPt->Write(); histoFineBinning_RecoDelta_yVsTTMass->Write(); histoFineBinning_RecoN_plusTTRapidity->Write(); histoFineBinning_RecoN_plusTTPt->Write(); histoFineBinning_RecoN_plusTTMass->Write(); histoFineBinning_RecoN_minusTTRapidity->Write(); histoFineBinning_RecoN_minusTTPt->Write(); histoFineBinning_RecoN_minusTTMass->Write(); histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Write(); histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Write(); histoFineBinning_RecoN_plusMinusN_minusTTPt->Write(); histoFineBinning_RecoN_plusPlusN_minusTTPt->Write(); histoFineBinning_RecoN_plusMinusN_minusTTMass->Write(); histoFineBinning_RecoN_plusPlusN_minusTTMass->Write(); histoFineBinning_RecoA_cTTRapidity->Write(); histoFineBinning_RecoA_cTTPt->Write(); histoFineBinning_RecoA_cTTMass->Write(); // RECO vs GEN histoRecoVsGenTopRapidity1->Write(); histoRecoVsGenTopRapidity2->Write(); histoRecoMinusGenDivGenLeptonRapidity1->Write(); histoRecoMinusGenDivGenLeptonRapidity2->Write(); histoRecoMinusGenDivGenTopRapidity1->Write(); histoRecoMinusGenDivGenTopRapidity2->Write(); histoRecoVsGenTopMass1->Write(); histoRecoVsGenTopMass2->Write(); histoRecoMinusGenDivGenTopMass1->Write(); histoRecoMinusGenDivGenTopMass2->Write(); histoRecoVsGenDelta_y->Write(); histoFineBinning_RecoVsGenDelta_y->Write(); histoRecoMinusGenDivGenDelta_y->Write(); histoRecoVsGenTTRapidity->Write(); histoRecoMinusGenDivGenTTRapidity->Write(); histoRecoVsGenTTPt->Write(); histoRecoMinusGenDivGenTTPt->Write(); histoRecoVsGenTTMass->Write(); histoRecoMinusGenDivGenTTMass->Write(); histoDelta_yEfficiencyN->Write(); histoDelta_yEfficiencyD->Write(); histoDelta_yEfficiency->Write(); histoDelta_yVsTTRapidityEfficiency->Write(); histoDelta_yVsTTPtEfficiency->Write(); histoDelta_yVsTTMassEfficiency->Write(); histoFineBinning_Delta_yEfficiencyN->Write(); histoFineBinning_Delta_yEfficiencyD->Write(); histoFineBinning_Delta_yEfficiency->Write(); histoFineBinning_Delta_yVsTTRapidityEfficiency->Write(); histoFineBinning_Delta_yVsTTPtEfficiency->Write(); histoFineBinning_Delta_yVsTTMassEfficiency->Write(); // fileCA->Write(); fileCA->Close(); delete fileCA; cout << "num_mttbar_eff = " << num_mttbar_eff << endl; cout << "den_mttbar_eff = " << den_mttbar_eff << endl; cout << "mttbar_eff = " << num_mttbar_eff / den_mttbar_eff << endl; return (0); }
void dNdeta_dAu(int i){ TFile *f = TFile::Open(Form("phhijing_dAu_%d.root",i)); TTree *tree = (TTree*)f->Get("T"); TBranchElement *array = (TBranchElement*)T->GetBranch("part_array"); tree->SetMakeClass(1); TH1::SetDefaultSumw2(kTRUE); const int ncent = 3; TH1F* hKF = new TH1F("hKF","particle id",10000,-5000,5000); TH1F* hn = new TH1F("hn","Ntotal",1000,0,1000); TH2F* hnchntrk = new TH2F("hnchntrk","",300,0,300,100,0,100); TH2F* hNbinary = new TH2F("hNbinary","Nbinary",300,0,300,300,0,300); TH2F* hb = new TH2F("hb","bimpact",300,0,300,200,0,20); TH1F* hnchtotal = new TH1F("hnchtotal","Nchargetotal",500,0,500); TH2F* hNbinarymbtrig = new TH2F("hNbinarymbtrig","Nbinary",300,0,300,300,0,300); TH2F* hbmbtrig = new TH2F("hbmbtrig","bimpact",300,0,300,200,0,20); TH2F* hnchntrkmbtrig = new TH2F("hnchntrkmbtrig","",300,0,300,100,0,100); TH1F* heta = new TH1F("heta","particle eta distr",120,-6,6); TH1F* hy = new TH1F("hy","particle y distr",120,-6,6); TH1F* hy1 = new TH1F("hy1","particle y distr in |y|<1",150,-1.5,1.5); TH1F* hphi = new TH1F("hphi","",200,0,8); TH1F* hMass= new TH1F("hMass","mass distribution",500,0,5); TH2F* hpteta[ncent]; TH2F* hptetambtrig[ncent]; TH2F* hpty[ncent]; TH2F* hptymbtrig[ncent]; for(int icent=0;icent<ncent;icent++){ hpteta[icent] = new TH2F(Form("hpteta_%d",icent),"",100,0,10,120,-6,6); hptetambtrig[icent] = new TH2F(Form("hptetambtrig_%d",icent),"",100,0,10,120,-6,6); hpty[icent] = new TH2F(Form("hpty_%d",icent),"",100,0,10,120,-6,6); hptymbtrig[icent] = new TH2F(Form("hptymbtrig_%d",icent),"",100,0,10,120,-6,6); } int Nbinary; float b; float px[MAXP]; float py[MAXP]; float pz[MAXP]; float E[MAXP]; int KS[MAXP]; int KF[MAXP]; float M[MAXP]; int n; int nPion = 0; int nPrim = 0; int nSecond = 0; int nPionC = 0; int nKaonC = 0; int nout=0; tree->SetBranchAddress("nbin",&Nbinary); tree->SetBranchAddress("bimpact",&b); tree->SetBranchAddress("part_array.fKS",&KS); tree->SetBranchAddress("part_array.fKF",&KF); tree->SetBranchAddress("part_array.fPx",&px); tree->SetBranchAddress("part_array.fPy",&py); tree->SetBranchAddress("part_array.fPz",&pz); tree->SetBranchAddress("part_array.fEnergy",&E); tree->SetBranchAddress("part_array.fMass",&M); array->SetAddress(&n); for(int ievent = 0;ievent < tree->GetEntries(); ievent++){ int nch = 0; int nchtotal = 0; int ntrk = 0; int nbbcau = 0; int nbbcde = 0; tree->GetEntry(ievent); // array->GetEntry(ievent); // int n = array->GetNdata(); if(n>MAXP) {cout<<n<<"!"<<endl; continue;} if(ievent%10000==0) cout<<ievent<<endl; for(int iparticle = 0;iparticle < n; iparticle++){ // if(KS[iparticle] < 1 || KS[iparticle] > 10) continue; // if(iparticle>10000) cout<<KF[iparticle]<<" "; hKF->Fill(KF[iparticle]); if(KF[iparticle] == 111) nPion++; if(fabs(KF[iparticle]) == 211) nPionC++; if(fabs(KF[iparticle]) == 321) nKaonC++; if(fabs(KF[iparticle]) > 5000) nout++; // if(KF[iparticle]!=313 && KF[iparticle]!=421 && KF[iparticle]!=311 && KF[iparticle]!d221 && KF[iparticle]!=111 && KF[iparticle]!=223 && KF[iparticle]!=333 && KF[iparticle]!=443 && KF[iparticle]!=2112 && KF[iparticle]!=3122) nch++; if(!(fabs(KF[iparticle]) == 211 || fabs(KF[iparticle]) == 213 || fabs(KF[iparticle]) == 321 || fabs(KF[iparticle]) == 323 ||fabs(KF[iparticle]) == 2212)) continue; if(KS[iparticle]==1) nPrim++; if(KS[iparticle]==11) nSecond++; hMass->Fill(M[iparticle]); // if(KS[iparticle]!=1) continue; float pt = sqrt(px[iparticle]**2+py[iparticle]**2); float theta = atan(pt/pz[iparticle]); if(theta<0) theta = TMath::Pi()+theta; float eta = -log(tan(theta/2)); if(px[iparticle]>0){ float phi = atan(py[iparticle]/px[iparticle]); if(py[iparticle]<0) float phi = 2*TMath::Pi()+atan(py[iparticle]/px[iparticle]); } else float phi = TMath::Pi()+atan(py[iparticle]/px[iparticle]); if((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])<=0) continue; float y = 0.5*log((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])); if(fabs(eta)<0.35 && pt>0.2 && pt< 5.0){ ntrk++; } if(fabs(eta)>3 && fabs(eta)<4 && pt>0.05){ int iarm = 0; if (eta > 0) iarm = 1; if(iarm==0){ nbbcau++; } else{ nbbcde++; } if(iarm==0) nch++; } nchtotal++; } if(nch>21) icent=0;//0-4.6% else if(nch<5) icent=2; //58-100% else icent = 1; for(int iparticle = 0;iparticle < n; iparticle++){ if(!(fabs(KF[iparticle]) == 211 || fabs(KF[iparticle]) == 213 || fabs(KF[iparticle]) == 321 || fabs(KF[iparticle]) == 323 ||fabs(KF[iparticle]) == 2212)) continue; float pt = sqrt(px[iparticle]**2+py[iparticle]**2); float theta = atan(pt/pz[iparticle]); if(theta<0) theta = TMath::Pi()+theta; float eta = -log(tan(theta/2)); if(px[iparticle]>0){ float phi = atan(py[iparticle]/px[iparticle]); if(py[iparticle]<0) float phi = 2*TMath::Pi()+atan(py[iparticle]/px[iparticle]); } else float phi = TMath::Pi()+atan(py[iparticle]/px[iparticle]); if((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])<=0) continue; float y = 0.5*log((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])); hy->Fill(y); heta->Fill(eta); if(fabs(y)<=1) hy1->Fill(y); hphi->Fill(phi); hpteta[icent]->Fill(pt,eta); hpty[icent]->Fill(pt,y); } hn->Fill(n); hnchtotal->Fill(nchtotal); hnchntrk->Fill(nch,ntrk); hNbinary->Fill(nch,Nbinary); hb->Fill(nch,b); if(nbbcau<1 || nbbcde<1) continue; //mb trigger hnchntrkmbtrig->Fill(nch,ntrk); hNbinarymbtrig->Fill(nch,Nbinary); hbmbtrig->Fill(nch,b); for(int iparticle = 0;iparticle < n; iparticle++){ if(!(fabs(KF[iparticle]) == 211 || fabs(KF[iparticle]) == 213 || fabs(KF[iparticle]) == 321 || fabs(KF[iparticle]) == 323 ||fabs(KF[iparticle]) == 2212)) continue; float pt = sqrt(px[iparticle]**2+py[iparticle]**2); float theta = atan(pt/pz[iparticle]); if(theta<0) theta = TMath::Pi()+theta; float eta = -log(tan(theta/2)); if(px[iparticle]>0){ float phi = atan(py[iparticle]/px[iparticle]); if(py[iparticle]<0) float phi = 2*TMath::Pi()+atan(py[iparticle]/px[iparticle]); } else float phi = TMath::Pi()+atan(py[iparticle]/px[iparticle]); if((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])<=0) continue; float y = 0.5*log((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])); hptetambtrig[icent]->Fill(pt,eta); hptymbtrig[icent]->Fill(pt,y); } } TFile *fout = new TFile(Form("outhisto_dAu_%d.root",i),"Recreate"); fout->cd(); hKF->Write(); heta->Write(); hy->Write(); hy1->Write(); hphi->Write(); for(int icent=0;icent<ncent;icent++){ hpteta[icent]->Write(); hpty[icent]->Write(); hptetambtrig[icent]->Write(); hptymbtrig[icent]->Write(); } hMass->Write(); hn->Write(); hnchntrk->Write(); hnchntrkmbtrig->Write(); hnchtotal->Write(); hNbinary->Write(); hb->Write(); hNbinarymbtrig->Write(); hbmbtrig->Write(); fout->Close(); cout<<nPion<<"\t"<<nPionC<<"\t"<<nKaonC<<"\t"<<nout<<"\t"<<nPrim<<"\t"<<nSecond<<endl; }
Int_t GetRateXY( Int_t fillnum = 15419 ,const char* sl = "small" ){ gSystem->Load("../lib/libMyCellMgr.so"); gROOT->LoadMacro("/home/yuxip/FMS/CellScan/macros/Legal.C"); Char_t runlist[20]; sprintf(runlist,"fill%d.list",fillnum); fstream inlist(runlist,ios::in); if(!inlist){ cout<<runlist<<" does not exist!!"<<endl; return -1; } TH2F* fcmp; TFile* fcell = 0; Int_t n1 = 0; Int_t n2 = 0; Char_t outfilename[30]; if(!strcmp(sl,"large")){ sprintf(outfilename,"largeRateVsGcor_fill%d_n2.ps",fillnum); n1 = 2; n2 = 2; //analysis each nstb separately } else if(!strcmp(sl,"small")){ sprintf(outfilename,"smallRateVsGcor_fill%d_n4.ps",fillnum); n1 = 4; n2 = 4; } else{ cout<<"invalid 2nd argument"<<endl; return -1; } TString outfile(outfilename); TString headout = outfile + "["; TString endout = outfile + "]"; // TCanvas* c1 = new TCanvas("c1","c1",1100,1100); TCanvas* c1 = new TCanvas("c1","c1",700,700); // c1->Divide(3,3); // c1->Print(headout); fstream inGcor("FmsCorr_sh.txt",ios::in); Int_t iew; Int_t instb; Int_t ich; Float_t gcorsh; Int_t cnt = 1; Int_t cellcnt = 0; Int_t rch = 0; Long_t runnum = 0; Char_t cellname[30]; Char_t cellfile[30]; Char_t title[20]; Int_t bit = 0; UChar_t status = 0; Int_t rate = 0; Int_t Trgth = 100; MyCell* mcell = 0; Float_t mycor; Float_t gdiff; // while(inlist>>runnum){ sprintf(title,"RateVsGcor_fill%d_n2",fillnum); // fcmp[cnt-1] = new TH2F(title,title,100,-1,1,100,0,10000); fcmp = new TH2F(title,title,100,-1,1,100,0,10000); while(inGcor>>iew>>instb>>ich>>gcorsh){ if(instb==n1&&iew==2)break; } for(Int_t nstb = n1; nstb <= n2; nstb++){ for(Int_t row0 = 0; row0 < 34; row0++){ for(Int_t col0 = 0; col0 < 17; col0++){ if(cellcnt)inGcor>>iew>>instb>>ich>>gcorsh; cellcnt++; if(!Legal(2,nstb,row0,col0)){ continue; } sprintf(cellname,"Cellr%d_c%d_n%d",row0,col0,nstb); cout<<"processing "<<cellname<<endl; if(col0==0){ if(nstb<3){ rch = 17*row0+col0+1; } else if(nstb<5){ rch = 12*row0+col0+1; } cout<<"debug instb: "<<instb<<" nstb: "<<nstb<<" ich: "<<ich<<" rch: "<<rch<<" gcorsh: "<<gcorsh<<endl; } sprintf(cellfile,"../cells/Cellr%d_c%d_n%d.root",row0,col0,nstb); fcell = new TFile(cellfile,"read"); if(!fcell){ cout<<cellfile<<" does not exist!!"<<endl; return -1; } mcell = (MyCell*)fcell->Get(cellname); if(!mcell){ cout<<"ERROR reading "<<cellname<<" object"<<endl; return -1; } mycor = mcell->GetGainCor(); if(col0==0)cout<<"mycor: "<<mycor<<endl; gdiff = mycor - gcorsh; // status = mcell->GetStatusBit(runnum); // bit = (Int_t)(status&0x03); //can not be 0011 inlist.clear(); inlist.seekg(0,ios::beg); while(inlist>>runnum){ if(col0==0)cout<<"run :"<<runnum<<endl; rate = mcell->GetNth(runnum,Trgth); fcmp->Fill(gdiff,rate); } mcell = 0; status = 0; bit = 0; gdiff = 0; fcell->Close(); fcell = 0; } } } // c1->cd(cnt); fcmp->Draw("COLZ"); // if(cnt%9==0){ // c1->Print(outfile); // c1->Clear(); // c1->Divide(3,3); // cnt = 0; // } // cnt++; // cout<<"============================"<<runnum<<" done.."<<endl; // cellcnt = 0; // } c1->Print(outfile); // c1->Print(endout); return 1; }
void sigma_plots_mass_4D(int sigMass, double cut_pt1IN, double cut_pt2IN, double cut_metIN,double cut_ptggIN, double ptLead_cutIN, double DPHI_cutIN, double maxDPHIJet_cutIN,double minDPHIJet_cutIN){ gStyle->SetPadTickY(1); gStyle->SetPadTickX(1); /* TFile *sig = TFile::Open(Form("./50ns_betaV4/NewWeightDMHtoGG_M%d.root",sigMass),"READ"); TFile *bkg1 = TFile::Open("./50ns_betaV4/NewWeightDiPhoton.root","READ"); TFile *bkg2 = TFile::Open("./50ns_betaV4/NewWeightDYJetsToLL.root","READ"); TFile *bkg3 = TFile::Open("./50ns_betaV4/NewWeightGJets.root","READ"); TFile *bkg4 = TFile::Open("./50ns_betaV4/NewWeightGluGluHToGG.root","READ"); TFile *bkg5 = TFile::Open("./50ns_betaV4/NewWeightQCD.root","READ"); TFile *bkg6 = TFile::Open("./50ns_betaV4/NewWeightVH.root","READ"); */ TFile *data = TFile::Open("./25ns_2246inv_v3/DoubleEG.root","READ"); TFile *sig = TFile::Open(Form("./25ns_2246inv_v3/2HDM_mZP%d.root",sigMass),"READ"); if(sig == NULL) cout<<"sig fails"<<endl; TFile *bkg1 = TFile::Open("./25ns_2246inv_v3/DiPhoton.root","READ"); if(bkg1 == NULL) cout<<"bkg1 fails"<<endl; TFile *bkg2 = TFile::Open("./25ns_2246inv_v3/DYJetsToLL.root","READ"); if(bkg2 == NULL) cout<<"bkg2 fails"<<endl; TFile *bkg3 = TFile::Open("./25ns_2246inv_v3/GJets.root","READ"); if(bkg3 == NULL) cout<<"bkg3 fails"<<endl; TFile *bkg4 = TFile::Open("./25ns_2246inv_v3/GluGluHToGG.root","READ"); if(bkg4 == NULL) cout<<"bkg4 fails"<<endl; TFile *bkg5 = TFile::Open("./25ns_2246inv_v3/QCD.root","READ"); if(bkg5 == NULL) cout<<"bkg5 fails"<<endl; TFile *bkg6 = TFile::Open("./25ns_2246inv_v3/VH.root","READ"); if(bkg6 == NULL) cout<<"bkg6 fails"<<endl; TFile *bkg7 = TFile::Open("./25ns_2246inv_v3/ttHJetToGG.root","READ"); TFile *bkg8 = TFile::Open("./25ns_2246inv_v3/VBFHToGG.root","READ"); TFile *bkg9 = TFile::Open("./25ns_2246inv_v3/TGJets.root","READ"); TFile *bkg10 = TFile::Open("./25ns_2246inv_v3/TTGJets.root","READ"); TFile *bkg11 = TFile::Open("./25ns_2246inv_v3/WGToLNuG.root","READ"); TFile *bkg12 = TFile::Open("./25ns_2246inv_v3/ZGTo2LG.root","READ"); TTree *tree_data = (TTree*) data->Get("DiPhotonTree"); TTree *tree_sig = (TTree*) sig->Get("DiPhotonTree"); TTree *tree_bkg1 = (TTree*) bkg1->Get("DiPhotonTree"); TTree *tree_bkg2 = (TTree*) bkg2->Get("DiPhotonTree"); TTree *tree_bkg3 = (TTree*) bkg3->Get("DiPhotonTree"); TTree *tree_bkg4 = (TTree*) bkg4->Get("DiPhotonTree"); TTree *tree_bkg5 = (TTree*) bkg5->Get("DiPhotonTree"); TTree *tree_bkg6 = (TTree*) bkg6->Get("DiPhotonTree"); TTree *tree_bkg7 = (TTree*) bkg7->Get("DiPhotonTree"); TTree *tree_bkg8 = (TTree*) bkg8->Get("DiPhotonTree"); TTree *tree_bkg9 = (TTree*) bkg9->Get("DiPhotonTree"); TTree *tree_bkg10 = (TTree*) bkg10->Get("DiPhotonTree"); TTree *tree_bkg11 = (TTree*) bkg11->Get("DiPhotonTree"); TTree *tree_bkg12 = (TTree*) bkg12->Get("DiPhotonTree"); TCut Cut_pt1; TCut Cut_pt2; TCut Cut_met; TCut Cut_ptgg; TCut mggmax = "mgg<130"; TCut mggmin = "mgg>120"; TCut eveto1 = "eleveto1 == 1"; TCut eveto2 = "eleveto2 == 1"; TCut eveto = eveto1 && eveto2; TCut genmatch = "((genmatch1==1 && genmatch2==0)||(genmatch1==0 && genmatch2==1)||(genmatch1==0 && genmatch2==0))"; TCut DPHIcut = Form("FDelta(pt1,eta1,phi1,0.,pt2,eta2,phi2,0.,t1pfmetPhi)>%lf",DPHI_cutIN); TCut maxDPHIJetcut = Form("MAX(ptJetLead,phiJetLead,ptJetSubLead,phiJetSubLead,ptJet3,phiJet3,ptJet4,phiJet4,t1pfmetPhi)<%lf",maxDPHIJet_cutIN); TCut minDPHIJetcut = Form("myMIN(ptJetLead,phiJetLead,ptJetSubLead,phiJetSubLead,ptJet3,phiJet3,ptJet4,phiJet4,t1pfmetPhi)>%lf",minDPHIJet_cutIN); TCut nMuonCut = "nMuons == 0"; TCut nEleCut = "nEle <= 1"; TCanvas *canvas = new TCanvas("canvas","",600,400); int i = 0; int j = 0; int k = 0; int l = 0; double cut_pt1 = 0; double cut_pt2 = 0; double cut_met = 0; double cut_ptgg = 0; double Stot_pt1 = 0; double Stot_pt2 = 0; double Stot_met = 0; double Stot_ptgg = 0; double S = 0; double F1 = 0; double F2 = 0; double F3 = 0; double F4 = 0; double F5 = 0; double F6 = 0; double F7 = 0; double F8 = 0; double F9 = 0; double F10 = 0; double F11 = 0; double F12 = 0; double B = 0; double Eff = 0; double Sig3 = 0; double Sig5 = 0; int NstepsPt1 = 20; int NstepsPt2 = 20; int NstepsMET = 20; int NstepsPtgg = 20; double temp = 0; double firstCutPt1 = cut_pt1IN - 0.05*NstepsPt1/2; double firstCutPt2 = 1./4.; double firstCutMET = cut_metIN - 5*NstepsMET/2; double firstCutPtgg = cut_ptggIN - 5*NstepsPtgg/2; double crossSec = 1.; double N = 0.; cout<<"############Segnale M"<<sigMass<<endl; cout<<"120 < mgg < 130"<<endl; ios_base::fmtflags oldflags = std::cout.flags(); TH2F *hpt1VSpt2 = new TH2F("hpt1VSpt2","",NstepsPt1,firstCutPt1,firstCutPt1+0.05*NstepsPt1,NstepsPt2,firstCutPt2,firstCutPt2+0.05*NstepsPt2); TH2F *hpt1VSmet = new TH2F("hpt1VSmet","",NstepsPt1,firstCutPt1,firstCutPt1+0.05*NstepsPt1,NstepsMET,firstCutMET,firstCutMET+5*NstepsMET); TH2F *hptggVSmet = new TH2F("hptggVSmet","",NstepsPtgg,firstCutPtgg,firstCutPtgg+5*NstepsPtgg,NstepsMET,firstCutMET,firstCutMET+5*NstepsMET); TH2F *hmetVSpt2 = new TH2F("metVSpt2","",NstepsMET,firstCutMET,firstCutMET+5*NstepsMET,NstepsPt2,firstCutPt2,firstCutPt2+0.05*NstepsPt2); TH2F *hptggVSpt2 = new TH2F("ptggVSpt2","",NstepsPtgg,firstCutPtgg,firstCutPtgg+5*NstepsPtgg,NstepsPt2,firstCutPt2,firstCutPt2+0.05*NstepsPt2); TH2F *hpt1VSptgg = new TH2F("hpt1VSptgg","",NstepsPt1,firstCutPt1,firstCutPt1+0.05*NstepsPt1,NstepsPtgg,firstCutPtgg,firstCutPtgg+5*NstepsPtgg); tree_sig->Draw("(pt1)>>pt1_tot1(30,0,1000)","weight"*(mggmin && mggmax && eveto)); TH1F *pt1_tot1 =(TH1F*)gPad->GetPrimitive("pt1_tot1"); pt1_tot1->Scale(crossSec); Stot_pt1 = pt1_tot1->Integral(); Cut_met = Form("t1pfmet>%lf",cut_metIN); Cut_ptgg = Form("ptgg>%lf",cut_ptggIN); for(i = 0; i<NstepsPt1;i++){ cut_pt1 = firstCutPt1 + 0.05*i +0.001; Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1); for(j = 0; j<NstepsPt2;j++){ cut_pt2 = firstCutPt2 + 0.05*j +0.001; Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2); tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data"); N = pt1_data->GetEntries(); Sig5= 0.; if(N>=0){ tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); pt1_1->Scale(crossSec); S = pt1_1->Integral(); tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1"); F1 = pt1_bkg1->Integral(); tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2"); F2 = pt1_bkg2->Integral(); if(F2<0) F2 = 0; tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3"); F3 = pt1_bkg3->Integral(); tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4"); F4 = pt1_bkg4->Integral(); tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5"); F5 = pt1_bkg5->Integral(); tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6"); F6 = pt1_bkg6->Integral(); tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7"); F7 = pt1_bkg7->Integral(); tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8"); F8 = pt1_bkg8->Integral(); tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9"); F9 = pt1_bkg9->Integral(); if(F9<0) F9=0; tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10"); F10 = pt1_bkg10->Integral(); tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11"); F11 = pt1_bkg11->Integral(); tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12"); F12 = pt1_bkg12->Integral(); B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12; Eff = S/Stot_pt1; Sig3 = Eff/(1.5+sqrt(B)); Sig5 = Eff/(2.5+sqrt(B)); } hpt1VSpt2->Fill(cut_pt1,cut_pt2,Sig5); } } ///////////////////////////////////////////////////////// Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2IN); Cut_ptgg = Form("ptgg>%lf",cut_ptggIN); for(i = 0; i<NstepsPt1;i++){ cut_pt1 = firstCutPt1 + 0.05*i +0.001; Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1); for(j = 0; j<NstepsMET;j++){ cut_met = firstCutMET + 5*j; Cut_met = Form("t1pfmet>%lf",cut_met); tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data"); N = pt1_data->GetEntries(); Sig5= 0.; if(N>=0){ tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); pt1_1->Scale(crossSec); S = pt1_1->Integral(); tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1"); F1 = pt1_bkg1->Integral(); tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2"); F2 = pt1_bkg2->Integral(); if(F2<0) F2 = 0; tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3"); F3 = pt1_bkg3->Integral(); tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4"); F4 = pt1_bkg4->Integral(); tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5"); F5 = pt1_bkg5->Integral(); tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6"); F6 = pt1_bkg6->Integral(); tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7"); F7 = pt1_bkg7->Integral(); tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8"); F8 = pt1_bkg8->Integral(); tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9"); F9 = pt1_bkg9->Integral(); if(F9<0) F9 = 0; tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10"); F10 = pt1_bkg10->Integral(); tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11"); F11 = pt1_bkg11->Integral(); tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12"); F12 = pt1_bkg12->Integral(); B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12; Eff = S/Stot_pt1; Sig3 = Eff/(1.5+sqrt(B)); Sig5 = Eff/(2.5+sqrt(B)); } hpt1VSmet->Fill(cut_pt1,cut_met,Sig5); } } ///////////////////////////////////////////////////////// Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1IN); Cut_ptgg = Form("ptgg>%lf",cut_ptggIN); for(i = 0; i<NstepsPt2;i++){ cut_pt2 = firstCutPt2 + 0.05*i+0.001; Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2); for(j = 0; j<NstepsMET;j++){ cut_met = firstCutMET + 5*j; Cut_met = Form("t1pfmet>%lf",cut_met); tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data"); N = pt1_data->GetEntries(); Sig5= 0.; if(N>=0){ tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); pt1_1->Scale(crossSec); S = pt1_1->Integral(); tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1"); F1 = pt1_bkg1->Integral(); tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2"); F2 = pt1_bkg2->Integral(); if(F2<0) F2 = 0; tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3"); F3 = pt1_bkg3->Integral(); tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4"); F4 = pt1_bkg4->Integral(); tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5"); F5 = pt1_bkg5->Integral(); tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6"); F6 = pt1_bkg6->Integral(); tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7"); F7 = pt1_bkg7->Integral(); tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8"); F8 = pt1_bkg8->Integral(); tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9"); F9 = pt1_bkg9->Integral(); if(F9<0) F9=0; tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10"); F10 = pt1_bkg10->Integral(); tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11"); F11 = pt1_bkg11->Integral(); tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12"); F12 = pt1_bkg12->Integral(); B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12; Eff = S/Stot_pt1; Sig3 = Eff/(1.5+sqrt(B)); Sig5 = Eff/(2.5+sqrt(B)); } hmetVSpt2->Fill(cut_met,cut_pt2,Sig5); } } ///////////////////////////////////////////////////////// Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2IN); Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1IN); for(i = 0; i<NstepsPtgg;i++){ cut_ptgg = firstCutPtgg + 5*i; Cut_ptgg = Form("ptgg>%lf",cut_ptgg); for(j = 0; j<NstepsMET;j++){ cut_met = firstCutMET + 5*j; Cut_met = Form("t1pfmet>%lf",cut_met); tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data"); N = pt1_data->GetEntries(); Sig5= 0.; if(N>=0){ tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); pt1_1->Scale(crossSec); S = pt1_1->Integral(); tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1"); F1 = pt1_bkg1->Integral(); tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2"); F2 = pt1_bkg2->Integral(); if(F2<0) F2 = 0; tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3"); F3 = pt1_bkg3->Integral(); tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4"); F4 = pt1_bkg4->Integral(); tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5"); F5 = pt1_bkg5->Integral(); tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6"); F6 = pt1_bkg6->Integral(); tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7"); F7 = pt1_bkg7->Integral(); tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8"); F8 = pt1_bkg8->Integral(); tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9"); F9 = pt1_bkg9->Integral(); if(F9<0) F9=0; tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10"); F10 = pt1_bkg10->Integral(); tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11"); F11 = pt1_bkg11->Integral(); tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12"); F12 = pt1_bkg12->Integral(); B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12; Eff = S/Stot_pt1; Sig3 = Eff/(1.5+sqrt(B)); Sig5 = Eff/(2.5+sqrt(B)); } hptggVSmet->Fill(cut_ptgg,cut_met,Sig5); } } ///////////////////////////////////////////////////////// Cut_met = Form("t1pfmet>%lf",cut_metIN); Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1IN); for(i = 0; i<NstepsPtgg;i++){ cut_ptgg = firstCutPtgg + 5*i; Cut_ptgg = Form("ptgg>%lf",cut_ptgg); for(j = 0; j<NstepsPt2;j++){ cut_pt2 = firstCutPt2 + 0.05*j+0.001; Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2); tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data"); N = pt1_data->GetEntries(); Sig5= 0.; if(N>=0){ tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); pt1_1->Scale(crossSec); S = pt1_1->Integral(); tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1"); F1 = pt1_bkg1->Integral(); tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2"); F2 = pt1_bkg2->Integral(); if(F2<0) F2 = 0; tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3"); F3 = pt1_bkg3->Integral(); tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4"); F4 = pt1_bkg4->Integral(); tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5"); F5 = pt1_bkg5->Integral(); tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6"); F6 = pt1_bkg6->Integral(); tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7"); F7 = pt1_bkg7->Integral(); tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8"); F8 = pt1_bkg8->Integral(); tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9"); F9 = pt1_bkg9->Integral(); if(F9<0) F9=0; tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10"); F10 = pt1_bkg10->Integral(); tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11"); F11 = pt1_bkg11->Integral(); tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12"); F12 = pt1_bkg12->Integral(); B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12; Eff = S/Stot_pt1; Sig3 = Eff/(1.5+sqrt(B)); Sig5 = Eff/(2.5+sqrt(B)); } hptggVSpt2->Fill(cut_ptgg,cut_pt2,Sig5); } } ///////////////////////////////////////////////////////// Cut_met = Form("t1pfmet>%lf",cut_metIN); Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2IN); for(i = 0; i<NstepsPtgg;i++){ cut_ptgg = firstCutPtgg + 5*i; Cut_ptgg = Form("ptgg>%lf",cut_ptgg); for(j = 0; j<NstepsPt1;j++){ cut_pt1 = firstCutPt1 + 0.05*j+0.001; Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1); tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data"); N = pt1_data->GetEntries(); Sig5= 0.; if(N>=0){ tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); pt1_1->Scale(crossSec); S = pt1_1->Integral(); tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1"); F1 = pt1_bkg1->Integral(); tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2"); F2 = pt1_bkg2->Integral(); if(F2<0) F2 = 0; tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3"); F3 = pt1_bkg3->Integral(); tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4"); F4 = pt1_bkg4->Integral(); tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch)); TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5"); F5 = pt1_bkg5->Integral(); tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6"); F6 = pt1_bkg6->Integral(); tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7"); F7 = pt1_bkg7->Integral(); tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8"); F8 = pt1_bkg8->Integral(); tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9"); F9 = pt1_bkg9->Integral(); if(F9<0) F9=0; tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10"); F10 = pt1_bkg10->Integral(); tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11"); F11 = pt1_bkg11->Integral(); tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut )); TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12"); F12 = pt1_bkg12->Integral(); B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12; Eff = S/Stot_pt1; Sig3 = Eff/(1.5+sqrt(B)); Sig5 = Eff/(2.5+sqrt(B)); } hpt1VSptgg->Fill(cut_pt1,cut_ptgg,Sig5); } } const Int_t NRGBs = 5; const Int_t NCont = 255; Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 }; Double_t red[NRGBs] = { 0.00, 0.00, 0.87, 1.00, 0.51 }; Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 }; Double_t blue[NRGBs] = { 0.51, 1.00, 0.12, 0.00, 0.00 }; TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); gStyle->SetNumberContours(NCont); int iPos=0; TCanvas *fancycanvas1 = new TCanvas("fancycanvas1","",550,500); fancycanvas1->SetRightMargin(0.17); hpt1VSpt2->GetXaxis()->SetTitle("p_{T1}/m_{#gamma#gamma}"); hpt1VSpt2->GetYaxis()->SetTitle("p_{T2}/m_{#gamma#gamma}"); hpt1VSpt2->GetZaxis()->SetTitle("Sign(5#sigma)"); hpt1VSpt2->GetZaxis()->SetTitleOffset(1.6); hpt1VSpt2->GetYaxis()->SetTitleOffset(1.2); hpt1VSpt2->Draw("colz"); CMS_lumi( fancycanvas1,true,iPos,true ); gStyle->SetOptStat(0); TCanvas *fancycanvas2 = new TCanvas("fancycanvas2","",550,500); fancycanvas2->SetRightMargin(0.17); hpt1VSmet->GetXaxis()->SetTitle("p_{T1}/m_{#gamma#gamma}"); hpt1VSmet->GetYaxis()->SetTitle("MET [GeV]"); hpt1VSmet->GetZaxis()->SetTitle("Sign(5#sigma)"); hpt1VSmet->GetZaxis()->SetTitleOffset(1.6); hpt1VSmet->GetYaxis()->SetTitleOffset(1.2); hpt1VSmet->Draw("colz"); CMS_lumi( fancycanvas2,true,iPos,true ); gStyle->SetOptStat(0); TCanvas *fancycanvas3 = new TCanvas("fancycanvas3","",550,500); fancycanvas3->SetRightMargin(0.17); hmetVSpt2->GetXaxis()->SetTitle("MET [GeV]"); hmetVSpt2->GetYaxis()->SetTitle("p_{T2}/m_{#gamma#gamma}"); hmetVSpt2->GetZaxis()->SetTitle("Sign(5#sigma)"); hmetVSpt2->GetZaxis()->SetTitleOffset(1.6); hmetVSpt2->GetYaxis()->SetTitleOffset(1.2); hmetVSpt2->Draw("colz"); CMS_lumi( fancycanvas3,true,iPos,true ); gStyle->SetOptStat(0); TCanvas *fancycanvas4 = new TCanvas("fancycanvas4","",550,500); fancycanvas4->SetRightMargin(0.17); hptggVSmet->GetXaxis()->SetTitle("p_{T#gamma#gamma} [GeV]"); hptggVSmet->GetYaxis()->SetTitle("MET [GeV]"); hptggVSmet->GetZaxis()->SetTitle("Sign(5#sigma)"); hptggVSmet->GetZaxis()->SetTitleOffset(1.6); hptggVSmet->GetYaxis()->SetTitleOffset(1.2); hptggVSmet->Draw("colz"); CMS_lumi( fancycanvas4,true,iPos,true ); gStyle->SetOptStat(0); TCanvas *fancycanvas5 = new TCanvas("fancycanvas5","",550,500); fancycanvas5->SetRightMargin(0.17); hptggVSpt2->GetXaxis()->SetTitle("p_{T#gamma#gamma} [GeV]"); hptggVSpt2->GetYaxis()->SetTitle("p_{T2}/m_{#gamma#gamma}"); hptggVSpt2->GetZaxis()->SetTitle("Sign(5#sigma)"); hptggVSpt2->GetZaxis()->SetTitleOffset(1.6); hptggVSpt2->GetYaxis()->SetTitleOffset(1.2); hptggVSpt2->Draw("colz"); CMS_lumi( fancycanvas5,true,iPos,true ); gStyle->SetOptStat(0); TCanvas *fancycanvas6 = new TCanvas("fancycanvas6","",550,500); fancycanvas6->SetRightMargin(0.17); hpt1VSptgg->GetXaxis()->SetTitle("p_{T1}/m_{#gamma#gamma}"); hpt1VSptgg->GetYaxis()->SetTitle("p_{T#gamma#gamma} [GeV]"); hpt1VSptgg->GetZaxis()->SetTitle("Sign(5#sigma)"); hpt1VSptgg->GetZaxis()->SetTitleOffset(1.6); hpt1VSptgg->GetYaxis()->SetTitleOffset(1.2); hpt1VSptgg->Draw("colz"); CMS_lumi( fancycanvas6,true,iPos,true ); gStyle->SetOptStat(0); fancycanvas1->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPt2_mass_DPHIandLepVeto_all4D.png",sigMass)); fancycanvas2->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsMET_mass_DPHIandLepVeto_all4D.png",sigMass)); fancycanvas3->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsMETvsPt2_mass_DPHIandLepVeto_all4D.png",sigMass)); fancycanvas4->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsMET_mass_DPHIandLepVeto_all4D.png",sigMass)); fancycanvas5->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsPt2_mass_DPHIandLepVeto_all4D.png",sigMass)); fancycanvas6->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPtgg_mass_DPHIandLepVeto_all4D.png",sigMass)); fancycanvas1->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPt2_mass_DPHIandLepVeto_all4D.pdf",sigMass)); fancycanvas2->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsMET_mass_DPHIandLepVeto_all4D.pdf",sigMass)); fancycanvas3->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsMETvspt2_mass_DPHIandLepVeto_all4D.pdf",sigMass)); fancycanvas4->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsMET_mass_DPHIandLepVeto_all4D.pdf",sigMass)); fancycanvas5->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsPt2_mass_DPHIandLepVeto_all4D.pdf",sigMass)); fancycanvas6->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPtgg_mass_DPHIandLepVeto_all4D.pdf",sigMass)); }
void RPCChambersCluster::variousStudyExperimentalFunction(TFile * fileToSave,TH1F * histo[10],const int & eventNum){ // Save file is used to save all the reconstructed graphs with tracks in order to inspect them RPCChamber * currentChamberObj; RPCChamber * triggerObj; RPCLinkBoardChannel * currentChannelObj; int numberOfChambers = this->getNumberOfChambers(); triggerObj = this->getTriggerObjectNumber(1); TGraphErrors * graphToFit; //currentChamberObj = this->getChamberNumber(1); int numberOfReferenceChambers = 0; // change this value for the three cases - CERN, Ghent and BARC vector<int> tempCluster; TH1F * hist1,* hist2,* hist3,* hist4, * numberOfClustersHisto, * topMinusEachChamberAvg, * bottomMinusEachChamberAvg,*clsSize , * numberOfClustersInSamePartitions, * histClustersPartitionDistr, * SingleMultiHits; hist1 = histo[0]; hist2 = histo[1]; hist3 = histo[2]; hist4 = histo[3]; numberOfClustersHisto = histo[4]; topMinusEachChamberAvg = histo[5]; bottomMinusEachChamberAvg = histo[6]; clsSize = histo[7]; histClustersPartitionDistr = histo[8]; SingleMultiHits = histo[9]; int timeReference = 0; int timeWindow = 0; int firstScintilatorTime = 0 ; int secondScintilatorTime = 0; int difference_reference = 0; int coincidence_time = 0 ; if (triggerObj->getChannel(32)->hasHit()){ coincidence_time = triggerObj->getChannel(32)->getHits().at(0); } ESiteFileType siteType = kIsCERNrawFile; // later make the method to take file type argument and to use it in here //TH1F * firstTriggerEntries = new TH1F("ScintStats1","ScintStats1",0,500,500); //firstTriggerEntries->SetLineColor(kBlue); //firstTriggerEntries->SetFillColor(kBlue); switch (siteType) { case kIsCERNrawFile: timeWindow = 500; numberOfReferenceChambers = 3; int countTwoHits=0; for (int i = 0 ; i < 13 ; i++){ if(triggerObj->getChannel(i+1)->hasHit() ){ if ( difference_reference == 0 || ( coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0) ) < difference_reference ) { difference_reference = coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0); firstScintilatorTime = triggerObj->getChannel(i+1)->getHits().at(0); } } } difference_reference = 0; for (int i = 13 ; i < 31 ; i++) { if(triggerObj->getChannel(i+1)->hasHit() ){ if ( difference_reference == 0 || ( coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0) ) < difference_reference ) { difference_reference = coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0); secondScintilatorTime = triggerObj->getChannel(i+1)->getHits().at(0); } } } //timeReference = timeReference/2; /* case kIsGENTrawFile: timeWindow = 20; for(int i = 0 ; i < 32 ; i++){ if(triggerObj->getChannel(i+1)->hasHit()) { triggerObj->getChannel(i+1)->getHits().at(0); } break; } case kIsBARCrawFile: timeWindow = 0; timeReference = 0; */ } timeReference = (firstScintilatorTime+secondScintilatorTime)/2; //cout << " time reference : " << timeReference << endl; //cout << " trigger entries : "; for (int i=0; i < 32 ; i++){ if (triggerObj->getChannel(i+1)->hasHit()){ // cout << " trig channel : " << i+1 << " " << triggerObj->getChannel(i+1)->getHits().at(0) << " "; } } cout << endl; // cout << " most close trigger entries : top " << firstScintilatorTime << " bottom : " << secondScintilatorTime; // cout << endl; hist1->Fill(abs(firstScintilatorTime-secondScintilatorTime)); hist2->Fill(coincidence_time - firstScintilatorTime); hist3->Fill(coincidence_time - secondScintilatorTime); // cout << "difference : " << firstScintilatorTime-secondScintilatorTime << endl; for (int totalChambers = 0 ; totalChambers < numberOfChambers ; totalChambers++){ currentChamberObj = this->getChamberNumber(totalChambers+1); cout << "Chamber " << totalChambers+1 ; for (int j=0 ; j < 96 ;j++){ currentChamberObj = this->getChamberNumber(totalChambers+1); currentChannelObj = currentChamberObj->getChannel(j+1); if (currentChannelObj->hasHit()){ cout << " channel " << currentChannelObj->getOnlineNumber() << " time " << currentChannelObj->getHits().at(0); } } cout << endl; currentChamberObj->findAllClustersForTriggerTimeReferenceAndTimeWindow(timeReference,timeWindow); // now check the clusterization methods // fill number of cluster when there is at least one if(currentChamberObj->getNumberOfClusters()){ numberOfClustersHisto->Fill(currentChamberObj->getNumberOfClusters()); } } cout << "-------------------" << endl; // cout << "Check new cluster methods" << endl; for (int totalChambers = 0 ; totalChambers < numberOfChambers ; totalChambers++){ currentChamberObj = this->getChamberNumber(totalChambers+1); // cout << "Chamber " << totalChambers+1 ; for (int i = 0 ; i < currentChamberObj->getNumberOfClusters() ; i++){ // make the difference to get the tolerance within one cluster int smallestTime = 0; int biggestTime = 0; int currentValue = 0; int sizeOfCurrentCluster = currentChamberObj->getClusterNumber(i+1).size(); tempCluster = currentChamberObj->getClusterNumber(i+1); int numberOfHits = 0 ; for (int j = 0 ; j < sizeOfCurrentCluster; j++){ // Fill the size here SingleMultiHits->Fill(currentChamberObj->getStrip(tempCluster.at(j))->getHits().size()); } clsSize->Fill(sizeOfCurrentCluster); for (int j = 0 ; j < sizeOfCurrentCluster ; j++ ){ currentValue = currentChamberObj->getStripsHitsTimesForCluster(i+1).at(j); if ( j == 0 ) { // init the values smallestTime = currentChamberObj->getStripsHitsTimesForCluster(i+1).at(j); biggestTime = currentChamberObj->getStripsHitsTimesForCluster(i+1).at(j); } else{ if ( smallestTime >= currentValue ){ smallestTime = currentValue; } if( biggestTime <= currentValue){ biggestTime = currentValue; } } } if (biggestTime - smallestTime != 0){ hist4->Fill(biggestTime-smallestTime); } int avgTimeForCluster = currentChamberObj->getAverageTimeForCluster(i+1); topMinusEachChamberAvg->Fill(abs(firstScintilatorTime - avgTimeForCluster)); bottomMinusEachChamberAvg->Fill(abs(secondScintilatorTime - avgTimeForCluster)); // cout << endl << "Cluster " << i+1 << " toptime " << biggestTime << " leasttime " << smallestTime ; } // cout << endl; } // cout << "-------Second check done-----------" << endl; // try with single cluster per chamber vector<int> vectorOfReferenceChambers; for (int i=0; i < this->getNumberOfChambers() ; i ++){ currentChamberObj = this->getChamberNumber(i+1); if (currentChamberObj->isReferenceChamber() && !currentChamberObj->getNumberOfClusters()){ // the reference chamber does not have a hit (cluster), probably inefficient (or else) , skip the execution break; } } // remove the following when the configuration object is introduced // done, change the implementation vectorOfReferenceChambers.push_back(1); vectorOfReferenceChambers.push_back(4); vectorOfReferenceChambers.push_back(6); /** Determination of track starts here */ // Move this part in separated method //TFile * goodTracks = new TFile("GoodTracks.root","UPDATE"); //TFile * badTracks = new TFile("BadTracks.root","UPDATE"); int globalCount = 1; for ( int i = 0 ; i < this->getChamberNumber(vectorOfReferenceChambers[0])->getNumberOfClusters() ; i++ ){ for( int j = 0 ; j < this->getChamberNumber(vectorOfReferenceChambers[1])->getNumberOfClusters() ; j++ ){ for( int k = 0 ; k < this->getChamberNumber(vectorOfReferenceChambers[2])->getNumberOfClusters() ; k++ ){ // check the multiplicity. use 5 as upper limit number // with the test run 2202 - CERN channel 33 is noisy so there is a condition only for it here TO DO - remove the channel 33 condition // old function /** Hits : first , use the time to distinguish useless crap - like noisy channels * * 2. Check the partition plane (YZ plane) for vertical tracks. If the track is vertical don't search for consecutiveness and don't fill the YZ histo * 3. Check the partitions plane for consecutiveness - one could not expect track that passes 3 -> 1 -> 3 partitions * */ if(this->getChamberNumber(vectorOfReferenceChambers[0])->getSizeOfCluster(i+1) > 5 || this->getChamberNumber(vectorOfReferenceChambers[1])->getSizeOfCluster(j+1) > 5 || this->getChamberNumber(vectorOfReferenceChambers[2])->getSizeOfCluster(k+1) > 5 ) continue; // the partition logic start here - track could pass more than one partition int direction = 0 ; // direction should describe how the partition changes from one reference chamber to another. It int RefChamberClusterPartition[3] ; int currentDifference = 0; bool positive = false; bool negative = false; int partitionPenetrated = 1; // the Y coordinate is the partition number ( 1 2 or 3 - A B or C) RefChamberClusterPartition[0] = this->getChamberNumber(vectorOfReferenceChambers[0])->getXYCoordinatesOfCluster(i+1).at(1); RefChamberClusterPartition[1] = this->getChamberNumber(vectorOfReferenceChambers[1])->getXYCoordinatesOfCluster(j+1).at(1); RefChamberClusterPartition[2] = this->getChamberNumber(vectorOfReferenceChambers[2])->getXYCoordinatesOfCluster(k+1).at(1); for ( int ii = 0; ii < 2 ; ii++ ){ direction = (RefChamberClusterPartition[ii] - RefChamberClusterPartition[ii+1]); if (direction != 0) { direction = direction/abs(direction); partitionPenetrated++; } // get only the sign ( +1 or -1) if (direction && direction == -1) positive = true; if (direction && direction == 1 ) negative = true; } // cannot have a track that goes in both direction // partition logic end here stringstream ss; ss << globalCount; string histoCounter = ss.str(); TH2F * histXZ = new TH2F(histoCounter.c_str(),"XZ plane",110,0,110,68,0,34); histXZ->SetMarkerColor(kBlue); histXZ->SetMarkerStyle(kOpenTriangleDown); // - open triangle down not found on noise server ? double * xc = new double[3]; double * yc = new double[3]; double * zc = new double[3]; vector<double> coordinates ; double xCoordinate = 0; int yCoordinate = 0; int zCoorinate = 0; coordinates = this->getChamberNumber(1)->getXYCoordinatesOfCluster(i+1); xCoordinate = coordinates.at(0); yCoordinate = coordinates.at(1); zCoorinate = 10*vectorOfReferenceChambers[0]; int prevPartition = yCoordinate; xc[0] = xCoordinate; yc[0] = yCoordinate; zc[0] = 1*10; histXZ->Fill(zc[0],xCoordinate); cout << xCoordinate << " " << yCoordinate << endl; coordinates = this->getChamberNumber(4)->getXYCoordinatesOfCluster(j+1); xCoordinate = coordinates.at(0); yCoordinate = coordinates.at(1); xc[1] = xCoordinate; yc[1] = yCoordinate; zc[1] = 4*10; histXZ->Fill(zc[1],xCoordinate); prevPartition = yCoordinate; cout << xCoordinate << " " << yCoordinate << endl; coordinates = this->getChamberNumber(6)->getXYCoordinatesOfCluster(k+1); xCoordinate = coordinates.at(0); yCoordinate = coordinates.at(1); xc[2] = xCoordinate; yc[2] = yCoordinate; zc[2] = 6*10; histXZ->Fill(zc[2],xCoordinate); cout << xCoordinate << " " << yCoordinate << endl; if ( positive && negative ) continue; TF1 * fitfunc = new TF1("FitTrack","[0]+x*[1]",0,100); Double_t * params = new Double_t[2]; histXZ->Fit(fitfunc); fitfunc->GetParameters(params); cout << "par1 " << params[0] << " par2 " << params[1] << " chi2 " << fitfunc->GetChisquare() << endl; double channelToSearchHitIn ; for (int jj = 0 ; jj < this->getNumberOfChambers() ; jj++){ if (jj+1 != vectorOfReferenceChambers[0] || jj+1 != vectorOfReferenceChambers[1] || jj+1 != vectorOfReferenceChambers[1]) // add additional rule that the chamber should exist in the calibration object { channelToSearchHitIn = fitfunc->Eval((jj+1)*10); cout << "Evaluated for chamber number " << jj+1 << " value : " << channelToSearchHitIn << endl; } } // now here - what to return, and how to get the hits in the chambers under test from the function if (fitfunc->GetChisquare() > 20) continue; // cut the execution if(fitfunc->GetChisquare() < 20){ //goodTracks->Write(trackHistoName.c_str()); histClustersPartitionDistr->Fill(partitionPenetrated); //histXZ->SaveAs((trackHistoName+".root").c_str()); // here search for hits in the chambers under test } /* else{ badTracks->Write(trackHistoName.c_str()); } */ //trackHistoName+=".root"; //histXZ->SaveAs(trackHistoName.c_str()); histXZ->Delete(); } } } // badTracks->Close("R"); // badTracks->Delete(); // goodTracks->Close("R"); // goodTracks->Delete(); }