DAQ/macros/DrawTPCDataStreamEmulator.C

0001
0002 #include <TFile.h>
0003 #include <TGraphAsymmErrors.h>
0004 #include <TGraphErrors.h>
0005 #include <TH2.h>
0006 #include <TLatex.h>
0007 #include <TLegend.h>
0008 #include <TString.h>
0009 #include <TTree.h>
0010 #include <cassert>
0011 #include <cmath>
0012 #include "SaveCanvas.C"
0013 #include "sPhenixStyle.C"
0014
0015 TFile *_file0 = NULL;
0016 TString description;
0017
0018 void DataRate()
0019 {
0020   assert(_file0);
0021   TH1 *hNormalization = (TH1 *) _file0->GetObjectChecked("hNormalization", "TH1");
0022   assert(hNormalization);
0023
0024   TCanvas *c1 = new TCanvas("DataRate", "DataRate", 1700, 960);
0025   c1->Divide(1, 1);
0026   int idx = 1;
0027   TPad *p;
0028
0029   p = (TPad *) c1->cd(idx++);
0030   c1->Update();
0031   p->SetRightMargin(.15);
0032   //  p->SetLogy();
0033
0034   TH1 *hDataSize = (TH1 *) _file0->GetObjectChecked("hDataSize", "TH1");
0035   assert(hDataSize);
0036
0037   TH1 *h = (TH1 *) hDataSize->DrawClone();
0038   h->Sumw2();
0039   h->Scale(1. / hNormalization->GetBinContent(1));
0040   h->SetTitle(";TPC Event Size [Byte];Probability / bin");
0041
0042   //    h->Rebin(100);
0043   //    h->GetXaxis()->SetRangeUser(0,5e6);
0044   h->Rebin(100);
0045   h->GetXaxis()->SetRangeUser(0, 20e6);
0046
0047   h->GetYaxis()->SetRangeUser(0, .05);
0048
0049   TLegend *leg = new TLegend(.2, .7, .8, .92);
0050   leg->AddEntry("", "#it{#bf{sPHENIX}} Simulation", "");
0051   leg->AddEntry("", description, "");
0052   leg->AddEntry("", Form("<Event size> = %.1f MB (before compression)", hDataSize->GetMean() / 1e6), "");
0053   leg->AddEntry("", Form("Data rate = %.0f Gbps (15 kHz trig., LZO compression)", hDataSize->GetMean() * 8 * .6 * 15e3 / 1e9), "");
0054   leg->Draw();
0055
0056   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0057 }
0058
0059 TH1 *MakeCDF(TH1 *h)
0060 {
0061   assert(h);
0062
0063   TH1 *hCDF = (TH1 *) h->Clone(TString("CDF") + h->GetName());
0064   hCDF->SetDirectory(NULL);
0065
0066   double integral = 0;
0067
0068   for (int bin = h->GetNbinsX() + 1; bin >= 0; --bin)
0069   {
0070     integral += h->GetBinContent(bin);
0071     hCDF->SetBinContent(bin, integral);
0072   }
0073
0074   for (int bin = h->GetNbinsX() + 1; bin >= 0; --bin)
0075   {
0076     hCDF->SetBinContent(bin, hCDF->GetBinContent(bin) / integral);
0077     hCDF->SetBinError(bin, 0);
0078   }
0079
0080   return hCDF;
0081 }
0082
0083 void FEEDataSize()
0084 {
0085   assert(_file0);
0086   TH1 *hNormalization = (TH1 *) _file0->GetObjectChecked("hNormalization", "TH1");
0087   assert(hNormalization);
0088
0089   TH2 *hFEEDataSize = (TH2 *) _file0->GetObjectChecked("hFEEDataSize", "TH2");
0090   assert(hFEEDataSize);
0091
0092   Color_t linecolors[] = {kBlack, kRed + 2, kBlue + 2, kGreen + 2, kBlack};
0093
0094   // Save raw
0095   TCanvas *c = new TCanvas("FEEDataSize_raw", "FEEDataSize_raw", 1900, 760);
0096   c->Divide(3, 1);
0097   int idx = 1;
0098   TPad *p;
0099   for (int module = 1; module <= 3; module++)
0100   {
0101     p = (TPad *) c->cd(idx++);
0102     c->Update();
0103     p->SetRightMargin(.15);
0104
0105     TString name = Form("hFEEDataSize_module%d", module);
0106
0107     (TH1 *) hFEEDataSize->ProjectionX(name, module, module)->DrawClone("");
0108   }
0109   SaveCanvas(c, TString(_file0->GetName()) + TString(c->GetName()), kTRUE);
0110
0111   // Plot
0112   TCanvas *c1 = new TCanvas("FEEDataSize", "FEEDataSize", 1900, 760);
0113   c1->Divide(2, 1);
0114   idx = 1;
0115
0116   p = (TPad *) c1->cd(idx++);
0117   c1->Update();
0118   p->SetRightMargin(.15);
0119   TH1 *frame = p->DrawFrame(0, 0, 50e3, .8e6);
0120   frame->SetTitle(";TPC FELIX Per-Drift Data Size [Byte];Count");
0121   frame->GetXaxis()->SetNdivisions(15, 5, 1, true);
0122
0123   TLegend *leg = new TLegend(.2, .6, .85, .92);
0124
0125   leg->AddEntry("", "#it{#bf{sPHENIX}} Simulation", "");
0126   leg->AddEntry("", description, "");
0127
0128   p = (TPad *) c1->cd(idx++);
0129   c1->Update();
0130   p->SetRightMargin(.15);
0131   frame = p->DrawFrame(0, 1e-5, 50e3, 1);
0132   frame->SetTitle(";TPC FELIX Per-Drift Data Size [Byte];CCDF");
0133   frame->GetXaxis()->SetNdivisions(15, 5, 1, true);
0134   p->SetLogy();
0135
0136   for (int module = 1; module <= 3; module++)
0137   {
0138     p = (TPad *) c1->cd(1);
0139     c1->Update();
0140
0141     TString name = Form("hFEEDataSize_module%d", module);
0142
0143     TH1 *h_FEE_raw = (TH1 *) hFEEDataSize->ProjectionX(name, module, module);
0144     TH1 *h_FEE = (TH1 *) h_FEE_raw->DrawClone("same");
0145     h_FEE->Sumw2();
0146     h_FEE->Rebin(100);
0147
0148     h_FEE->SetLineColor(linecolors[module]);
0149     h_FEE->SetMarkerColor(linecolors[module]);
0150
0151     leg->AddEntry(h_FEE, Form("Module%d: <Data/Drift/FEE> = %.1f kB", module, h_FEE->GetMean() / 1e3), "lp");
0152
0153     p = (TPad *) c1->cd(2);
0154     c1->Update();
0155
0156     h_FEE = MakeCDF(h_FEE_raw);
0157     h_FEE->SetLineColor(linecolors[module]);
0158     h_FEE->Draw("same");
0159     h_FEE->GetXaxis()->SetRangeUser(0, 1e6);
0160   }
0161
0162   p = (TPad *) c1->cd(1);
0163   leg->Draw();
0164
0165   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0166 }
0167
0168 void SectorDataSize()
0169 {
0170   assert(_file0);
0171   TH1 *hNormalization = (TH1 *) _file0->GetObjectChecked("hNormalization", "TH1");
0172   assert(hNormalization);
0173
0174   TH1 *hSectorDataSize = (TH1 *) _file0->GetObjectChecked("hSectorDataSize", "TH1");
0175   assert(hSectorDataSize);
0176
0177   // Save raw
0178   TCanvas *c = new TCanvas("SectorDataSize_raw", "SectorDataSize_raw", 1000, 760);
0179   TH1 *h = (TH1 *) hSectorDataSize->DrawClone();
0180   SaveCanvas(c, TString(_file0->GetName()) + TString(c->GetName()), kTRUE);
0181
0182   //plot
0183   TCanvas *c1 = new TCanvas("SectorDataSize", "SectorDataSize", 2000, 760);
0184   c1->Divide(2, 1);
0185   int idx = 1;
0186   TPad *p;
0187
0188   p = (TPad *) c1->cd(idx++);
0189   c1->Update();
0190   p->SetRightMargin(.15);
0191   //    p->SetLogy();
0192
0193   h = (TH1 *) hSectorDataSize->DrawClone();
0194   h->Sumw2();
0195   //  h->Scale(1. / hNormalization->GetBinContent(1) / 24);
0196   h->SetTitle(";TPC FELIX Per-DriftWindow Data Size [Byte];Count");
0197
0198   h->Rebin(100);
0199   //    h->GetXaxis()->SetRangeUser(0,5e6);
0200   //  h->Rebin(20);
0201   h->GetXaxis()->SetRangeUser(0, 2e6);
0202
0203   //  h->GetYaxis()->SetRangeUser(0, .5);
0204
0205   TLegend *leg = new TLegend(.35, .7, .85, .92);
0206   leg->AddEntry("", "#it{#bf{sPHENIX}} Simulation", "");
0207   leg->AddEntry("", description, "");
0208   leg->AddEntry("", Form("<Data/Drift Window/FELIX> = %.2f MB", hSectorDataSize->GetMean() / 1e6), "");
0209   leg->Draw();
0210
0211   p = (TPad *) c1->cd(idx++);
0212   c1->Update();
0213   p->SetRightMargin(.15);
0214   p->SetLogy();
0215
0216   h = MakeCDF(hSectorDataSize);
0217   h->Draw();
0218   h->SetTitle(";TPC FELIX Per-Drift Data Size [Byte];CCDF");
0219
0220   h->GetXaxis()->SetRangeUser(0, 1e6);
0221
0222   //  h->GetYaxis()->SetRangeUser(0, .5);
0223
0224   //  TLegend *leg = new TLegend(.2, .7, .8, .92);
0225   //  leg->AddEntry("", "#it{#bf{sPHENIX}} Simulation", "");
0226   //  leg->AddEntry("", description, "");
0227   //  leg->AddEntry("", Form("<Event size> = %.1f MB (before compression)", hDataSize->GetMean() / 1e6), "");
0228   //  leg->AddEntry("", Form("Data rate = %.0f Gbps (15 kHz trig., LZO compression)", hDataSize->GetMean() * 8 * .6 * 15e3 / 1e9), "");
0229   //  leg->Draw();
0230
0231   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0232 }
0233
0234 void dNdeta()
0235 {
0236   assert(_file0);
0237   TH1 *hNormalization = (TH1 *) _file0->GetObjectChecked("hNormalization", "TH1");
0238   assert(hNormalization);
0239
0240   TCanvas *c1 = new TCanvas("dNdeta", "dNdeta", 1800, 960);
0241   c1->Divide(1, 1);
0242   int idx = 1;
0243   TPad *p;
0244
0245   p = (TPad *) c1->cd(idx++);
0246   c1->Update();
0247   //  p->SetLogy();
0248
0249   TH1 *hNChEta = (TH1 *) _file0->GetObjectChecked("hNChEta", "TH1");
0250   assert(hNChEta);
0251
0252   TH1 *h = (TH1 *) hNChEta->DrawClone();
0253   h->Sumw2();
0254   h->Rebin(10);
0255   h->Scale(1. / hNormalization->GetBinContent(2));
0256   h->Scale(1. / h->GetXaxis()->GetBinWidth(1));
0257   h->SetTitle(";#eta;dN_{Ch}/d#eta");
0258
0259   TLegend *leg = new TLegend(.3, .25, .8, .45);
0260   leg->AddEntry("", "#it{#bf{sPHENIX}} Simulation", "");
0261   leg->AddEntry("", description, "");
0262   leg->AddEntry("", "dN_{Ch}/d#eta, sHIJING to Geant4 input", "");
0263   leg->Draw();
0264
0265   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0266 }
0267
0268 void ChargeCheck()
0269 {
0270   assert(_file0);
0271
0272   TCanvas *c1 = new TCanvas("ChargeCheck", "ChargeCheck", 1800, 960);
0273   c1->Divide(1, 1);
0274   int idx = 1;
0275   TPad *p;
0276
0277   p = (TPad *) c1->cd(idx++);
0278   c1->Update();
0279   p->SetRightMargin(.2);
0280
0281   TH2 *hLayerZBinADC = (TH2 *) _file0->GetObjectChecked("hLayerZBinADC", "TH2");
0282   assert(hLayerZBinADC);
0283
0284   hLayerZBinADC->Draw("colz");
0285
0286   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0287 }
0288
0289 void WaveletCheck()
0290 {
0291   assert(_file0);
0292
0293   TCanvas *c1 = new TCanvas("WaveletCheck", "WaveletCheck", 1800, 960);
0294   c1->Divide(1, 1);
0295   int idx = 1;
0296   TPad *p;
0297
0298   p = (TPad *) c1->cd(idx++);
0299   c1->Update();
0300   p->SetLogz();
0301   p->SetRightMargin(.15);
0302
0303   TH2 *hLayerWaveletSize = (TH2 *) _file0->GetObjectChecked("hLayerWaveletSize", "TH2");
0304   assert(hLayerWaveletSize);
0305
0306   hLayerWaveletSize->GetYaxis()->SetRangeUser(0, 260);
0307   hLayerWaveletSize->Draw("colz");
0308
0309   p = (TPad *) c1->cd(idx++);
0310   c1->Update();
0311   p->SetLogy();
0312
0313   hLayerWaveletSize->ProjectionY()->Draw();
0314
0315   TLegend *leg = new TLegend(.2, .7, .8, .92);
0316   leg->AddEntry("", "#it{#bf{sPHENIX}} Simulation", "");
0317   leg->AddEntry("", description, "");
0318   leg->Draw();
0319   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0320 }
0321
0322 void Check1()
0323 {
0324   assert(_file0);
0325
0326   TCanvas *c1 = new TCanvas("Check1", "Check1", 1800, 960);
0327   c1->Divide(3, 2);
0328   int idx = 1;
0329   TPad *p;
0330
0331   p = (TPad *) c1->cd(idx++);
0332   c1->Update();
0333   p->SetLogy();
0334
0335   TH1 *hNormalization = (TH1 *) _file0->GetObjectChecked("hNormalization", "TH1");
0336   assert(hNormalization);
0337
0338   hNormalization->Draw();
0339
0340   p = (TPad *) c1->cd(idx++);
0341   c1->Update();
0342   p->SetLogy();
0343   p->SetRightMargin(.1);
0344
0345   TH1 *hDataSize = (TH1 *) _file0->GetObjectChecked("hDataSize", "TH1");
0346   assert(hDataSize);
0347
0348   TH1 *h = (TH1 *) hDataSize->DrawClone();
0349   h->Rebin(400);
0350
0351   p = (TPad *) c1->cd(idx++);
0352   c1->Update();
0353   p->SetLogy();
0354
0355   TH1 *hWavelet = (TH1 *) _file0->GetObjectChecked("hWavelet", "TH1");
0356   assert(hWavelet);
0357
0358   h = (TH1 *) hWavelet->DrawClone();
0359   h->Rebin(400);
0360
0361   p = (TPad *) c1->cd(idx++);
0362   c1->Update();
0363   p->SetLogz();
0364   p->SetRightMargin(.15);
0365
0366   TH2 *hLayerWaveletSize = (TH2 *) _file0->GetObjectChecked("hLayerWaveletSize", "TH2");
0367   assert(hLayerWaveletSize);
0368
0369   hLayerWaveletSize->Draw("colz");
0370
0371   p = (TPad *) c1->cd(idx++);
0372   c1->Update();
0373   //  p->SetLogy();
0374
0375   TH1 *hNChEta = (TH1 *) _file0->GetObjectChecked("hNChEta", "TH1");
0376   assert(hNChEta);
0377
0378   hNChEta->DrawClone();
0379
0380   p = (TPad *) c1->cd(idx++);
0381   c1->Update();
0382   //  p->SetLogy();
0383
0384   hNChEta = (TH1 *) _file0->GetObjectChecked("hNChEta", "TH1");
0385   assert(hNChEta);
0386
0387   h = (TH1 *) hNChEta->DrawClone();
0388   h->Sumw2();
0389   h->Rebin(100);
0390   h->Scale(1. / hNormalization->GetBinContent(1));
0391
0392   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0393 }
0394
0395 void Occupancy()
0396 {
0397   assert(_file0);
0398
0399   TCanvas *c1 = new TCanvas("Occupancy", "Occupancy", 1800, 960);
0400   //  c1->Divide(3, 2);
0401   int idx = 1;
0402   TPad *p;
0403
0404   p = (TPad *) c1->cd(idx++);
0405   c1->Update();
0406   p->SetLogz();
0407   p->SetRightMargin(.15);
0408
0409   TH2 *hLayerHit = (TH2 *) _file0->GetObjectChecked("hLayerHit", "TH2");
0410   assert(hLayerHit);
0411
0412   hLayerHit->GetYaxis()->SetRangeUser(0, 260);
0413   hLayerHit->Draw("colz");
0414
0415   hLayerHit->ProfileY()->Draw("same");
0416
0417   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0418 }
0419
0420 void Check2()
0421 {
0422   assert(_file0);
0423
0424   TCanvas *c1 = new TCanvas("Check2", "Check2", 1800, 960);
0425   c1->Divide(3, 2);
0426   int idx = 1;
0427   TPad *p;
0428
0429   p = (TPad *) c1->cd(idx++);
0430   c1->Update();
0431   p->SetLogz();
0432   p->SetRightMargin(.15);
0433
0434   TH2 *hLayerHit = (TH2 *) _file0->GetObjectChecked("hLayerHit", "TH2");
0435   assert(hLayerHit);
0436
0437   hLayerHit->GetYaxis()->SetRangeUser(0, 260);
0438   hLayerHit->Draw("colz");
0439
0440   p = (TPad *) c1->cd(idx++);
0441   c1->Update();
0442   p->SetLogz();
0443   p->SetRightMargin(.15);
0444
0445   TH2 *hLayerDataSize = (TH2 *) _file0->GetObjectChecked("hLayerDataSize", "TH2");
0446   assert(hLayerDataSize);
0447
0448   hLayerDataSize->Draw("colz");
0449
0450   p = (TPad *) c1->cd(idx++);
0451   c1->Update();
0452   p->SetRightMargin(.15);
0453   //  p->SetLogz();
0454
0455   TH2 *hLayerSumHit = (TH2 *) _file0->GetObjectChecked("hLayerSumHit", "TH2");
0456   assert(hLayerSumHit);
0457
0458   hLayerSumHit->Draw("colz");
0459
0460   p = (TPad *) c1->cd(idx++);
0461   c1->Update();
0462   p->SetRightMargin(.15);
0463   //  p->SetLogz();
0464
0465   TH2 *hLayerSumDataSize = (TH2 *) _file0->GetObjectChecked("hLayerSumDataSize", "TH2");
0466   assert(hLayerSumDataSize);
0467
0468   hLayerSumDataSize->Draw("colz");
0469
0470   p = (TPad *) c1->cd(idx++);
0471   c1->Update();
0472   p->SetRightMargin(.15);
0473   //  p->SetLogz();
0474
0475   TH2 *hLayerZBinHit = (TH2 *) _file0->GetObjectChecked("hLayerZBinHit", "TH2");
0476   assert(hLayerZBinHit);
0477
0478   hLayerZBinHit->Draw("colz");
0479
0480   p = (TPad *) c1->cd(idx++);
0481   c1->Update();
0482   p->SetRightMargin(.15);
0483   //  p->SetLogz();
0484
0485   TH2 *hLayerZBinADC = (TH2 *) _file0->GetObjectChecked("hLayerZBinADC", "TH2");
0486   assert(hLayerZBinADC);
0487
0488   hLayerZBinADC->Draw("colz");
0489   SaveCanvas(c1, TString(_file0->GetName()) + TString(c1->GetName()), kTRUE);
0490 }
0491
0492 void DrawTPCDataStreamEmulator(
0493     //        const TString infile = "data/TPCIntegratedCharge_AuAu0-4fm_200kHz.root",
0494     //        const TString disc = "Au+Au 0-7%C Triggered + 200 kHz collision"  //
0495     //    const TString infile = "data/TPCDataStreamEmulator_AuAu0-12fm_170kHz_2.root",
0496     //    const TString disc = "Au+Au 0-12fm Triggered + 170 kHz collision"  //
0497     //            const TString infile = "data/TPCDataStreamEmulator_AuAu0-14.7fm_0kHz_1.root",
0498     //            const TString disc = "Au+Au 0-14.7fm Triggered + No pileup collision"  //
0499     //    const TString infile = "data/TPCDataStreamEmulator_AuAu0-14.7fm_170kHz_1.root",
0500     //    const TString infile = "/sphenix/user/jinhuang/TPC/Multiplicity/AuAu200MB_170kHz_Iter2/AuAu200MB_170kHz_Iter2_SUM.xml_TPCDataStreamEmulator.root",
0501     //    const TString disc = "Au+Au 0-20fm Triggered + 170 kHz collision"  //
0502     //    const TString infile = "/sphenix/user/jinhuang/TPC/Multiplicity/AuAu200MB_170kHz_Stream_Iter3/AuAu200MB_170kHz_Stream_Iter3_SUM.xml_TPCDataStreamEmulator.root",
0503 //    const TString infile = "/sphenix/user/jinhuang/TPC/TPCMLDataInterface//170kHz_RandomTimeFrame_Iter2/170kHz_RandomTimeFrame_Iter2_SUM.xml_TPCMLDataInterface.root",
0504 //    const TString disc = "Au+Au 0-20fm 170 kHz collision in 13#mus"  //
0505         const TString infile = "/sphenix/user/jinhuang/TPC/TPCMLDataInterface/AuAu200_170kHz_MB_Iter2/AuAu200_170kHz_MB_Iter2_SUM.xml_TPCMLDataInterface.root",
0506         const TString disc = "Au+Au 170 kHz collision + M.B. in 13#mus"
0507         //        const TString infile = "/sphenix/user/jinhuang/TPC/TPCMLDataInterface/AuAu200_170kHz_10C_Iter2/AuAu200_170kHz_10C_Iter2_SUM.xml_TPCMLDataInterface.root",
0508 //        const TString disc = "Au+Au 0-20fm 170 kHz + 10%C collision in 13#mus"  //
0509                                                                      //        const TString infile = "data/TPCDataStreamEmulator_AuAu0-12fm_0kHz.root",
0510                                                                      //        const TString disc = "Au+Au MB Triggered + 0 kHz collision"  //
0511 )
0512 {
0513   SetsPhenixStyle();
0514   gStyle->SetOptStat(0);
0515   gStyle->SetOptFit(1111);
0516   TVirtualFitter::SetDefaultFitter("Minuit2");
0517
0518   _file0 = new TFile(infile);
0519   assert(_file0->IsOpen());
0520   description = disc;
0521
0522   WaveletCheck();
0523   DataRate();
0524 //  SectorDataSize();
0525 //  FEEDataSize();
0526   Occupancy();
0527   //
0528   dNdeta();
0529   ChargeCheck();
0530   //
0531   Check1();
0532   Check2();
0533 }