Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 14:22:47

0001 #include "TMath.h"
0002 #include "TFile.h"
0003 #include "TTree.h"
0004 #include "TH1D.h"
0005 #include "TH2D.h"
0006 #include "TCanvas.h"
0007 #include "TStyle.h"
0008 #include "TGraph.h"
0009 #include "TLegend.h"
0010 #include "TLatex.h"
0011 #include "TMultiGraph.h"
0012 
0013 #include <iostream>
0014 
0015 #include "L1Trigger/L1TNtuples/interface/L1AnalysisL1UpgradeDataFormat.h"
0016 
0017 void rates(const char * rootfile="L1Ntuple.root",const char * treepath="l1UpgradeEmuTree/L1UpgradeTree"){
0018   nevents=10000;
0019 
0020   // make trees

0021   TFile * file = new TFile(rootfile);
0022   TTree * treeL1Up  = (TTree*) file->Get(treepath);
0023   if (! treeL1Up){
0024     cout << "ERROR: could not open tree\n";
0025     return;
0026   }
0027 
0028 
0029   treeL1Up->Print();
0030 
0031   // set branch addresses

0032   L1Analysis::L1AnalysisL1UpgradeDataFormat    *upgrade_ = new L1Analysis::L1AnalysisL1UpgradeDataFormat();
0033   treeL1Up->SetBranchAddress("L1Upgrade", &upgrade_);
0034 
0035   // mu bins

0036   int nMuBins = 50;
0037   float muLo = 10.;
0038   float muHi = 50.;
0039   float muBinWidth = (muHi-muLo)/nMuBins;
0040 
0041   // eg bins

0042   int nEgBins = 50;
0043   float egLo = 10.;
0044   float egHi = 260.;
0045   float egBinWidth = (egHi-egLo)/nEgBins;
0046 
0047   // tau bins

0048   int nTauBins = 50;
0049   float tauLo = 10.;
0050   float tauHi = 260.;
0051   float tauBinWidth = (tauHi-tauLo)/nTauBins;
0052  
0053   // jet bins

0054   int nJetBins = 50;
0055   float jetLo = 10.;
0056   float jetHi = 260.;
0057   float jetBinWidth = (jetHi-jetLo)/nJetBins;
0058 
0059   // etSum bins

0060   int nEtSumBins = 100;
0061   float etSumLo = 10.;
0062   float etSumHi = 510.;
0063   float etSumBinWidth = (etSumHi-etSumLo)/nEtSumBins;
0064 
0065   // htSum bins

0066   int nHtSumBins = 100;
0067   float htSumLo = 10.;
0068   float htSumHi = 510.;
0069   float htSumBinWidth = (htSumHi-htSumLo)/nHtSumBins;
0070 
0071   // metSum bins

0072   int nMetSumBins = 50;
0073   float metSumLo = 10.;
0074   float metSumHi = 260.;
0075   float metSumBinWidth = (metSumHi-metSumLo)/nMetSumBins;
0076 
0077   // mhtSum bins

0078   int nMhtSumBins = 50;
0079   float mhtSumLo = 10.;
0080   float mhtSumHi = 260.;
0081   float mhtSumBinWidth = (mhtSumHi-mhtSumLo)/nMhtSumBins;
0082 
0083   //make histos

0084   TH1D* muRates = new TH1D("muRates", "", nMuBins, muLo-2.5, muHi-2.5);
0085   TH1D* egRates = new TH1D("egRates", "", nEgBins, egLo-2.5, egHi-2.5);
0086   TH1D* tauRates = new TH1D("tauRates", "", nTauBins, tauLo-2.5, tauHi-2.5);
0087   TH1D* jetRates = new TH1D("jetRates", "", nJetBins, jetLo-2.5, jetHi-2.5);
0088   TH1D* etSumRates = new TH1D("etSumRates","", nEtSumBins, etSumLo-2.5, etSumHi-2.5);
0089   TH1D* htSumRates = new TH1D("htSumRates","", nHtSumBins, htSumLo-2.5, htSumHi-2.5);
0090   TH1D* metSumRates = new TH1D("metSumRates","", nMetSumBins, metSumLo-2.5, metSumHi-2.5);
0091   TH1D* mhtSumRates = new TH1D("mhtSumRates","", nMhtSumBins, mhtSumLo-2.5, mhtSumHi-2.5);
0092 
0093   TH1D* hMuEt = new TH1D("muEt", "", 400, 0.,400.);
0094   TH1D* hEgEt = new TH1D("egEt", "", 400, 0.,400.);
0095   TH1D* hTauEt = new TH1D("tauEt","",400, 0.,400.);
0096   TH1D* hJetEt = new TH1D("jetEt","",400, 0.,400.);
0097   TH1D* hEtSum = new TH1D("etSum","",800, 0.,800.);
0098   TH1D* hHtSum = new TH1D("htSum","",800, 0.,800.);
0099 
0100   // get entries

0101   Long64_t nentries = treeL1Up->GetEntriesFast();
0102   if (nevents>nentries) nevents=nentries;
0103   unsigned nZB = 0;
0104 
0105   std::cout << "Running over " << nevents << ", nentries = " << nentries << std::endl;
0106 
0107   for (Long64_t jentry=0; jentry<nevents;jentry++){
0108 
0109     if((jentry%1000)==0) std::cout << "Done " << jentry  << " events..." << std::endl;
0110 
0111     treeL1Up->GetEntry(jentry);
0112     nZB++;
0113     
0114     //cout << upgrade_->nJets << "\n";

0115 
0116     // get Mu rates

0117     double muEt(0);
0118     for(unsigned int it=0; it<upgrade_->nMuons; ++it){
0119       // work around a muon bug:

0120       int offset = upgrade_->muonQual.size() - upgrade_->nMuons;
0121       //cout << "INFO:  " << upgrade_->nMuons << "\n";

0122       //cout << "INFO:  " << upgrade_->muonEt.size() << "\n";

0123       //cout << "INFO:  " << upgrade_->muonQual.size() << "\n";

0124       if (upgrade_->muonQual[it+offset]<8) continue;
0125       hMuEt->Fill(upgrade_->muonEt[it]);
0126       muEt = upgrade_->muonEt[it] > muEt ?  upgrade_->muonEt[it]  : muEt;
0127     }
0128     for(int bin=0; bin<nMuBins; bin++)
0129       if(muEt >= muLo + (bin*muBinWidth) ) muRates->Fill(muLo+(bin*muBinWidth)); //GeV

0130 
0131     // get Eg rates

0132     int egEt(0);
0133     for(unsigned int it=0; it<upgrade_->nEGs; ++it){
0134       hEgEt->Fill(0.5*upgrade_->egIEt[it]);
0135       egEt = upgrade_->egEt[it] > egEt ?  upgrade_->egEt[it]  : egEt;
0136     }
0137     for(int bin=0; bin<nEgBins; bin++)
0138       if(egEt >= egLo + (bin*egBinWidth) ) egRates->Fill(egLo+(bin*egBinWidth)); //GeV

0139     
0140     // get Tau rates

0141     int tauEt(0);
0142     for(unsigned int it=0; it<upgrade_->nTaus; ++it){
0143       hTauEt->Fill(0.5*upgrade_->tauIEt[it]);
0144       tauEt = upgrade_->tauEt[it] > tauEt ? upgrade_->tauEt[it] : tauEt;
0145     }
0146     for(int bin=0; bin<nTauBins; bin++)
0147       if( tauEt >= tauLo + (bin*tauBinWidth) ) tauRates->Fill(tauLo+(bin*tauBinWidth)); //GeV

0148         
0149     // get Jet rates

0150     int jetEt(0);
0151     for(unsigned int it=0; it<upgrade_->nJets; ++it){
0152       hJetEt->Fill(0.5*upgrade_->jetIEt[it]);
0153       jetEt =  upgrade_->jetEt[it] > jetEt ? upgrade_->jetEt[it] : jetEt;
0154     }
0155     for(int bin=0; bin<nJetBins; bin++)
0156       if( jetEt >= jetLo + (bin*jetBinWidth) ) jetRates->Fill(jetLo+(bin*jetBinWidth));  //GeV

0157 
0158     double etSum  = -1.0;
0159     double htSum  = -1.0;
0160     double metSum = -1.0;
0161     double mhtSum = -1.0;
0162     for(unsigned int it=0; it<upgrade_->nSums; ++it){
0163       double et = upgrade_->sumEt[it];
0164       if (upgrade_->sumType[it] == L1Analysis::kTotalEt)   etSum  = et;
0165       if (upgrade_->sumType[it] == L1Analysis::kTotalHt)   htSum  = et;
0166       if (upgrade_->sumType[it] == L1Analysis::kMissingEt) metSum = et;
0167       if (upgrade_->sumType[it] == L1Analysis::kMissingHt) mhtSum = et;
0168     }
0169     //std::cout << "mht:  " << mhtSum << "\n";

0170     //std::cout << "ht sum:  " << htSum << "\n";

0171 
0172     hEtSum->Fill(etSum);
0173     //std::cout << "et sum = " << etSum << std::endl;

0174     for(int bin=0; bin<nEtSumBins; bin++)
0175       if( etSum >= etSumLo+(bin*etSumBinWidth) ) etSumRates->Fill(etSumLo+(bin*etSumBinWidth)); //GeV

0176     
0177     hHtSum->Fill(htSum);
0178     //std::cout << "ht sum = " << htSum << std::endl;

0179     for(int bin=0; bin<nHtSumBins; bin++){
0180       //std::cout << "Ht? " << upgrade_->sumEt[1]->getType() << std::endl;

0181       if( htSum >= htSumLo+(bin*htSumBinWidth) ) htSumRates->Fill(htSumLo+(bin*htSumBinWidth)); //GeV

0182     }
0183 
0184     //hMetSum->Fill(0.5*metSum);

0185     //std::cout << "met sum = " << metSum << std::endl;

0186     for(int bin=0; bin<nMetSumBins; bin++)
0187       if( metSum >= metSumLo+(bin*metSumBinWidth) ) metSumRates->Fill(metSumLo+(bin*metSumBinWidth)); //GeV

0188         
0189     //hMhtSum->Fill(0.5*mhtSum]);

0190     //std::cout << "mht sum = " << mhtSum << std::endl;

0191     for(int bin=0; bin<nMhtSumBins; bin++){
0192       //std::cout << "Mht? " << upgrade_->sumEt[1]->getType() << std::endl;

0193       if( mhtSum >= mhtSumLo+(bin*mhtSumBinWidth) ) mhtSumRates->Fill(mhtSumLo+(bin*mhtSumBinWidth)); //GeV

0194     }
0195 
0196   }
0197 
0198 
0199   //normalisation factor

0200   double avrgInstLumi = 4.5e33; 
0201   double sigmaPP = 6.9e-26;
0202   //double norm = (avrgInstLumi*sigmaPP)/(nevents*1000); //kHz

0203 
0204   double norm = (11.246*2736.)/nZB; // zb rate = n_colliding * 11 kHz 

0205   std::cout << "norm = " << norm << std::endl;
0206 
0207   //make TGraphs

0208   TGraph* gMuRate = new TGraph(nMuBins);
0209   TGraph* gEgRate = new TGraph(nEgBins);
0210   TGraph* gTauRate = new TGraph(nTauBins);
0211   TGraph* gJetRate = new TGraph(nJetBins);
0212   TGraph* gEtSumRate = new TGraph(nEtSumBins);
0213   TGraph* gHtSumRate = new TGraph(nHtSumBins);
0214   TGraph* gMetSumRate = new TGraph(nMetSumBins);
0215   TGraph* gMhtSumRate = new TGraph(nMhtSumBins);
0216 
0217   //norm=1;

0218   for(int bin=0;bin<nMuBins;bin++) gMuRate->SetPoint(bin,muLo+muBinWidth*bin,muRates->GetBinContent(bin+1)*norm);
0219   for(int bin=0;bin<nEgBins;bin++) gEgRate->SetPoint(bin,egLo+egBinWidth*bin,egRates->GetBinContent(bin+1)*norm);
0220   for(int bin=0;bin<nTauBins;bin++) gTauRate->SetPoint(bin,tauLo+tauBinWidth*bin,tauRates->GetBinContent(bin+1)*norm);
0221   for(int bin=0;bin<nJetBins;bin++) gJetRate->SetPoint(bin,jetLo+jetBinWidth*bin,jetRates->GetBinContent(bin+1)*norm);
0222   for(int bin=0;bin<nEtSumBins;bin++) gEtSumRate->SetPoint(bin,etSumLo+etSumBinWidth*bin,etSumRates->GetBinContent(bin+1)*norm);
0223   for(int bin=0;bin<nHtSumBins;bin++) gHtSumRate->SetPoint(bin,htSumLo+htSumBinWidth*bin,htSumRates->GetBinContent(bin+1)*norm);
0224   for(int bin=0;bin<nMetSumBins;bin++) gMetSumRate->SetPoint(bin,metSumLo+metSumBinWidth*bin,metSumRates->GetBinContent(bin+1)*norm);
0225   for(int bin=0;bin<nMhtSumBins;bin++) gMhtSumRate->SetPoint(bin,mhtSumLo+mhtSumBinWidth*bin,mhtSumRates->GetBinContent(bin+1)*norm);
0226 
0227 
0228   TCanvas* c1 = new TCanvas;
0229   c1->SetLogy();
0230 
0231   TLatex n1;
0232   n1.SetNDC();
0233   n1.SetTextFont(42);
0234   n1.SetTextSize(0.04);
0235    
0236   TLatex n2;
0237   n2.SetNDC();
0238   n2.SetLineWidth(2);
0239   n2.SetTextFont(61);
0240   n2.SetTextSize(0.05);
0241    
0242   TLatex n3;
0243   n3.SetNDC();
0244   n3.SetTextFont(52);
0245   n3.SetTextSize(0.04);
0246 
0247   TLatex n4;
0248   n4.SetNDC();
0249   n4.SetTextFont(52);
0250   n4.SetTextSize(0.04);
0251 
0252   gEgRate->SetLineWidth(2);
0253   gEgRate->SetLineColor(kRed);
0254   gEgRate->GetXaxis()->SetTitle("Threshold [GeV]");
0255   gEgRate->GetYaxis()->SetTitle("Rate");
0256   gEgRate->SetMarkerStyle(23);
0257   gEgRate->SetMarkerColor(kRed);
0258   gEgRate->GetYaxis()->SetRangeUser(1, 1e7);
0259   //gEgRate->Draw("APL");

0260   
0261   gTauRate->SetLineWidth(2);
0262   gTauRate->SetLineColor(kBlue);
0263   gTauRate->GetXaxis()->SetTitle("Threshold [GeV]");
0264   gTauRate->GetYaxis()->SetTitle("Rate");
0265   gTauRate->SetMarkerStyle(23);
0266   gTauRate->SetMarkerColor(kBlue);
0267   gTauRate->GetYaxis()->SetRangeUser(1, 1e7);
0268   //gTauRate->Draw("sameAPL");

0269 
0270   gJetRate->SetLineWidth(2);
0271   gJetRate->SetLineColor(kGreen);
0272   gJetRate->GetXaxis()->SetTitle("Threshold [GeV]");
0273   gJetRate->GetYaxis()->SetTitle("Rate");
0274   gJetRate->SetMarkerStyle(23);
0275   gJetRate->SetMarkerColor(kGreen);
0276   gJetRate->GetYaxis()->SetRangeUser(1, 1e7);
0277   gJetRate->SetTitle("");
0278   //gJetRate->Draw("sameAPL");

0279 
0280   TMultiGraph *mg = new TMultiGraph();
0281   mg->Add(gEgRate);
0282   mg->Add(gTauRate);
0283   mg->Add(gJetRate);
0284   mg->SetMinimum(0.1);
0285   mg->SetMaximum(3E5);
0286   mg->Draw("APL");
0287   mg->GetXaxis()->SetTitle("Threshold [GeV]");
0288   mg->GetYaxis()->SetTitle("Rate [kHz]");
0289   gPad->Modified();
0290 
0291   TLegend* leg1 = new TLegend(0.5,0.73,0.7,0.88);
0292   leg1->SetFillColor(0);
0293   leg1->AddEntry(gEgRate,"EGamma","lp");
0294   leg1->AddEntry(gTauRate,"Tau","lp");
0295   leg1->AddEntry(gJetRate,"Jets","lp");
0296   leg1->SetBorderSize(0);
0297   leg1->SetFillStyle(0);
0298   leg1->Draw();
0299 
0300 
0301   n3.DrawLatex(0.5, 0.6, "Run 260627 #sqrt{s} = 13 TeV");
0302   n4.DrawLatex(0.5, 0.55, "Zero Bias");
0303  
0304   c1->SaveAs("ratesJetEgTau.pdf");
0305 
0306 
0307   TCanvas* c2 = new TCanvas;
0308   c2->SetLogy();
0309 
0310   gMuRate->SetTitle("");
0311   gMuRate->SetLineWidth(2);
0312   gMuRate->SetLineColor(kOrange);
0313   gMuRate->GetXaxis()->SetTitle("Threshold [GeV]");
0314   gMuRate->GetYaxis()->SetTitle("Rate");
0315   gMuRate->SetMarkerStyle(23);
0316   gMuRate->SetMarkerColor(kOrange);
0317   gMuRate->GetYaxis()->SetRangeUser(1, 1e3);
0318 
0319   gMuRate->Draw("APL");
0320   gMuRate->GetXaxis()->SetTitle("Threshold [GeV]");
0321   gMuRate->GetYaxis()->SetTitle("Rate [kHz]");
0322   gPad->Modified();
0323 
0324 
0325   TLegend* leg2 = new TLegend(0.5,0.73,0.7,0.88);
0326   leg2->SetFillColor(0);
0327   leg2->AddEntry(gMuRate,"Muon","lp");
0328   leg2->SetBorderSize(0);
0329   leg2->SetFillStyle(0);
0330   leg2->Draw();
0331   leg2->Draw();
0332   n3.DrawLatex(0.5, 0.6, "Run 260627 #sqrt{s} = 13 TeV");
0333   n4.DrawLatex(0.5, 0.55, "Zero Bias");
0334 
0335   c2->SaveAs("ratesMuon.pdf");
0336 
0337   TCanvas* c3 = new TCanvas;
0338   c3->SetLogy();
0339 
0340   gEtSumRate->SetLineWidth(2);
0341   gEtSumRate->SetLineColor(kMagenta);
0342   gEtSumRate->GetXaxis()->SetTitle("Threshold [GeV]");
0343   gEtSumRate->GetYaxis()->SetTitle("Rate");
0344   gEtSumRate->SetMarkerStyle(23);
0345   gEtSumRate->SetMarkerColor(kMagenta);
0346   gEtSumRate->GetYaxis()->SetRangeUser(1, 1e7);
0347   //gEtSumRate->Draw("APL");

0348 
0349   gHtSumRate->SetLineWidth(2);
0350   gHtSumRate->SetLineColor(kTeal);
0351   gHtSumRate->GetXaxis()->SetTitle("Threshold [GeV]");
0352   gHtSumRate->GetYaxis()->SetTitle("Rate");
0353   gHtSumRate->SetMarkerStyle(23);
0354   gHtSumRate->SetMarkerColor(kTeal);
0355   gHtSumRate->GetYaxis()->SetRangeUser(1, 1e7);
0356   gHtSumRate->SetTitle("");
0357   //gHtSumRate->Draw("sameAPL");

0358 
0359   TMultiGraph *mgSums = new TMultiGraph();
0360   mgSums->Add(gEtSumRate);
0361   mgSums->Add(gHtSumRate);
0362   mgSums->Draw("APL");
0363   mgSums->GetXaxis()->SetTitle("Threshold [GeV]");
0364   mgSums->GetYaxis()->SetTitle("Rate [kHz]");
0365   gPad->Modified();
0366   
0367   TLegend* leg3 = new TLegend(0.7,0.78,0.9,0.88);
0368   leg3->SetFillColor(0);
0369   leg3->AddEntry(gEtSumRate,"E_{T}^{total}","lp");
0370   leg3->AddEntry(gHtSumRate,"H_{T}","lp");
0371   leg3->SetBorderSize(0);
0372   leg3->SetFillStyle(0);
0373   leg3->Draw("same");
0374 
0375   n3.DrawLatex(0.6, 0.4, "Run 260627 #sqrt{s} = 13 TeV");
0376   n4.DrawLatex(0.6, 0.25, "Zero Bias");
0377   
0378   c3->SaveAs("ratesSums.pdf");
0379 
0380 
0381 
0382 
0383 
0384   TCanvas* c4 = new TCanvas;
0385   c4->SetLogy();
0386 
0387   gMetSumRate->SetLineWidth(2);
0388   gMetSumRate->SetLineColor(kViolet);
0389   gMetSumRate->GetXaxis()->SetTitle("Threshold [GeV]");
0390   gMetSumRate->GetYaxis()->SetTitle("Rate");
0391   gMetSumRate->SetMarkerStyle(23);
0392   gMetSumRate->SetMarkerColor(kViolet);
0393   gMetSumRate->GetYaxis()->SetRangeUser(1, 1e7);
0394   //gEtSumRate->Draw("APL");

0395 
0396   gMhtSumRate->SetLineWidth(2);
0397   gMhtSumRate->SetLineColor(kOrange);
0398   gMhtSumRate->GetXaxis()->SetTitle("Threshold [GeV]");
0399   gMhtSumRate->GetYaxis()->SetTitle("Rate");
0400   gMhtSumRate->SetMarkerStyle(23);
0401   gMhtSumRate->SetMarkerColor(kOrange);
0402   gMhtSumRate->GetYaxis()->SetRangeUser(1, 1e7);
0403   gMhtSumRate->SetTitle("");
0404   //gMhtSumRate->Draw("sameAPL");

0405 
0406   TMultiGraph *mgMsums = new TMultiGraph();
0407   mgMsums->Add(gMetSumRate);
0408   mgMsums->Add(gMhtSumRate);
0409   mgMsums->Draw("APL");
0410   mgMsums->GetXaxis()->SetTitle("Threshold [GeV]");
0411   mgMsums->GetYaxis()->SetTitle("Rate [kHz]");
0412   gPad->Modified();
0413   
0414   TLegend* leg4 = new TLegend(0.7,0.78,0.9,0.88);
0415   leg4->SetFillColor(0);
0416   leg4->AddEntry(gMetSumRate,"E_{T}^{miss}","lp");
0417   leg4->AddEntry(gMhtSumRate,"H_{T}^{miss}","lp");
0418   leg4->SetBorderSize(0);
0419   leg4->SetFillStyle(0);
0420   leg4->Draw("same");
0421 
0422   n3.DrawLatex(0.3, 0.4, "Run 260627 #sqrt{s} = 13 TeV");
0423   n4.DrawLatex(0.3, 0.25, "Zero Bias");
0424   
0425  
0426   
0427   c4->SaveAs("ratesMETMHT.pdf");
0428 
0429 
0430 
0431 
0432   // hJetEt->GetXaxis()->SetTitle("Jet E_{T} [GeV]");

0433   // hJetEt->GetYaxis()->SetTitle("Rate");

0434   // hJetEt->SetMarkerStyle(23);

0435   // hJetEt->SetMarkerColor(kGreen);

0436   // hJetEt->Scale(norm);

0437   // hJetEt->Draw("P");

0438   // c1.Print("hJetEt.pdf");

0439 
0440   // hEgEt->GetXaxis()->SetTitle("EG E_{T} [GeV]");

0441   // hEgEt->GetYaxis()->SetTitle("Rate");

0442   // hEgEt->SetMarkerStyle(23);

0443   // hEgEt->SetMarkerColor(kGreen);

0444   // hEgEt->Scale(norm);

0445   // hEgEt->Draw("P");

0446   // c1.Print("hEgEt.pdf");

0447   
0448 
0449   // hTauEt->GetXaxis()->SetTitle("Tau E_{T} [GeV]");

0450   // hTauEt->GetYaxis()->SetTitle("Rate");

0451   // hTauEt->SetMarkerStyle(23);

0452   // hTauEt->SetMarkerColor(kGreen);

0453   // hTauEt->Scale(norm);

0454   // hTauEt->Draw("P");

0455   // c1.Print("hTauEt.pdf");

0456 
0457   // hEtSum->GetXaxis()->SetTitle("E^{sum}_{T} [GeV]");

0458   // hEtSum->GetYaxis()->SetTitle("Rate");

0459   // hEtSum->SetMarkerStyle(23);

0460   // hEtSum->SetMarkerColor(kGreen);

0461   // hEtSum->Scale(norm);

0462   // hEtSum->Draw("P");

0463   // c1.Print("hEtSum.pdf");

0464 
0465   // hHtSum->GetXaxis()->SetTitle("H_{T} [GeV]");

0466   // hHtSum->GetYaxis()->SetTitle("Rate");

0467   // hHtSum->SetMarkerStyle(23);

0468   // hHtSum->SetMarkerColor(kGreen);

0469   // hHtSum->Scale(norm);

0470   // hHtSum->Draw("P");

0471   // c1.Print("hHtSum.pdf");

0472 
0473 
0474 
0475 
0476 
0477   // jetRates->GetXaxis()->SetTitle("E_{T} [GeV]");

0478   // jetRates->GetYaxis()->SetTitle("Rate");

0479   // jetRates->SetMarkerStyle(23);

0480   // jetRates->SetMarkerColor(kGreen);

0481   // jetRates->GetXaxis()->SetRangeUser(10,110);

0482   // jetRates->Scale(norm);

0483   // jetRates->Draw("P");

0484  
0485 
0486   // egRates->GetXaxis()->SetTitle("E_{T} [GeV]");

0487   // egRates->GetYaxis()->SetTitle("Rate");

0488   // egRates->SetMarkerStyle(23);

0489   // egRates->SetMarkerColor(kRed);

0490   // egRates->GetXaxis()->SetRangeUser(10,110);

0491   // egRates->Scale(norm);

0492   // egRates->Draw("sameP");

0493 
0494   // tauRates->GetXaxis()->SetTitle("E_{T} [GeV]");

0495   // tauRates->GetYaxis()->SetTitle("Rate");

0496   // tauRates->SetMarkerStyle(23);

0497   // tauRates->SetMarkerColor(kBlue);

0498   // tauRates->GetXaxis()->SetRangeUser(10,110);

0499   // tauRates->Scale(norm);

0500   // tauRates->Draw("sameP");

0501 
0502   // etSumRates->GetXaxis()->SetTitle("E_{T} [GeV]");

0503   // etSumRates->GetYaxis()->SetTitle("Rate");

0504   // etSumRates->SetMarkerStyle(23);

0505   // etSumRates->SetMarkerColor(kViolet);

0506   // etSumRates->GetXaxis()->SetRangeUser(10,110);

0507   // etSumRates->Scale(norm);

0508   // etSumRates->Draw("sameP");

0509 
0510   // htSumRates->GetXaxis()->SetTitle("E_{T} [GeV]");

0511   // htSumRates->GetYaxis()->SetTitle("Rate");

0512   // htSumRates->SetMarkerStyle(23);

0513   // htSumRates->SetMarkerColor(kTeal);

0514   // htSumRates->GetXaxis()->SetRangeUser(10,110);

0515   // htSumRates->Scale(norm);

0516   // htSumRates->Draw("sameP");

0517 
0518   
0519   // c1.SetLogy();

0520   // c1.Print("rates.pdf");

0521  
0522 
0523 
0524   //individual plots

0525 
0526 
0527   // jetRates->Draw("P");

0528   // c1.SetLogy();

0529   // c1.Print("jetRates.pdf"); 

0530  
0531   // egRates->Draw("P");

0532   // c1.SetLogy();

0533   // c1.Print("egRates.pdf");

0534 
0535   // tauRates->Draw("P");

0536   // c1.SetLogy();

0537   // c1.Print("tauRates.pdf");

0538 
0539   // etSumRates->Draw("P");

0540   // c1.SetLogy();

0541   // c1.Print("etSumRates.pdf");

0542 
0543   // htSumRates->Draw("P");

0544   // c1.SetLogy();

0545   // c1.Print("htSumRates.pdf");

0546 
0547 
0548   //c1.SetLogy();

0549   //c1.Print("rates.pdf");

0550 
0551   
0552 }