--- /dev/null
+#include "TChain.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TF1.h"
+#include "TH2F.h"
+#include "TCanvas.h"
+#include "TObjArray.h"
+#include "/home/alla/alice/AliRoot/AliRoot/STEER/STEERBase/TTreeStream.h"
+
+#define NPMTs 24
+
+int MakeTrendT0( char *infile, int run) {
+
+ char *outfile = "trending.root";
+
+ if(!infile) return -1;
+ if(!outfile) return -1;
+
+ TFile *f = TFile::Open(infile,"read");
+ if (!f) {
+ printf("File %s not available\n", infile);
+ return -1;
+ }
+
+ // LOAD HISTOGRAMS FROM QAresults.root
+ TObjArray *fTzeroObject = (TObjArray*) f->Get("T0_Performance/QAT0chists");
+
+ TH1F* fTzeroORAplusORC =(TH1F*) ((TH1F*) fTzeroObject->FindObject("fTzeroORAplusORC"))->Clone("A");
+ TH1F* fResolution =(TH1F*) ((TH1F*) fTzeroObject->FindObject("fResolution"))->Clone("B");
+ TH1F* fTzeroORA =(TH1F*) ((TH1F*) fTzeroObject->FindObject("fTzeroORA"))->Clone("C");
+ TH1F* fTzeroORC =(TH1F*) ((TH1F*) fTzeroObject->FindObject("fTzeroORC"))->Clone("D");
+
+ TH2F *fTimeVSAmplitude[NPMTs];//counting PMTs from 0
+ TH1D *fAmplitude[NPMTs];
+ TH1D *fTime[NPMTs];
+ //-----> add new histogram here
+
+
+
+ // sigma fit of resolution, mean T0A, T0C and T0C&A, mean amplitude for each PMT
+ double resolutionSigma = -9999; //dummy init
+ double tzeroOrAPlusOrC = -9999; //dummy init
+ double tzeroOrA = -9999; //dummy init
+ double tzeroOrC = -9999; //dummy init
+ double meanAmplitude[NPMTs]; //dummy init
+ double meanTime[NPMTs]; //dummy init
+ double timeDelayOCDB[NPMTs]; //dummy init
+
+ //.................................................................................
+
+ for(int ipmt=1; ipmt<=NPMTs; ipmt++){ //loop over all PMTs
+ fTimeVSAmplitude[ipmt-1] =(TH2F*) ((TH2F*) fTzeroObject->FindObject(Form("fTimeVSAmplitude%d",ipmt)))->Clone(Form("E%d",ipmt));
+ int nbinsX = fTimeVSAmplitude[ipmt-1]->GetNbinsX();
+ int nbinsY = fTimeVSAmplitude[ipmt-1]->GetNbinsY();
+ //Amplitude
+ fAmplitude[ipmt-1] = (TH1D*) fTimeVSAmplitude[ipmt-1]->ProjectionX(Form("fAmplitude%d",ipmt), 1, nbinsY);
+ meanAmplitude[ipmt-1] = -9999; //dummy init
+ if(fAmplitude[ipmt-1]->GetEntries()>0){
+ meanAmplitude[ipmt-1] = fAmplitude[ipmt-1]->GetMean();
+ }
+
+ //Time
+ fTime[ipmt-1] = (TH1D*) fTimeVSAmplitude[ipmt-1]->ProjectionY(Form("fTime%d",ipmt), 1, nbinsX);
+ meanTime[ipmt-1] = -9999; //dummy init
+ if(fTime[ipmt-1]->GetEntries()>0){
+ if(fTime[ipmt-1]->GetEntries()>20){
+ meanTime[ipmt-1] = GetParameterGaus((TH1F*) fTime[ipmt-1], 1); // Mean Time
+ }else if(fTime[ipmt-1]->GetEntries()>0){
+ meanTime[ipmt-1] = fTime[ipmt-1]->GetMean();
+ }
+ }
+ }
+
+
+
+ if(fResolution->GetEntries()>20){
+ resolutionSigma = GetParameterGaus(fResolution, 2); //gaussian sigma
+ }else if(fResolution->GetEntries()>0){
+ resolutionSigma = fResolution->GetRMS(); //gaussian sigma
+ }
+
+ if(fTzeroORAplusORC->GetEntries()>20){
+ tzeroOrAPlusOrC = GetParameterGaus(fTzeroORAplusORC, 1); //gaussian mean
+ }else if(fTzeroORAplusORC->GetEntries()>0){
+ tzeroOrAPlusOrC = fTzeroORAplusORC->GetMean();
+ }
+
+ if(fTzeroORA->GetEntries()>20){
+ tzeroOrA = GetParameterGaus(fTzeroORA, 1); //gaussian mean
+ }else if(fTzeroORA->GetEntries()>0){
+ tzeroOrA = fTzeroORA->GetMean();
+ }
+
+ if(fTzeroORC->GetEntries()>20){
+ tzeroOrC = GetParameterGaus(fTzeroORC, 1); //gaussian mean
+ }else if(fTzeroORC->GetEntries()>0){
+ tzeroOrC = fTzeroORC->GetMean(); //gaussian mean
+ }
+
+ //-----> analyze the new histogram here and set mean/sigma
+
+
+ f->Close();
+
+ //-------------------- READ OCDB TIME DELAYS ---------------------------
+ // Arguments:
+ AliCDBManager* man = AliCDBManager::Instance();
+ man->SetDefaultStorage("raw://");
+ man->SetRun(run);
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("T0/Calib/TimeDelay");
+ AliT0CalibTimeEq *clb = (AliT0CalibTimeEq*)entry->GetObject();
+ for (Int_t i=0; i<NPMTs; i++){
+ timeDelayOCDB[i] = 0;
+ if(clb)
+ timeDelayOCDB[i] = clb->GetCFDvalue(i,0);
+ }
+
+
+
+ //--------------- write walues to the output ------------
+ TTreeSRedirector* pcstream = NULL;
+ pcstream = new TTreeSRedirector(outfile);
+ if (!pcstream) return;
+
+
+ TFile *x = pcstream->GetFile();
+ x->cd();
+
+ TObjString runType;
+ Int_t startTimeGRP=0;
+ Int_t stopTimeGRP=0;
+ Int_t time=0;
+ Int_t duration=0;
+
+ time = (startTimeGRP+stopTimeGRP)/2;
+ duration = (stopTimeGRP-startTimeGRP);
+
+ (*pcstream)<<"t0QA"<<
+ "run="<<run;//<<
+ //"time="<<time<<
+ // "startTimeGRP="<<startTimeGRP<<
+ // "stopTimeGRP="<<stopTimeGRP<<
+ /// "duration="<<duration<<
+ // "runType.="<<&runType;
+
+
+ (*pcstream)<<"t0QA"<<
+ "resolution="<< resolutionSigma<<
+ "tzeroOrAPlusOrC="<< tzeroOrAPlusOrC<<
+ "tzeroOrA="<< tzeroOrA<<
+ "tzeroOrC="<< tzeroOrC<<
+ "amplPMT1="<<meanAmplitude[0]<<
+ "amplPMT2="<<meanAmplitude[1]<<
+ "amplPMT3="<<meanAmplitude[2]<<
+ "amplPMT4="<<meanAmplitude[3]<<
+ "amplPMT5="<<meanAmplitude[4]<<
+ "amplPMT6="<<meanAmplitude[5]<<
+ "amplPMT7="<<meanAmplitude[6]<<
+ "amplPMT8="<<meanAmplitude[7]<<
+ "amplPMT9="<<meanAmplitude[8]<<
+ "amplPMT10="<<meanAmplitude[9]<<
+ "amplPMT11="<<meanAmplitude[10]<<
+ "amplPMT12="<<meanAmplitude[11]<<
+ "amplPMT13="<<meanAmplitude[12]<<
+ "amplPMT14="<<meanAmplitude[13]<<
+ "amplPMT15="<<meanAmplitude[14]<<
+ "amplPMT16="<<meanAmplitude[15]<<
+ "amplPMT17="<<meanAmplitude[16]<<
+ "amplPMT18="<<meanAmplitude[17]<<
+ "amplPMT19="<<meanAmplitude[18]<<
+ "amplPMT20="<<meanAmplitude[19]<<
+ "amplPMT21="<<meanAmplitude[20]<<
+ "amplPMT22="<<meanAmplitude[21]<<
+ "amplPMT23="<<meanAmplitude[22]<<
+ "amplPMT24="<<meanAmplitude[23]<<
+ "timePMT1="<<meanTime[0]<<
+ "timePMT2="<<meanTime[1]<<
+ "timePMT3="<<meanTime[2]<<
+ "timePMT4="<<meanTime[3]<<
+ "timePMT5="<<meanTime[4]<<
+ "timePMT6="<<meanTime[5]<<
+ "timePMT7="<<meanTime[6]<<
+ "timePMT8="<<meanTime[7]<<
+ "timePMT9="<<meanTime[8]<<
+ "timePMT10="<<meanTime[9]<<
+ "timePMT11="<<meanTime[10]<<
+ "timePMT12="<<meanTime[11]<<
+ "timePMT13="<<meanTime[12]<<
+ "timePMT14="<<meanTime[13]<<
+ "timePMT15="<<meanTime[14]<<
+ "timePMT16="<<meanTime[15]<<
+ "timePMT17="<<meanTime[16]<<
+ "timePMT18="<<meanTime[17]<<
+ "timePMT19="<<meanTime[18]<<
+ "timePMT20="<<meanTime[19]<<
+ "timePMT21="<<meanTime[20]<<
+ "timePMT22="<<meanTime[21]<<
+ "timePMT23="<<meanTime[22]<<
+ "timePMT24="<<meanTime[23];
+(*pcstream)<<"t0QA"<<
+ "timeDelayPMT1="<<timeDelayOCDB[0]<<
+ "timeDelayPMT2="<<timeDelayOCDB[1]<<
+ "timeDelayPMT3="<<timeDelayOCDB[2]<<
+ "timeDelayPMT4="<<timeDelayOCDB[3]<<
+ "timeDelayPMT5="<<timeDelayOCDB[4]<<
+ "timeDelayPMT6="<<timeDelayOCDB[5]<<
+ "timeDelayPMT7="<<timeDelayOCDB[6]<<
+ "timeDelayPMT8="<<timeDelayOCDB[7]<<
+ "timeDelayPMT9="<<timeDelayOCDB[8]<<
+ "timeDelayPMT10="<<timeDelayOCDB[9]<<
+ "timeDelayPMT11="<<timeDelayOCDB[10]<<
+ "timeDelayPMT12="<<timeDelayOCDB[11]<<
+ "timeDelayPMT13="<<timeDelayOCDB[12]<<
+ "timeDelayPMT14="<<timeDelayOCDB[13]<<
+ "timeDelayPMT15="<<timeDelayOCDB[14]<<
+ "timeDelayPMT16="<<timeDelayOCDB[15]<<
+ "timeDelayPMT17="<<timeDelayOCDB[16]<<
+ "timeDelayPMT18="<<timeDelayOCDB[17]<<
+ "timeDelayPMT19="<<timeDelayOCDB[18]<<
+ "timeDelayPMT20="<<timeDelayOCDB[19]<<
+ "timeDelayPMT21="<<timeDelayOCDB[20]<<
+ "timeDelayPMT22="<<timeDelayOCDB[21]<<
+ "timeDelayPMT23="<<timeDelayOCDB[22]<<
+ "timeDelayPMT24="<<timeDelayOCDB[23];
+
+ //-----> add the mean/sigma of the new histogram here
+
+ (*pcstream)<<"t0QA"<<"\n";
+
+ pcstream->Close();
+
+ delete pcstream;
+
+ return;
+
+}
+
+//_____________________________________________________________________________
+double GetParameterGaus(TH1F *histo, int whichParameter){
+
+ int maxBin = histo->GetMaximumBin();
+ double max = (histo->GetBinContent(maxBin-1) + histo->GetBinContent(maxBin) + histo->GetBinContent(maxBin+1))/3;
+ double mean = histo->GetBinCenter(maxBin); //mean
+ double lowfwhm = histo->GetBinCenter(histo->FindFirstBinAbove(max/2));
+ double highfwhm = histo->GetBinCenter(histo->FindLastBinAbove(max/2));
+ double sigma = (highfwhm - lowfwhm)/2.35482; //estimate fwhm FWHM = 2.35482*sigma
+
+ TF1 *gaussfit = new TF1("gaussfit","gaus", mean - 4*sigma, mean + 4*sigma); // fit in +- 4 sigma window
+ gaussfit->SetParameters(max, mean, sigma);
+
+ if(whichParameter==2)
+ histo->Fit(gaussfit,"RQNI");
+ else
+ histo->Fit(gaussfit,"RQN");
+
+ double parValue = gaussfit->GetParameter(whichParameter);
+
+ delete gaussfit;
+
+ return parValue;
+}
+
+
--- /dev/null
+
+TGraphErrors * MakeGraphSparse(TTree * tree, const Char_t * expr="mean-fdelta:run", const Char_t * cut="isTPC&&ptype==0&&theta>0"){
+ // Format of expr: Var:Error:Run
+ //
+ // Make a sparse draw of the variables
+ // Format of expr : Var:Error:Run
+ //
+
+ const Int_t entries = tree->Draw(expr,cut,"goff");
+
+ Double_t *graphX, *graphY, *graphError;
+
+ //check whether error argument exists in expr
+ if(!tree->GetV3()){
+ graphX = tree->GetV2();
+ graphY = tree->GetV1();
+ }
+ else{
+ graphX = tree->GetV3();
+ graphY = tree->GetV1();
+ graphError = tree->GetV2();
+ }
+
+ // sort according to run number
+ Int_t *index = new Int_t[entries];
+ TMath::Sort(entries,graphX,index,false);
+
+ // define arrays for the new graph
+ Double_t *tempArray = new Double_t[entries];
+ Double_t *xError = new Double_t[entries];
+ Double_t *yError = new Double_t[entries];
+ Int_t *vrun = new Int_t[entries];
+ Double_t count = 0.5;
+
+ // evaluate arrays for the new graph accroding to the run-number
+ Int_t icount=0;
+ tempArray[index[0]] = count;
+ xError[0] = 0;
+ yError[0] = 0;
+ if(tree->GetV3())
+ yError[index[0]] = graphError[index[0]];
+ vrun[0] = graphX[index[0]];
+
+ // loop the rest entries
+ for(Int_t i=1;i<entries;i++){
+ xError[i] = 0;
+ yError[i] = 0;
+
+ if(tree->GetV3())
+ yError[i] = graphError[index[i]];
+
+
+ if(graphX[index[i]]==graphX[index[i-1]])
+ tempArray[index[i]] = count;
+ else if((graphX[index[i]]!=graphX[index[i-1]])){
+ count++;
+ icount++;
+ tempArray[index[i]] = count;
+ vrun[icount]=graphX[index[i]];
+ }
+ }
+
+ // count the number of xbins (run-wise) for the new graph
+ const Int_t newNbins = int(count+0.5);
+ Double_t *newBins = new Double_t[newNbins+1];
+ for(Int_t i=0; i<=count+1;i++){
+ newBins[i] = i;
+ }
+
+ // define and fill the new graph
+ TGraphErrors *graphNew = new TGraphErrors(entries,tempArray,graphY,xError,yError);
+ graphNew->GetXaxis()->Set(newNbins,newBins);
+
+ // set the bins for the x-axis
+ Char_t xName[50];
+ for(Int_t i=0;i<count;i++){
+ sprintf(xName,"%d",Int_t(vrun[i]));
+ graphNew->GetXaxis()->SetBinLabel(i+1,xName);
+ }
+ graphNew->GetHistogram()->SetTitle("");
+
+ // memory clearing
+ delete [] xError;
+ delete [] yError;
+ delete [] tempArray;
+ delete [] index;
+ delete [] newBins;
+ delete [] vrun;
+ return graphNew;
+
+}
+//------------------------------------------------------------------------------------------------
+drawPerformanceT0QATrends(const char* inFile = "trending.root", const char* runType="pp") {
+ //
+ //
+ gROOT->Reset();
+ gROOT->SetStyle("Plain");
+ gStyle->SetPalette(1);
+ gStyle->SetLabelSize(0.04,"x");
+
+
+ // open input file
+ //
+ TFile *file = TFile::Open(inFile);
+ if(!file) return;
+ file->cd();
+
+ TTree *tree = (TTree*)file->Get("t0QA");
+ if(!tree) return;
+ int const entries = tree->GetEntries();
+ cout<<"number of entries "<<entries<<endl;
+ TH1F *frame = new TH1F();
+
+ //const float norm_runs = 8.0;
+ if(entries<8)
+ const float norm_runs =10.0;
+ else if(entries>=8&&entries<16)
+ const float norm_runs =20.0;
+ else
+ const float norm_runs =50.0;
+ int const canvas_width = int(((entries*1.0)/norm_runs)*2000.0);
+ if(entries>50){
+ gStyle->SetTickLength(0.03*norm_runs/(entries*1.0),"Y");
+ gStyle->SetTitleYOffset((norm_runs/(entries*1.0))*0.8);
+ gStyle->SetPadLeftMargin(0.1*norm_runs/(entries*1.0));
+ gStyle->SetPadRightMargin(0.1*norm_runs/(entries*1.0));
+ }
+
+ //Define ranges of you trending plots
+ double resolutionMin = 10, resolutionMax = 50; // OR A - OR C
+ double oraplusorcMin = -100, oraplusorcMax = 100; // OR A + OR CA
+ double oraMin = -100, oraMax = 100; // OR A
+ double orcMin = -100, orcMax = 100; // OR C
+ double amplMin =0, amplMax =3 ; // amplitude in each PMT
+ double timeMin , timeMax ; // amplitude in each PMT
+ //-----> add ranges of your new trending plot
+
+
+ TCanvas *c1 = new TCanvas("can","can",canvas_width,500);
+ c1->SetGridy(1);
+ c1->SetGridx(1);
+ c1->SetBottomMargin(0.17);
+
+ /****** T0 ORA+ORC ******/
+ TGraphErrors *grSum = MakeGraphSparse(tree,"tzeroOrAPlusOrC:run","");
+ grSum->SetMarkerStyle(20);
+ grSum->SetMarkerSize(1.0);
+ grSum->SetMarkerColor(2);
+ TGraphErrors *grORA = MakeGraphSparse(tree,"tzeroOrA:run","");
+ grORA->SetMarkerStyle(28);
+ grORA->SetMarkerSize(1.0);
+ grORA->SetMarkerColor(4);
+ TGraphErrors *grORC = MakeGraphSparse(tree,"tzeroOrC:run","");
+ grORC->SetMarkerStyle(25);
+ grORC->SetMarkerSize(1.0);
+ grORC->SetMarkerColor(1);
+
+ grSum->GetHistogram()->SetYTitle("mean [ps]");
+ grSum->GetHistogram()->SetTitle("T0 ORA, ORC and (ORA+ORC)/2");
+ grSum->GetHistogram()->SetMinimum(oraplusorcMin);
+ grSum->GetHistogram()->SetMaximum(oraplusorcMax);
+ grSum->Draw("AP");
+ grORA->Draw("psame");
+ grORC->Draw("psame");
+ TLegend *leg = new TLegend(0.1,0.85,0.3,0.95," ","brNDC");
+ leg->SetFillStyle(0); leg->SetBorderSize(0); leg->SetTextSize(0.05);leg->SetNColumns(3);leg->SetColumnSeparation(1);
+ leg->AddEntry(grORA,"ORA","p");
+ leg->AddEntry(grORC,"ORC","p");
+ leg->AddEntry(grSum,"(ORA+ORC)/2","p");
+ leg->Draw();
+
+ grSum->GetXaxis()->LabelsOption("v");
+ c1->SaveAs("meanT0OrAPlusOrC_vs_run.gif");
+
+ /****** T0 Resolution ******/
+ TGraphErrors *gr = MakeGraphSparse(tree,"resolution:run","");
+ gr->SetMarkerStyle(20);
+ gr->SetMarkerSize(1.0);
+ gr->SetMarkerColor(2);
+ gr->GetHistogram()->SetMinimum(resolutionMin);
+ gr->GetHistogram()->SetMaximum(resolutionMax);
+ gr->Draw("AP");
+ gr->GetXaxis()->LabelsOption("v");
+ gr->GetHistogram()->SetYTitle("sigma [ps]");
+ gr->GetHistogram()->SetTitle("T0 resolution (ORA -ORC)/2");
+ c1->SaveAs("sigmaResolutionT0_vs_run.gif");
+
+
+ /****** Mean T0 OR A ******/
+ /* TGraphErrors *gr = MakeGraphSparse(tree,"tzeroOrA:run","");
+ gr->SetMarkerStyle(20);
+ gr->SetMarkerSize(1.0);
+ gr->SetMarkerColor(2);
+ gr->GetHistogram()->SetYTitle("mean [ps]");
+ gr->GetHistogram()->SetTitle("T0 OR A");
+ gr->GetHistogram()->SetMinimum(oraMin);
+ gr->GetHistogram()->SetMaximum(oraMax);
+ gr->Draw("AP");
+ gr->GetXaxis()->LabelsOption("v");
+ c1->SaveAs("meanT0OrA_vs_run.gif");
+*/
+
+ /****** Mean T0 OR C ******/
+ /* TGraphErrors *gr = MakeGraphSparse(tree,"tzeroOrC:run","");
+ gr->SetMarkerStyle(20);
+ gr->SetMarkerSize(1.0);
+ gr->SetMarkerColor(2);
+ gr->GetHistogram()->SetYTitle("mean [ps]");
+ gr->GetHistogram()->SetTitle("T0 OR C");
+ gr->GetHistogram()->SetMinimum(orcMin);
+ gr->GetHistogram()->SetMaximum(orcMax);
+ gr->Draw("AP");
+ gr->GetXaxis()->LabelsOption("v");
+ c1->SaveAs("meanT0OrC_vs_run.gif");
+*/
+
+ /****** Mean Amplitude in PMT ******/
+ const int kNPMTs = 24;
+ char name[200];
+
+ for(int ipmt=1;ipmt<=kNPMTs; ipmt++){
+ sprintf(name,"amplPMT%d:run",ipmt);
+ gr = MakeGraphSparse(tree,name,"");
+ gr->SetMarkerStyle(20);
+ gr->SetMarkerSize(1.0);
+ gr->SetMarkerColor(6);
+ gr->GetHistogram()->SetYTitle("mean");
+ gr->GetHistogram()->SetTitle(Form("Amplitude PMT%d",ipmt));
+
+ int nRuns = gr->GetN();
+ double *y = gr->GetY();
+ double min = y[0];
+ double max = y[0];
+ for(int irun =1; irun<nRuns;irun++){
+ if(min > y[irun] & y[irun]>0) min = y[irun];
+ if(max < y[irun]) max = y[irun];
+ }
+ // amplMin = min - 2;
+ // amplMax = max + 2;
+
+ gr->GetHistogram()->SetMinimum(amplMin);
+ gr->GetHistogram()->SetMaximum(amplMax);
+ gr->Draw("AP");
+ gr->GetXaxis()->LabelsOption("v");
+ c1->SaveAs(Form("meanAmplPMT%d_vs_run.gif",ipmt));
+ }
+ /****** Mean Time in PMT ******/
+ for(int ipmt=1;ipmt<=kNPMTs; ipmt++){
+ sprintf(name,"timePMT%d:run",ipmt);
+ gr = MakeGraphSparse(tree,name,"");
+
+
+ sprintf(name,"timeDelayPMT%d:run",ipmt);
+ TGraphErrors *grDelay = MakeGraphSparse(tree,name,"");
+ //regular run
+ int nRuns = gr->GetN();
+ double *y = gr->GetY();
+ double min = y[0];
+ double max = y[0];
+ for(int irun =1; irun<nRuns;irun++){
+ if(min > y[irun] && y[irun]>0) min = y[irun];
+ if(max < y[irun]) max = y[irun];
+ }
+ //Delay
+ // double *yDelay = grDelay->GetY();
+ // nRuns = grDelay->GetN();
+ // for(int irun =0; irun<nRuns;irun++){
+ // if(min > yDelay[irun] && yDelay[irun]>0) min = yDelay[irun];
+ // if(max < yDelay[irun]) max = yDelay[irun];
+ // }
+
+ timeMin = min - 2;
+ timeMax = max + 2;
+
+ gr->SetMarkerStyle(20);
+ gr->SetMarkerSize(1.0);
+ gr->SetMarkerColor(2);
+ grDelay->SetMarkerStyle(24);
+ grDelay->SetMarkerSize(1.0);
+ grDelay->SetMarkerColor(1);
+
+ gr->GetHistogram()->SetYTitle("mean [channels]");
+ gr->GetHistogram()->SetTitle(Form("Time PMT%d",ipmt));
+ gr->GetHistogram()->SetMinimum(timeMin);
+ gr->GetHistogram()->SetMaximum(timeMax);
+ gr->GetXaxis()->LabelsOption("v");
+ gr->Draw("AP");
+ grDelay->Draw("Psame");
+
+ TLegend *leg = new TLegend(0.1,0.85,0.3,0.95," ","brNDC");
+ leg->SetFillStyle(0); leg->SetBorderSize(0); leg->SetTextSize(0.05);leg->SetNColumns(3);
+ leg->AddEntry(gr,"mean time","p");
+ //leg->AddEntry(grDelay,"Time Delay OCDB","p");
+ leg->Draw();
+
+ c1->SaveAs(Form("meanTimePMT%d_vs_run.gif",ipmt));
+ }
+
+
+ //-----> draw your new trending plot here
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff