// Draw label for Decay Channel in upper left corner of plot
void DrawPrelimLabel(int cmsprelim, double textSize) {
TPaveText *cms = new TPaveText();
cms->AddText("CMS");
cms->SetX1NDC( gStyle->GetPadLeftMargin() + gStyle->GetTickLength() );
cms->SetY1NDC(1.0 - gStyle->GetPadTopMargin() - gStyle->GetTickLength() - 0.05 );
cms->SetX2NDC( gStyle->GetPadLeftMargin() + gStyle->GetTickLength() + 0.15 );
cms->SetY2NDC(1.0 - gStyle->GetPadTopMargin() - gStyle->GetTickLength() );
cms->SetFillStyle(0);
cms->SetBorderSize(0);
if (textSize!=0) cms->SetTextSize(textSize*1.1);
cms->SetTextAlign(12);
cms->SetTextFont(61);
cms->Draw("same");
if(cmsprelim > 0) {
TPaveText *extra = new TPaveText();
if(cmsprelim == 2) { extra->AddText("Private Work"); }
else { extra->AddText("Preliminary"); }
extra->SetX1NDC( gStyle->GetPadLeftMargin() + gStyle->GetTickLength() );
extra->SetY1NDC(1.0 - gStyle->GetPadTopMargin() - gStyle->GetTickLength() - 0.10 );
extra->SetX2NDC( gStyle->GetPadLeftMargin() + gStyle->GetTickLength() + 0.15 );
extra->SetY2NDC(1.0 - gStyle->GetPadTopMargin() - gStyle->GetTickLength() - 0.05 );
extra->SetFillStyle(0);
extra->SetBorderSize(0);
if (textSize!=0) extra->SetTextSize(textSize);
extra->SetTextAlign(12);
extra->SetTextFont(52);
extra->Draw("same");
}
}
// Draw statistics info above plot
void DrawCMSLabels(double lumi, double energy, double textSize) {
//const char *text = "%2.1f #times 10^{6} clusters (fiducial) (%1.1f GeV)";
const char *text;
if(lumi > 10000000) {
lumi /= 10000000;
text = "%2.1f #times 10^{7} tracks (%1.1f GeV)";
}
else {
lumi /= 1000000;
text = "%2.1f #times 10^{6} tracks (%1.1f GeV)";
}
TPaveText *label = new TPaveText();
label->SetX1NDC(gStyle->GetPadLeftMargin());
label->SetY1NDC(1.0-gStyle->GetPadTopMargin());
label->SetX2NDC(1.0-gStyle->GetPadRightMargin());
label->SetY2NDC(1.0);
label->SetTextFont(42);
label->AddText(Form(text, lumi, energy));
label->SetFillStyle(0);
label->SetBorderSize(0);
if (textSize!=0) label->SetTextSize(textSize);
label->SetTextAlign(32);
label->Draw("same");
}
// Draw label for Decay Channel in upper left corner of plot
void DrawDecayChLabel(TString decaychannel, double textSize) {
TPaveText *decch = new TPaveText();
decch->AddText(decaychannel);
decch->SetX1NDC( gStyle->GetPadLeftMargin() + gStyle->GetTickLength() );
decch->SetY1NDC(1.0 - gStyle->GetPadTopMargin() - gStyle->GetTickLength() - 0.05 );
decch->SetX2NDC( gStyle->GetPadLeftMargin() + gStyle->GetTickLength() + 0.15 );
decch->SetY2NDC(1.0 - gStyle->GetPadTopMargin() - gStyle->GetTickLength() );
decch->SetFillStyle(0);
decch->SetBorderSize(0);
if (textSize!=0) decch->SetTextSize(textSize);
decch->SetTextAlign(12);
decch->Draw("same");
}
void DrawFreeCMSLabels(char* text, double textSize) {
//const char *text = "%2.1f #times 10^{6} clusters (fiducial) (%1.1f GeV)";
//char *text = "%2.1f #times 10^{6} clusters (fiducial)";
TPaveText *label = new TPaveText();
label->SetX1NDC(gStyle->GetPadLeftMargin());
label->SetY1NDC(1.0-gStyle->GetPadTopMargin());
label->SetX2NDC(1.0-gStyle->GetPadRightMargin());
label->SetY2NDC(1.0);
label->SetTextFont(42);
label->AddText(text);
label->SetFillStyle(0);
label->SetBorderSize(0);
if (textSize!=0) label->SetTextSize(textSize);
label->SetTextAlign(32);
label->Draw("same");
}
// Draw official labels (CMS Preliminary, luminosity and CM energy) above plot
void DrawCMSLabels(int cmsprelim=1, double energy=8, double textSize=0.04) {
const char *text;
if(cmsprelim ==2 ) {//Private work for PhDs students
text = "Private Work, Simulation at #sqrt{s} = %2.f TeV";
} else if (cmsprelim==1) {//CMS preliminary label
text = "CMS Preliminary, Simulation at #sqrt{s} = %2.f TeV";
} else {//CMS label
text = "CMS, Simulation at #sqrt{s} = %2.f TeV";
}
TPaveText *label = new TPaveText();
label->SetX1NDC(gStyle->GetPadLeftMargin());
label->SetY1NDC(1.0-gStyle->GetPadTopMargin());
label->SetX2NDC(1.0-gStyle->GetPadRightMargin());
label->SetY2NDC(1.0);
label->SetTextFont(42);
label->AddText(Form(text, energy));
label->SetFillStyle(0);
label->SetBorderSize(0);
if (textSize!=0) label->SetTextSize(textSize);
label->SetTextAlign(32);
label->Draw("same");
}
int fgtRawSpectraQA( const Char_t *filenameIn = "testfile.daq",
const Char_t *filebaseOut = "testfile.rawQA",
Int_t date = 20120115,
Int_t time = 0,
Float_t pedRelThres = 0, // 0 = no cut, otherwise: # of sigma above pedestal for cut
Int_t nevents = 2000,
Int_t timebin = 2,
UInt_t statusMask,
Bool_t cutShortEvents = 1 ){
LoadLibs();
Int_t ierr = 0;
//
// START CONSTRUCTING THE CHAIN
//
cout << "Constructing the chain" << endl;
analysisChain = new StChain("eemcAnalysisChain");
//
// THE DATABASE
//
// note: DB is used to convert elec coords into geoIds in
// StEvent/StFgtStrip, and do determine the disc and quad given
// an rdo/arm/apv combination.
cout << "Constructing St_db_Maker" << endl;
TString dir0 = "MySQL:StarDb";
TString dir1 = "$STAR/StarDb";
St_db_Maker *dbMkr = new St_db_Maker( "dbMkr", dir0, dir1 );
dbMkr->SetDateTime(date,time);
cout << "Constructing StFgtDbMaker" << endl;
fgtDbMkr = new StFgtDbMaker( "fgtDbMkr" );
//
// NOW THE OTHER READERS AND MAKERS
//
cout << "Constructing the daq reader" << endl;
daqRdr = new StFgtRawDaqReader( "daqReader", filenameIn, "" );
daqRdr->setIsCosmic( 0 );
daqRdr->cutShortEvents( cutShortEvents );
// a2cMkr = new StFgtA2CMaker( "a2cMkr" );
// a2cMkr->setStatusMask( statusMask );
// a2cMkr->setAbsThres( -10000 ); // set to below -4096 to skip cut
// a2cMkr->setRelThres( pedRelThres ); // set to zero to skip cut
cout << "Constructing the QA Makers" << endl;
qaMkr = new StFgtQaRawOctAdc( "qaMkr", 2 );
qaMkr->setTimeBin( 2 );
// debug
analysisChain->ls(4);
cout << "Initializing" << endl;
ierr = analysisChain->Init();
if( ierr ){
cout << "Error initializing" << endl;
return;
};
if( nevents < 0 )
nevents = 1<<30; // a big number
cout << "max nevents = " << nevents << endl;
for( int i=0; i<nevents && !ierr; ++i ){
if( i+1 % 100 == 0 )
cout << "\ton event number " << i << endl;
//cout << "clear" << endl;
analysisChain->Clear();
//cout << "make" << endl;
ierr = analysisChain->Make();
};
//
// Calls the ::Finish() method on all makers
//
cout << "finish" << endl;
analysisChain->Finish();
cout << "Making plots" << endl;
gROOT->SetStyle("Plain");
gStyle->SetOptStat(0);
gStyle->SetPalette(1);
can = new TCanvas( "fgtRawQA", "fgtRawQA", 850, 1100);
can->Divide( 1, 4 );
// open output file
can->Print( (std::string(filebaseOut) + ".ps[").data() );
//std::vector< TH2F* >& hist = qaMkr->getHistVec();
cout << "First hist at " << qaMkr->getHist(0) << endl;
cout << "Finding max" << endl;
// get max
Float_t max = 0;
for( Int_t idx = 0; idx < 48; ++idx ){
if( qaMkr->getHist(idx) )
if( qaMkr->getHist(idx)->GetMaximum() > max )
max = qaMkr->getHist(idx)->GetMaximum();
};
max = 0.9*max;
cout << "Max is " << max << endl;
TH2F *dummy[4];
const Char_t dummyNames[4][20] = { "dummy1", "dummy2", "dummy3", "dummy4" };
Float_t xMin = qaMkr->getHist(0)->GetXaxis()->GetXmin();
Float_t xMax = qaMkr->getHist(0)->GetXaxis()->GetXmax();
Float_t yMin = qaMkr->getHist(0)->GetYaxis()->GetXmin();
Float_t yMax = qaMkr->getHist(0)->GetYaxis()->GetXmax();
for( Int_t i=0; i<4; ++i )
dummy[i] = new TH2F( dummyNames[i], "", 5, xMin, xMax, 1, yMin, yMax );
std::stringstream ss;
Int_t subpad = 1;
idx = 0;
for( Int_t rdo = 1; rdo < 3; ++rdo ){
for( Int_t arm = 0; arm < 6; ++arm ){
for( Int_t startIdx = 0; startIdx < 4; ++startIdx, ++idx ){
for( Int_t oct = 0; oct < 1; ++oct ){
cout << "rdo/arm/disc/oct = " << rdo << '/' << arm << '/' << startIdx << '/' << oct << endl;
if( qaMkr->getHist(idx)->GetEntries() > 0 ){
can->cd(subpad);
gPad->SetLeftMargin( 0.06 );
gPad->SetRightMargin( 0.05 );
gPad->SetBottomMargin( 0.11 );
qaMkr->getHist(idx)->SetMaximum( max );
dummy[subpad-1]->GetXaxis()->SetTitleOffset(0.9);
dummy[subpad-1]->GetXaxis()->SetTitleSize(0.06);
dummy[subpad-1]->GetXaxis()->SetLabelSize(0.06);
dummy[subpad-1]->GetYaxis()->SetTitleOffset(0.55);
dummy[subpad-1]->GetYaxis()->SetTitleSize(0.06);
dummy[subpad-1]->GetYaxis()->SetLabelSize(0.06);
gPad->SetGridx(0);
gPad->SetGridy(0);
for( Int_t i = 0; i<5; ++i ){
ss.str("");
ss.clear();
ss << "channels in APV "; // startArray[startIdx]+i;
dummy[subpad-1]->GetXaxis()->SetBinLabel( i+1, ss.str().data() );
};
dummy[subpad-1]->GetXaxis()->SetNdivisions(222,0);
dummy[subpad-1]->SetMinimum( 0 );
dummy[subpad-1]->SetMaximum( max );
dummy[subpad-1]->SetTitle( qaMkr->getHist(idx)->GetTitle() );
qaMkr->getHist(idx)->SetTitle("");
dummy[subpad-1]->GetYaxis()->SetTitle( qaMkr->getHist(idx)->GetYaxis()->GetTitle() );
qaMkr->getHist(idx)->GetYaxis()->SetTitle("");
dummy[subpad-1]->Draw("COLZ");
qaMkr->getHist(idx)->Draw("COLZ SAME");
gPad->Update();
gPad->Modified();
TPaveText *title = (TPaveText*)(gPad->GetPrimitive("title"));
if( title ){
title->SetX1NDC( 0.045 );
title->SetX2NDC( 0.55 );
title->SetY1NDC( 0.91 ) ;
title->SetY2NDC( 0.999 );
title->SetBorderSize(0);
title->SetTextAlign( 12 );
title->SetTextColor(kBlue);
title->Draw();
};
TPave *palette = (TPave*)(gPad->GetPrimitive("palette"));
if( palette ){
palette->SetX1NDC( 0.955 );
palette->SetX2NDC( 0.985 );
palette->Draw();
};
++subpad;
if( subpad == 5 ){
subpad = 1;
can->Print( (std::string(filebaseOut) + ".ps").data() );
};
};
};
};
};
};
if( subpad != 1 )
can->Print( (std::string(filebaseOut) + ".ps").data() );
can->Print( (std::string(filebaseOut) + ".ps]").data() );
gSystem->Exec(( std::string("ps2pdf -dAutoRotatePages=/None ") + filebaseOut + ".ps" ).data());
cerr << "\tall done" << endl;
return;
};
void makeMuonTimingPlot (std::string fname)
{
TFile file(fname.c_str());
TDirectoryFile *dir = (TDirectoryFile*)file.Get("Muons");
TList *hlist = dir->GetListOfKeys();
TH1F *h1;
bool foundHist = false;
for (auto hist : *hlist)
{
TString name = hist->GetName();
if (!name.Contains("hMuTimeP")) continue;
TH1F *h0 = (TH1F*)dir->Get(name.Data());
if (!foundHist)
{
h1 = (TH1F*)h0->Clone();
h1->Sumw2();
foundHist = true;
}
else
{
h1->Add(h0);
}
}
TH1F *h2 = new TH1F("h2", "h2", 200, -100, 100);
h2->GetXaxis()->SetTitle("muon time (ns)");
h2->GetYaxis()->SetTitle("Fraction of Muons/ns");
h2->GetYaxis()->SetTitleOffset(1.1);
h2->GetXaxis()->SetTitleOffset(0.8);
h2->SetTitle("CSC Muon Time");
h2->SetTitleFont(42);
h2->SetTitleSize(0.052);
h2->Sumw2();
h2->SetLineColor(kCyan+3);
h2->SetFillColor(kCyan+3);
for (int ibin = 1; ibin <= 200; ibin++)
{
h2->SetBinContent(ibin, h1->GetBinContent(ibin));
h2->SetBinError(ibin, h1->GetBinError(ibin));
if (ibin == 200)
h2->SetEntries(h1->GetEntries());
}
TCanvas c1("c1", "c1", 600, 400);
gStyle->SetOptStat("");
double rms = h2->GetRMS();
double avg = h2->GetMean();
TLatex cms(0.17, 0.83, "CMS");
cms.SetNDC();
cms.SetTextFont(61);
cms.SetTextSize(0.06);
TLatex prelim(0.17, 0.81, "Preliminary");
prelim.SetNDC();
prelim.SetTextAlign(13);
prelim.SetTextFont(52);
prelim.SetTextSize(0.0456);
TLatex data(0.17, 0.76, "Data 2016");
data.SetNDC();
data.SetTextAlign(13);
data.SetTextFont(52);
data.SetTextSize(0.0456);
TLatex lumi(0.9, 0.93, "4.0 fb^{-1} (13 TeV)");
lumi.SetNDC();
lumi.SetTextAlign(31);
lumi.SetTextFont(42);
lumi.SetTextSize(0.052);
TLatex mean(0.7, 0.81, Form("Mean %2.1f", avg));
mean.SetNDC();
mean.SetTextAlign(11);
mean.SetTextFont(61);
mean.SetTextSize(0.06);
TLatex stdev(0.7, 0.76, Form("RMS %2.1f", rms));
stdev.SetNDC();
stdev.SetTextAlign(11);
stdev.SetTextFont(61);
stdev.SetTextSize(0.06);
h2->GetXaxis()->SetRangeUser(-6*rms,6*rms);
TH1F* h2norm = (TH1F*)h2->DrawNormalized("hist");
gPad->Update();
cms.Draw();
prelim.Draw();
data.Draw();
lumi.Draw();
mean.Draw();
stdev.Draw();
TPaveText *title = (TPaveText*)gPad->GetPrimitive("title");
title->SetBorderSize(0);
title->SetFillColor(0);
title->SetFillStyle(0);
title->SetX1NDC(0.13);
title->SetY1NDC(0.88);
title->SetX2NDC(0.9);
title->SetY2NDC(0.98);
title->SetTextFont(42);
title->SetTextSize(0.052);
title->SetTextAlign(11);
c1.Print("plots/muon_time_all.pdf");
c1.Print("plots/muon_time_all.png");
c1.Print("plots/muon_time_all.root");
}
void compareThreeVersions(TimeInfoAllSteps TIAS_1,TimeInfoAllSteps TIAS_2,TimeInfoAllSteps TIAS_3,TString file_postfix) {
gStyle->SetOptStat(0);
TPaveText* labelcms = new TPaveText(0.20,0.79,0.54,0.92,"NDCBR");
labelcms->SetTextAlign(12);
labelcms->SetTextSize(0.04);
labelcms->SetFillColor(kWhite);
labelcms->AddText("CMS Preliminary Simulation");
//labelcms->AddText("CMS Preliminary");
//labelcms->AddText("Simulation");
labelcms->AddText("#sqrt{s} = 8 TeV, t#bar{t}+PU");
labelcms->SetBorderSize(0);
labelcms->SetTextFont(42);
labelcms->SetLineWidth(2);
TH1F *htime_iter_1 = new TH1F("time_iter_1"+file_postfix,"time_iter_1",8,0,8);
timingTestPerIter(TIAS_1,htime_iter_1);
htime_iter_1->SetLineStyle(TIAS_1.style());
htime_iter_1->SetLineColor(TIAS_1.color());
TH1F *htime_iter_2 = new TH1F("time_iter_2"+file_postfix,"time_iter_2",8,0,8);
timingTestPerIter(TIAS_2,htime_iter_2);
htime_iter_2->SetLineStyle(TIAS_2.style());
htime_iter_2->SetLineColor(TIAS_2.color());
TH1F *htime_iter_3 = new TH1F("time_iter_3"+file_postfix,"time_iter_3",8,0,8);
timingTestPerIter(TIAS_3,htime_iter_3);
htime_iter_3->SetLineStyle(TIAS_3.style());
htime_iter_3->SetLineColor(TIAS_3.color());
float iter_Iter0PU20 = htime_iter_1->GetBinContent(1);
htime_iter_1->Scale(1./iter_Iter0PU20);
htime_iter_2->Scale(1./iter_Iter0PU20);
htime_iter_3->Scale(1./iter_Iter0PU20);
htime_iter_1->GetYaxis()->SetRangeUser(0,1.1*TMath::Max(htime_iter_1->GetBinContent(htime_iter_1->GetMaximumBin()),TMath::Max(htime_iter_2->GetBinContent(htime_iter_2->GetMaximumBin()),htime_iter_3->GetBinContent(htime_iter_3->GetMaximumBin()))));
TLegend* leg = new TLegend(0.2,0.59,0.45,0.79);
leg->SetNColumns(1);
leg->SetFillColor(kWhite);
leg->SetLineColor(kWhite);
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetTextFont(42);
leg->AddEntry(htime_iter_1,TIAS_1.legend(),"L");
leg->AddEntry(htime_iter_2,TIAS_2.legend(),"L");
leg->AddEntry(htime_iter_3,TIAS_3.legend(),"L");
htime_iter_1->GetYaxis()->SetTitleOffset(1.2);
htime_iter_1->GetXaxis()->SetRangeUser(0,7);
htime_iter_1->GetYaxis()->SetTitle("time [1/iter0@<PU>=20]");
htime_iter_1->GetYaxis()->SetTitleSize(0.04);
htime_iter_1->GetXaxis()->SetTitleSize(0.04);
htime_iter_1->GetYaxis()->SetLabelSize(0.04);
TCanvas c0;
c0.SetTicks(1,1);
htime_iter_1->Draw("H");
htime_iter_2->Draw("H,same");
htime_iter_3->Draw("H,same");
leg->Draw();
labelcms->Draw();
c0.SetGridy();
c0.SaveAs("timingNew_iter_"+file_postfix+".png");
TH1F *htime_step_1 = new TH1F("time_step_1"+file_postfix,"time_step_1",5,0,5);
timingTestPerStep(TIAS_1,htime_step_1);
htime_step_1->SetLineStyle(TIAS_1.style());
htime_step_1->SetLineColor(TIAS_1.color());
htime_step_1->GetYaxis()->SetTitle("time [1/building@<PU>=20]");
TH1F *htime_step_2 = new TH1F("time_step_2"+file_postfix,"time_step_2",5,0,5);
timingTestPerStep(TIAS_2,htime_step_2);
htime_step_2->SetLineStyle(TIAS_2.style());
htime_step_2->SetLineColor(TIAS_2.color());
TH1F *htime_step_3 = new TH1F("time_step_3"+file_postfix,"time_step_3",5,0,5);
timingTestPerStep(TIAS_3,htime_step_3);
htime_step_3->SetLineStyle(TIAS_3.style());
htime_step_3->SetLineColor(TIAS_3.color());
float step_BuildPU20 = htime_step_1->GetBinContent(3);
htime_step_1->Scale(1./step_BuildPU20);
htime_step_2->Scale(1./step_BuildPU20);
htime_step_3->Scale(1./step_BuildPU20);
htime_step_1->GetYaxis()->SetTitleOffset(1.2);
htime_step_1->GetXaxis()->SetRangeUser(0,7);
htime_step_1->GetYaxis()->SetTitleSize(0.04);
htime_step_1->GetXaxis()->SetTitleSize(0.04);
htime_step_1->GetYaxis()->SetLabelSize(0.04);
TCanvas c1;
c1.SetTicks(1,1);
//htime_step_1->Scale(1./htime_step_1->Integral());
//htime_step_2->Scale(1./htime_step_2->Integral());
//htime_step_3->Scale(1./htime_step_3->Integral());
htime_step_1->GetYaxis()->SetRangeUser(0,1.1*TMath::Max(htime_step_1->GetBinContent(htime_step_1->GetMaximumBin()),TMath::Max(htime_step_2->GetBinContent(htime_step_2->GetMaximumBin()),htime_step_3->GetBinContent(htime_step_3->GetMaximumBin()))));
htime_step_1->GetXaxis()->SetRangeUser(1,5);
htime_step_1->Draw("H");
htime_step_2->Draw("H,same");
htime_step_3->Draw("H,same");
leg->SetX1NDC(0.60);
leg->SetX2NDC(0.85);
labelcms->SetX1NDC(0.60);
labelcms->SetX2NDC(0.94);
leg->Draw();
labelcms->Draw();
c1.SetGridy();
c1.SaveAs("timingNew_step_"+file_postfix+".png");
TH1F *htime_track_1 = (TH1F*) htime_iter_1->Clone("time_track_1"+file_postfix);
htime_track_1->Reset();
makeTimePerTrackPlot(htime_track_1,htime_iter_1,TIAS_1.mtvfile());
TH1F *htime_track_2 = (TH1F*) htime_iter_2->Clone("time_track_2"+file_postfix);
htime_track_2->Reset();
makeTimePerTrackPlot(htime_track_2,htime_iter_2,TIAS_2.mtvfile());
TH1F *htime_track_3 = (TH1F*) htime_iter_3->Clone("time_track_3"+file_postfix);
htime_track_3->Reset();
makeTimePerTrackPlot(htime_track_3,htime_iter_3,TIAS_3.mtvfile());
float track_Iter0PU20 = htime_track_1->GetBinContent(1);
htime_track_1->Scale(1./track_Iter0PU20);
htime_track_2->Scale(1./track_Iter0PU20);
htime_track_3->Scale(1./track_Iter0PU20);
htime_track_1->GetYaxis()->SetRangeUser(0,1.1*TMath::Max(htime_track_1->GetBinContent(htime_track_1->GetMaximumBin()),TMath::Max(htime_track_2->GetBinContent(htime_track_2->GetMaximumBin()),htime_track_3->GetBinContent(htime_track_3->GetMaximumBin()))));
TCanvas c2;
c2.SetTicks(1,1);
htime_track_1->GetYaxis()->SetTitleOffset(1.2);
htime_track_1->GetXaxis()->SetRangeUser(0,7);
htime_track_1->GetYaxis()->SetTitle("time/track [1/iter0@<PU>=20]");
htime_track_1->GetYaxis()->SetTitleSize(0.04);
htime_track_1->GetXaxis()->SetTitleSize(0.04);
htime_track_1->GetYaxis()->SetLabelSize(0.04);
htime_track_1->Draw("H");
htime_track_2->Draw("H,same");
htime_track_3->Draw("H,same");
leg->SetX1NDC(0.2);
leg->SetX2NDC(0.45);
labelcms->SetX1NDC(0.2);
labelcms->SetX2NDC(0.54);
leg->Draw();
labelcms->Draw();
c2.SetGridy();
c2.SaveAs("timingNew_track_"+file_postfix+".png");
}
void AnalyzeWaveforms(char *WaveformsFile = "Waveforms.root", const int nAddedChannels = 5) {
//try to access waveforms file and in case of failure return
if(gSystem->AccessPathName(WaveformsFile,kFileExists)) {
cout << "Error: file " << WaveformsFile << " does not exsist. Run .x WaveformsFileMaker.C to create it" << endl;
return;
}
// gStyle->SetOptFit(111);
// gStyle->SetStatFormat("1.3E");
// gStyle->SetFitFormat("1.3E");
// fetch the list of trees contained in the waveforms file
// for every tree generate a waveform graph
TFile *f = TFile::Open(WaveformsFile);
TList *listOfKeys = f->GetListOfKeys();
Int_t numberOfKeys = listOfKeys->GetEntries();
TList *listOfGraphs = new TList();
// if the waveform file name begins with the string "comparator" it goes in this list
TList *listOfCompWaves = new TList();
// if the waveform file name begins with the string "sum output" it goes in this list
TList *listOfAdderWaves = new TList();
for(Int_t i = 0; i < numberOfKeys; i++) {
TString *keyName = new TString(listOfKeys->At(i)->GetName());
TTree *tree = (TTree*)f->Get(keyName->Data());
Float_t x = 0;
Float_t y = 0;
tree->SetBranchAddress("x",&x);
tree->SetBranchAddress("y",&y);
Int_t nentries = tree->GetEntries();
TString *gName = new TString(keyName->Data());
gName->Append(" graph");
TGraphErrors *gWave = new TGraphErrors(nentries);
gWave->SetName(gName->Data());
gWave->SetTitle(gName->Data());
gWave->GetXaxis()->SetTitle("Time");
gWave->GetYaxis()->SetTitle("Voltage");
// gWave->SetBit(TH1::kCanRebin);
for (Int_t j = 0; j < nentries; j++) {
tree->GetEntry(j);
gWave->SetPoint(j,x,y);
}
listOfGraphs->Add(gWave);
if(keyName->BeginsWith("comparator"))
listOfCompWaves->Add(gWave);
if(keyName->BeginsWith("sum output"))
listOfAdderWaves->Add(gWave);
/* TString *cName = new TString(keyName->Data());
cName->Append(" canvas");
TCanvas *cy = new TCanvas(cName->Data(),cName->Data(),800,600);
gWave->Draw("AL"); */
}
cout << listOfAdderWaves->GetEntries() << endl;
// analysis for waves with no delay
// global variables
Double_t xMin,xMax,yStart,yEnd;
Int_t graphPoints;
Double_t step;
// comparator outputs waves sum
TGraphErrors *gFirstCompWave = (TGraphErrors *)listOfCompWaves->First();
graphPoints = gFirstCompWave->GetN();
gFirstCompWave->GetPoint(0,xMin,yStart);
gFirstCompWave->GetPoint(graphPoints - 1,xMax,yEnd);
step = (xMax - xMin)/graphPoints;
cout << gFirstCompWave->GetName() << endl;
cout << "xMin = " << xMin << " xMax = " << xMax << " graphPoints = " << graphPoints << endl;
TGraphErrors *gCompSum = new TGraphErrors(graphPoints);
gCompSum->SetLineColor(kBlue);
gCompSum->SetLineWidth(2);
gCompSum->SetName("Comparator Outputs Sum");
gCompSum->SetTitle("Comparator Outputs Sum");
Int_t nCompWaves = listOfCompWaves->GetEntries();
Float_t gx,gy = 0;
// Alpha coefficiens are now written "hard coded" here
Float_t alphaArray[3] = {0.199,0.201,0.197};
// Deleays coming from the multiplexer are written "hard coded" here
Float_t muxDelayArray[3] = {0,77.14E-12,192.01E-12};
for(Int_t i = 0; i < graphPoints; i++) {
for(Int_t j = 0; j < nCompWaves; j++) {
TGraphErrors *gCompWave = (TGraphErrors *)listOfCompWaves->At(j);
gy += (gCompWave->Eval(xMin + i*step + muxDelayArray[j]))*alphaArray[j];
}
gCompSum->SetPoint(i,xMin + i*step,gy);
gy = 0;
}
// note that there is a manual correction on the x axis for the comparator waves sum to compare them better in the multigraph
Double_t *xArray = gCompSum->GetX();
for(Int_t i = 0; i < graphPoints; i++) {
xArray[i] += 5.6E-9;
}
// TCanvas *cCompSum = new TCanvas("cCompSum","Comparator Outputs Sum",800,600);
// gCompSum->Draw("AL");
// adder outputs waves sum
// THE ANALYSIS FOR THE ADDER OUTPUT WITH NOT DELAY AND 3 CHANNELS ADDED IS DEPRECATED.
// THERE WAS A MISTAKE IN THE DATA TAKING
// I'LL KEEP THE CODE HERE FOR FURTHER REFERENCE
/*
TGraphErrors *gFirstAdderWave = (TGraphErrors *)listOfAdderWaves->First();
graphPoints = gFirstAdderWave->GetN();
gFirstAdderWave->GetPoint(0,xMin,yStart);
gFirstAdderWave->GetPoint(graphPoints - 1,xMax,yEnd);
step = (xMax - xMin)/graphPoints;
cout << gFirstAdderWave->GetName() << endl;
cout << "xMin : " << xMin << " xMax : " << xMax << endl;
TGraphErrors *gAdderSum = new TGraphErrors(graphPoints);
gAdderSum->SetLineWidth(2);
// gAdderSum->SetLineColor(kGreen);
gAdderSum->SetLineStyle(9);
gAdderSum->SetName("Sum of the adder outputs with no delay");
gAdderSum->SetTitle("Sum of the adder outputs with no delay");
Int_t nAdderWaves = listOfAdderWaves->GetEntries();
gy = 0;
for(Int_t i = 0; i < graphPoints; i++) {
for(Int_t j = 0; j < nAdderWaves; j++) {
TGraphErrors *gAdderWave = (TGraphErrors *)listOfAdderWaves->At(j);
gy += gAdderWave->Eval(xMin + i*step);
}
gAdderSum->SetPoint(i,xMin + i*step,gy);
gy = 0;
}
// TCanvas *cAdderSum = new TCanvas("cAdderSum","Sum of the adder outputs",800,600);
// gAdderSum->Draw("AL");
TGraphErrors *g3ChannelsSumNoDelay = listOfGraphs->FindObject("sum_output_3_channels_(3) graph");
g3ChannelsSumNoDelay->SetLineColor(kRed);
g3ChannelsSumNoDelay->SetLineWidth(2);
// note that there is a manual correction on the x axis for the adder output to compare it better in the multigraph
Double_t *xArray = g3ChannelsSumNoDelay->GetX();
graphPoints = g3ChannelsSumNoDelay->GetN();
for(Int_t i = 0; i < graphPoints; i++) {
xArray[i] -= 600E-12;
}
// comparison among the computed adder output ,the real one and the sum of the comparator outputs with alpha coefficients correction
TMultiGraph *mgSumNoDelay = new TMultiGraph();
mgSumNoDelay->Add(g3ChannelsSumNoDelay);
mgSumNoDelay->Add(gAdderSum);
mgSumNoDelay->Add(gCompSum);
mgSumNoDelay->SetTitle("Collection of graphs for 3 channels sum with no delay");
TCanvas *cmgSumNoDelay = new TCanvas("cmgSumNoDelay", "Collection of graphs for 3 channels sum with no delay", 1200,800);
cmgSumNoDelay->Update();
mgSumNoDelay->Draw("AL");
legend = new TLegend(0.6,0.78,0.99,0.99);
legend->AddEntry(g3ChannelsSumNoDelay, "Actual sum done by the adder", "lp");
legend->AddEntry(gAdderSum, "Sum of the adder outputs", "lp");
legend->AddEntry(gCompSum, "Sum of the comparator outputs","lp");
legend->Draw();
mgSumNoDelay->GetXaxis()->SetTitle("Seconds");
mgSumNoDelay->GetYaxis()->SetTitle("Volts");
TPaveText *title = (TPaveText*)cmgSumNoDelay->GetPrimitive("title");
title->SetX1NDC(0.009);
title->SetY1NDC(0.94);
title->SetX2NDC(0.56);
title->SetY2NDC(0.99);
cmgSumNoDelay->Modified();
*/
// analysis for delayed adder outputs
Int_t nAdderWaves = listOfAdderWaves->GetEntries();
TGraphErrors *g3ChannelsSumDelay = listOfGraphs->FindObject("sum_output_3_channels_(1-1-1) graph");
g3ChannelsSumDelay->SetLineColor(kRed);
g3ChannelsSumDelay->SetLineWidth(2);
// Delay coming from cables are written "hard coded" here
Float_t cablesDelayArray[3] = {0,1.45E-9,3.21E-9};
graphPoints = g3ChannelsSumDelay->GetN();
//g3ChannelsSumDelay->GetPoint(0,xMin,yStart);
//g3ChannelsSumDelay->GetPoint(graphPoints - 1,xMax,yEnd);
xMin = 6E-9;
xMax = 16E-9;
step = (xMax - xMin)/graphPoints;
cout << "Sum of the adder outputs with delay" << endl;
cout << "xMin : " << xMin << " xMax : " << xMax << endl;
TGraphErrors *gAdderSumDelay = new TGraphErrors(graphPoints);
gAdderSumDelay->SetLineColor(kBlue);
gAdderSumDelay->SetLineWidth(2);
gAdderSumDelay->SetName("Sum of the adder outputs with delay");
gAdderSumDelay->SetTitle("Sum of the adder outputs with delay");
gy = 0;
// note that there is a manual correction on the delay of 500E-12 to compare the adder output better in the multigraph
for(Int_t i = 0; i < graphPoints; i++) {
for(Int_t j = 0; j < nAdderWaves; j++) {
TGraphErrors *gAdderWave = (TGraphErrors *)listOfAdderWaves->At(j);
gy += gAdderWave->Eval(xMin + i*step + cablesDelayArray[j] - 500E-12);
}
gAdderSumDelay->SetPoint(i,xMin + i*step,gy);
gy = 0;
}
// TCanvas *cSumSumDelay = new TCanvas("cSumSumDelay","Sum of the sum outputs with delay",800,600);
// gAdderSumDelay->Draw("APEL");
TMultiGraph *mg3ChannelsSumDelay = new TMultiGraph();
mg3ChannelsSumDelay->Add(gAdderSumDelay);
mg3ChannelsSumDelay->Add(g3ChannelsSumDelay);
mg3ChannelsSumDelay->SetTitle("Collection of graphs for 3 channels sum with delay");
TCanvas *cmg3ChannelsSumDelay = new TCanvas("cmg3ChannelsSumDelay", "Collection of graphs for 3 channels sum with delay", 1200, 800);
cmg3ChannelsSumDelay->Update();
legend = new TLegend(0.6,0.78,0.99,0.99);
legend->AddEntry(g3ChannelsSumDelay, "Actual sum done by the adder", "lp");
legend->AddEntry(gAdderSumDelay, "Sum of the delayed adder outputs", "lp");
mg3ChannelsSumDelay->Draw("AL");
legend->Draw();
mg3ChannelsSumDelay->GetXaxis()->SetTitle("Seconds");
mg3ChannelsSumDelay->GetYaxis()->SetTitle("Volts");
TPaveText *title = (TPaveText*)cmg3ChannelsSumDelay->GetPrimitive("title");
title->SetX1NDC(0.009);
title->SetY1NDC(0.94);
title->SetX2NDC(0.56);
title->SetY2NDC(0.99);
cmg3ChannelsSumDelay->Modified();
/*
// delay test just to try a different method
TMultiGraph *mgDelayTest = new TMultiGraph();
Double_t gxTest,gyTest;
TGraphErrors *gDelayTest0 = new TGraphErrors(((TGraphErrors *)listOfAdderWaves->At(0))->GetN());
for(Int_t j = 0; j < gDelayTest0->GetN(); j++) {
((TGraphErrors *)listOfAdderWaves->At(0))->GetPoint(j,gxTest,gyTest);
gDelayTest0->SetPoint(j,gxTest - cablesDelayArray[0],gyTest);
}
mgDelayTest->Add(gDelayTest0);
TGraphErrors *gDelayTest1 = new TGraphErrors(((TGraphErrors *)listOfAdderWaves->At(1))->GetN());
for(Int_t j = 0; j < gDelayTest1->GetN(); j++) {
((TGraphErrors *)listOfAdderWaves->At(1))->GetPoint(j,gxTest,gyTest);
gDelayTest1->SetPoint(j,gxTest - cablesDelayArray[1],gyTest);
}
mgDelayTest->Add(gDelayTest1);
TGraphErrors *gDelayTest2 = new TGraphErrors(((TGraphErrors *)listOfAdderWaves->At(2))->GetN());
for(Int_t j = 0; j < gDelayTest2->GetN(); j++) {
((TGraphErrors *)listOfAdderWaves->At(2))->GetPoint(j,gxTest,gyTest);
gDelayTest2->SetPoint(j,gxTest - cablesDelayArray[2],gyTest);
}
mgDelayTest->Add(gDelayTest2);
// TCanvas *cmgDelayTest = new TCanvas("cmgDelayTest", "cmgDelayTest", 800,600);
// mgDelayTest->Draw("APEL");
graphPoints = 12000;
xMin = 2E-9;
xMax = 22E-9;
step = (xMax - xMin)/graphPoints;
cout << "xMin : " << xMin << " xMax : " << xMax << endl;
Double_t delayTest0xMin,delayTest0xMax,delayTest1xMin,delayTest1xMax,delayTest2xMin,delayTest2xMax;
gDelayTest0->GetPoint(0,delayTest0xMin,gyTest);
gDelayTest0->GetPoint(gDelayTest0->GetN() - 1,delayTest0xMax,gyTest);
gDelayTest1->GetPoint(0,delayTest1xMin,gyTest);
gDelayTest1->GetPoint(gDelayTest1->GetN() - 1,delayTest1xMax,gyTest);
gDelayTest2->GetPoint(0,delayTest2xMin,gyTest);
gDelayTest2->GetPoint(gDelayTest2->GetN() - 1,delayTest2xMax,gyTest);
cout << delayTest0xMin << endl;
TGraphErrors *gAdderSumDelayV2 = new TGraphErrors(graphPoints);
for(Int_t i = 0; i < graphPoints; i++) {
gyTest = gDelayTest0->Eval(xMin + i*step);
gyTest += gDelayTest1->Eval(xMin + i*step);
gyTest += gDelayTest2->Eval(xMin + i*step);
gAdderSumDelayV2->SetPoint(i,xMin + i*step+ 500E-12,gyTest);
}
gAdderSumDelayV2->SetLineColor(kGreen);
gAdderSumDelayV2->SetLineWidth(2);
mg3ChannelsSumDelay->Add(gAdderSumDelayV2);
c3ChannelsSumDelay->Modified();
TCanvas *cAdderSumDelayV2 = new TCanvas("cAdderSumDelayV2","cAdderSumDelayV2",800,600);
gAdderSumDelayV2->Draw("APL");
*/
// List of waves representing the adder output with 5,4,3,2,1 channels in input
TGraphErrors *gAdder5Channels = listOfGraphs->FindObject("adder output 5 channels v2 graph");
TGraphErrors *gAdder4Channels = listOfGraphs->FindObject("adder output 4 channels v2 graph");
TGraphErrors *gAdder3Channels = listOfGraphs->FindObject("adder output 3 channels v2 graph");
TGraphErrors *gAdder2Channels = listOfGraphs->FindObject("adder output 2 channels v2 graph");
TGraphErrors *gAdder1Channel = listOfGraphs->FindObject("adder output 1 channel v2 graph");
TGraphErrors *gAdderSingleCh0 = listOfGraphs->FindObject("single sum output ch 0 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh1 = listOfGraphs->FindObject("single sum output ch 1 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh4 = listOfGraphs->FindObject("single sum output ch 4 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh5 = listOfGraphs->FindObject("single sum output ch 5 input 500 mV DT 100 mV graph");
TGraphErrors *gAdderSingleCh7 = listOfGraphs->FindObject("single sum output ch 7 input 500 mV DT 100 mV graph");
TMultiGraph *mgAdder54321Channels = new TMultiGraph();
mgAdder54321Channels->SetTitle("Collection of graphs for different numbers of added channels");
mgAdder54321Channels->Add(gAdder5Channels);
mgAdder54321Channels->Add(gAdder4Channels);
mgAdder54321Channels->Add(gAdder3Channels);
mgAdder54321Channels->Add(gAdder2Channels);
mgAdder54321Channels->Add(gAdder1Channel);
TCanvas *cmgAdder54321Channels = new TCanvas("cmgAdder54321Channels", "Collection of graphs for different numbers of added channels",1200,800);
mgAdder54321Channels->Draw("AL");
cmgAdder54321Channels->Update();
mgAdder54321Channels->GetXaxis()->SetTitle("seconds");
mgAdder54321Channels->GetYaxis()->SetTitle("Volts");
cmgAdder54321Channels->Modified();
// analysis of the linearity of the adder
Double_t addedVMax[nAddedChannels];
addedVMax[0] = TMath::MaxElement(gAdder1Channel->GetN(), gAdder1Channel->GetY());
addedVMax[1] = TMath::MaxElement(gAdder2Channels->GetN(), gAdder2Channels->GetY());
addedVMax[2] = TMath::MaxElement(gAdder3Channels->GetN(), gAdder3Channels->GetY());
addedVMax[3] = TMath::MaxElement(gAdder4Channels->GetN(), gAdder4Channels->GetY());
addedVMax[4] = TMath::MaxElement(gAdder5Channels->GetN(), gAdder5Channels->GetY());
Double_t singleVMax[nAddedChannels];
singleVMax[0] = TMath::MaxElement(gAdderSingleCh0->GetN(), gAdderSingleCh0->GetY());
singleVMax[1] = TMath::MaxElement(gAdderSingleCh1->GetN(), gAdderSingleCh1->GetY());
singleVMax[2] = TMath::MaxElement(gAdderSingleCh4->GetN(), gAdderSingleCh4->GetY());
singleVMax[3] = TMath::MaxElement(gAdderSingleCh5->GetN(), gAdderSingleCh5->GetY());
singleVMax[4] = TMath::MaxElement(gAdderSingleCh7->GetN(), gAdderSingleCh7->GetY());
vector<double> expectedVMax(nAddedChannels);
Double_t previousVmax = 0;
for(Int_t i = 0; i < expectedVMax.size(); i++) {
expectedVMax[i] = singleVMax[i] + previousVmax;
previousVmax = expectedVMax[i];
cout << "singleVMax[" <<i <<"] = " << singleVMax[i] << endl;
cout << "addedVMax[" <<i <<"] = " << addedVMax[i] << endl;
cout << "expectedVMax[" <<i <<"] = " << expectedVMax[i] << endl;
}
TGraph *gAdderLinearity = new TGraph(expectedVMax.size(),&expectedVMax[0],addedVMax);
gAdderLinearity->SetTitle("Linearity of the adder");
gAdderLinearity->GetXaxis()->SetTitle("Expected amplitude value (V)");
gAdderLinearity->GetYaxis()->SetTitle("Actual amplitude value (V)");
gAdderLinearity->GetYaxis()->SetTitleOffset(1.3);
TCanvas *cgAdderLinearity = new TCanvas("cgAdderLinearity","Linearity of the adder",800,600);
cgAdderLinearity->SetGrid();
cgAdderLinearity->Update();
gAdderLinearity->SetMarkerStyle(20);
gAdderLinearity->SetMarkerSize(0.8);
//gAdderLinearity->Fit("pol1","Q+","",expectedVMax[0],expectedVMax[2]);
TF1 *line = new TF1("line","x",expectedVMax.back(),expectedVMax.front());
gAdderLinearity->Draw("APEL");
line->Draw("SAME");
//gAdderLinearity->GetFunction("pol1")->SetRange(expectedVMax.back(),expectedVMax.front());;
cgAdderLinearity->SetLeftMargin(0.13);
cgAdderLinearity->Modified();
f->Close();
}
/*
root -l 'sigmapeak.C+(0.025)'
//
Processing sigmapeak.C+(0.025)...
background only: bkg_nsigma_0_99 = -0.352803
sig_nsigma_0_59 = -0.608621
sig_nsigma_0_99 = 2.1472
sig_nsigma_60_99 = 4.14042
sig_nsigma_70_90 = 5.57689
sig_nsigma_75_85 = 8.056
*/
void sigmapeak(Double_t signal_area=0.025)
{
Double_t bkg_mean = 0;
Double_t bkg_sigma = 0.001;
Double_t x[100];
Double_t y[100];
Int_t np = 100;
TRandom3 rand;
for (int i=0; i<np; ++i) {
x[i] = i;
y[i] = rand.Gaus(bkg_mean,bkg_sigma);
}
TGraph* gr = new TGraph(np,x,y);
gr->SetNameTitle("gr",Form("#sigma = %0.1f",bkg_sigma));
gr->SetMarkerStyle(7);
gr->SetMarkerColor(46);
new TCanvas();
gr->Draw("ap");
Double_t bkg_nsigma_0_99 = Nsigma(gr->GetY(), 0,99, bkg_sigma);
cout<< "background only: bkg_nsigma_0_99 = " << bkg_nsigma_0_99 <<endl;
// add signal
Double_t signal_mean = 80;
Double_t signal_sigma = 3;
for (int i=0; i<gr->GetN(); ++i) {
Double_t xx = (gr->GetX()[i] - signal_mean)/signal_sigma;
Double_t arg = 0.5*xx*xx;
Double_t exp = arg < 50? TMath::Exp(-arg): 0;
Double_t signal = signal_area/(TMath::Sqrt(TMath::TwoPi())*signal_sigma) * exp;
gr->SetPoint(i, gr->GetX()[i], gr->GetY()[i] + signal);
}
gr->SetTitle(Form("#sigma_{bkg} = %0.3f signal: area = %0.3f mean = %0.0f sigma = %0.1f", bkg_sigma,signal_area,signal_mean,signal_sigma));
gr->Draw("apl");
gr->Fit("gaus", "R", "", signal_mean - 5*signal_sigma, signal_mean+5*signal_sigma);
Double_t fit_area = 2.5 * gr->GetFunction("gaus")->GetParameter("Constant") * gr->GetFunction("gaus")->GetParameter("Sigma");
cout<< "Area under fitted gaussian = " << fit_area <<endl;
// titmax();
gPad->Modified(); // to create box (NB: the pad was not drawn yet at this point!)
gPad->Update();
TPaveText* tit = (TPaveText*)gPad->GetPrimitive("title");
tit->SetX1NDC(0.);
tit->SetX2NDC(1.);
tit->SetY1NDC(0.9);
tit->SetY2NDC(1.);
gPad->Modified(); // to update the pad
gPad->Update();
Double_t sig_nsigma_0_59 = Nsigma(gr->GetY(), 0,59, bkg_sigma);
cout<< "sig_nsigma_0_59 = " << sig_nsigma_0_59 <<endl;
Double_t sig_nsigma_0_99 = Nsigma(gr->GetY(), 0,99, bkg_sigma);
cout<< "sig_nsigma_0_99 = " << sig_nsigma_0_99 <<endl;
Double_t sig_nsigma_60_99 = Nsigma(gr->GetY(), 60,99, bkg_sigma);
cout<< "sig_nsigma_60_99 = " << sig_nsigma_60_99 <<endl;
Double_t sig_nsigma_70_90 = Nsigma(gr->GetY(), 70,90, bkg_sigma);
cout<< "sig_nsigma_70_90 = " << sig_nsigma_70_90 <<endl;
Double_t sig_nsigma_75_85 = Nsigma(gr->GetY(), 75,85, bkg_sigma);
cout<< "sig_nsigma_75_85 = " << sig_nsigma_75_85 <<endl;
Double_t ys5[100];
smooth5(np, gr->GetY(), ys5);
TGraph* gr5 = new TGraph(np, x, ys5);
gr5->SetNameTitle("gr5","smoothed on 5 points");
gr5->SetMarkerStyle(7);
gr5->SetMarkerColor(2);
gr5->SetLineColor(2);
new TCanvas;
gr5->Draw("apl");
Double_t ys7[100];
smooth7(np, gr->GetY(), ys7);
TGraph* gr7 = new TGraph(np, x, ys7);
gr7->SetNameTitle("gr7","smoothed on 7 points");
gr7->SetMarkerStyle(7);
gr7->SetMarkerColor(8);
gr7->SetLineColor(8);
new TCanvas;
gr7->Draw("apl");
Double_t ys7a[100];
smooth7a(np, gr->GetY(), ys7a);
TGraph* gr7a = new TGraph(np, x, ys7a);
gr7a->SetNameTitle("gr7a","smoothed on 7a points");
gr7a->SetMarkerStyle(7);
gr7a->SetMarkerColor(3);
gr7a->SetLineColor(3);
new TCanvas;
gr7a->Draw("apl");
Double_t ys5g[100];
smooth5g(np, gr->GetY(), ys5g);
TGraph* gr5g = new TGraph(np, x, ys5g);
gr5g->SetNameTitle("gr5g","smoothed on 5g points");
gr5g->SetMarkerStyle(7);
gr5g->SetMarkerColor(4);
gr5g->SetLineColor(4);
new TCanvas;
gr5g->Draw("apl");
Double_t ys5a[100];
smooth5a(np, gr->GetY(), ys5a);
TGraph* gr5a = new TGraph(np, x, ys5a);
gr5a->SetNameTitle("gr5a","smoothed on 5a points");
gr5a->SetMarkerStyle(7);
gr5a->SetMarkerColor(6);
gr5a->SetLineColor(6);
new TCanvas;
gr5a->Draw("apl");
}
void Draw_Time_Hists(TTree* t) {
// Draw processing time, CPU time, and latency per packet
// distributions from the input tree
if (!t) {
cout << "Invalid input tree" << endl;
return;
}
gROOT->SetStyle("Plain");
gStyle->SetOptStat(0);
gStyle->SetNdivisions(505);
gStyle->SetTitleFontSize(0.1);
if(!TString(gSystem->GetLibraries()).Contains("Proof"))
gSystem->Load("libProof.so");
TCanvas* canvas = new TCanvas("ProfHists","Profile Histograms",800,600);
canvas->Divide(3,1);
canvas->cd(1);
gPad->SetLogy();
t->Draw("fProcTime");
TH1* h = dynamic_cast<TH1*>(gROOT->FindObject("htemp"));
h->SetTitle("Processing Time per Packet");
h->GetXaxis()->SetTitle("Processing Time [s]");
gPad->Update();
TPaveText* titlepave = 0;
titlepave = dynamic_cast<TPaveText*>(gPad->GetListOfPrimitives()->FindObject("title"));
if (titlepave) {
Double_t x1ndc = titlepave->GetX1NDC();
Double_t x2ndc = titlepave->GetX2NDC();
titlepave->SetX1NDC((1.0-x2ndc+x1ndc)/2.);
titlepave->SetX2NDC((1.0+x2ndc-x1ndc)/2.);
titlepave->SetBorderSize(0);
gPad->Update();
}
gPad->Modified();
canvas->cd(2);
gPad->SetLogy();
t->Draw("fCpuTime");
h = dynamic_cast<TH1*>(gROOT->FindObject("htemp"));
h->SetTitle("CPU Time per Packet");
h->GetXaxis()->SetTitle("CPU Time [s]");
gPad->Update();
titlepave = dynamic_cast<TPaveText*>(gPad->GetListOfPrimitives()->FindObject("title"));
if (titlepave) {
Double_t x1ndc = titlepave->GetX1NDC();
Double_t x2ndc = titlepave->GetX2NDC();
titlepave->SetX1NDC((1.0-x2ndc+x1ndc)/2.);
titlepave->SetX2NDC((1.0+x2ndc-x1ndc)/2.);
titlepave->SetBorderSize(0);
gPad->Update();
}
gPad->Modified();
canvas->cd(3);
gPad->SetLogy();
t->Draw("fLatency");
h = dynamic_cast<TH1*>(gROOT->FindObject("htemp"));
h->SetTitle("Request Packet Latency");
h->GetXaxis()->SetTitle("Latency [s]");
gPad->Update();
titlepave = dynamic_cast<TPaveText*>(gPad->GetListOfPrimitives()->FindObject("title"));
if (titlepave) {
Double_t x1ndc = titlepave->GetX1NDC();
Double_t x2ndc = titlepave->GetX2NDC();
titlepave->SetX1NDC((1.0-x2ndc+x1ndc)/2.);
titlepave->SetX2NDC((1.0+x2ndc-x1ndc)/2.);
titlepave->SetBorderSize(0);
gPad->Update();
}
gPad->Modified();
}
