From 91282711ae7ac662900c80d838327aaa14c4f8ce Mon Sep 17 00:00:00 2001 From: prino Date: Mon, 18 Aug 2008 20:11:32 +0000 Subject: [PATCH] Added macros for analysis of SDD calibration runs (F. Prino) --- ITS/AnalyzeSDDGainAllMod.C | 236 ++++++++++++++++++++ ITS/AnalyzeSDDInjectorsAllMod.C | 199 +++++++++++++++++ ITS/AnalyzeSDDNoiseAllMod.C | 385 ++++++++++++++++++++++++++++++++ 3 files changed, 820 insertions(+) create mode 100644 ITS/AnalyzeSDDGainAllMod.C create mode 100644 ITS/AnalyzeSDDInjectorsAllMod.C create mode 100644 ITS/AnalyzeSDDNoiseAllMod.C diff --git a/ITS/AnalyzeSDDGainAllMod.C b/ITS/AnalyzeSDDGainAllMod.C new file mode 100644 index 00000000000..5d3ab2e45be --- /dev/null +++ b/ITS/AnalyzeSDDGainAllMod.C @@ -0,0 +1,236 @@ +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +#include +#include +#include +#include +#include +#include "AliRawReader.h" +#include "AliRawReaderDate.h" +#include "AliRawReaderRoot.h" +#include "AliITSOnlineSDDBase.h" +#include "AliITSOnlineSDDCMN.h" +#include "AliITSOnlineSDDTP.h" +#include "AliITSRawStreamSDD.h" +#endif + +// Macro for the analysis of PULSER runs (equivalent to ITSSDDGAINda.cxx) +// Two functions named AnalyzeSDDGainAllModules: +// The first is for analyzing a local raw data file and takes as agrument the file name. +// The second is for running on ALIEN +// All DDLs are analyzed, the argument nDDL selects the DDL to be plotted +// Origin: F. Prino (prino@to.infn.it) + + +void AnalyzeSDDGainAllMod(Char_t *datafil, Int_t nDDL, Int_t firstEv=10, Int_t lastEv=16, Float_t pascalDAC=100){ + + Int_t eqOffset = 256; + Int_t DDLid_range = 24; + // Int_t eqOffset = 100; + // Int_t DDLid_range = 1; + const Int_t kTotDDL=24; + const Int_t kModPerDDL=12; + const Int_t kSides=2; + + + TH2F** histo = new TH2F*[kTotDDL*kModPerDDL*kSides]; + AliITSOnlineSDDTP **anal=new AliITSOnlineSDDTP*[kTotDDL*kModPerDDL*kSides]; + Bool_t isFilled[kTotDDL*kModPerDDL*kSides]; + + Char_t hisnam[20]; + for(Int_t iddl=0; iddlSetPalette(1); + Char_t text[50]; + + Int_t iev=firstEv; + AliRawReader *rd; + if(strstr(datafil,".root")!=0){ + rd=new AliRawReaderRoot(datafil,iev); + }else{ + rd=new AliRawReaderDate(datafil,iev); + } + TLatex *t0=new TLatex(); + t0->SetNDC(); + t0->SetTextSize(0.06); + t0->SetTextColor(4); + + do{ + c0->Clear(); + c0->Divide(4,6,0.001,0.001); + printf("Event # %d\n",iev); + //rd->SelectEvents(7); + rd->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + rd->Reset(); + for(Int_t iddl=0; iddlReset(); + } + } + } + AliITSRawStreamSDD s(rd); + rd->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + while(s.Next()){ + Int_t iDDL=rd->GetDDLID(); + Int_t iCarlos=s.GetCarlosId(); + if(iDDL>=0 && iDDLFill(s.GetCoord2(),s.GetCoord1(),s.GetSignal()); + isFilled[index]=1; + } + } + iev++; + for(Int_t iddl=0; iddlAddEvent(histo[index]); + if(iddl==nDDL){ + Int_t index2=kSides*imod+isid; + c0->cd(index2+1); + histo[index]->DrawCopy("colz"); + sprintf(text,"DDL %d channel %d Side %d",nDDL,imod,isid); + t0->DrawLatex(0.15,0.92,text); + c0->Update(); + } + } + } + } + printf(" --- OK\n"); + }while(rd->NextEvent()&&iev<=lastEv); + + TH1F *htotgain=new TH1F("htotgain","",100,0.,5.); + TH1F *htotpeakpos=new TH1F("htotpeakpos","",256,-0.5,255.5); + TH1F *hstatus=new TH1F("hstatus","",2,-0.5,1.5); + + TFile *outfil=new TFile("SDDgain-results.root","recreate"); + for(Int_t iddl=0; iddlValidateAnodes(); + anal[index]->WriteToASCII(); + anal[index]->WriteToROOT(outfil); + for(Int_t ian=0; ian<256;ian++){ + Float_t gain=anal[index]->GetChannelGain(ian); + Float_t ppos=anal[index]->GetTimeBinTPPeak(ian); + Int_t anstatus=anal[index]->IsAnodeGood(ian); + hstatus->Fill(anstatus); + htotgain->Fill(gain); + htotpeakpos->Fill(ppos); + } + } + } + } + } + outfil->Close(); + + // Draw Statistics of baselines and noise + TCanvas *call=new TCanvas("call","General stats",700,700); + call->Divide(2,2); + call->cd(1); + htotpeakpos->Draw(); + htotpeakpos->GetXaxis()->SetTitle("TP peak position (Time Bin)"); + htotpeakpos->GetXaxis()->SetTitleSize(0.07); + htotpeakpos->GetXaxis()->SetTitleOffset(0.6); + call->cd(2); + htotgain->Draw(); + htotgain->GetXaxis()->SetTitle("Gain (ADC/DAC)"); + htotgain->GetXaxis()->SetTitleSize(0.07); + htotgain->GetXaxis()->SetTitleOffset(0.6); + call->cd(3); + hstatus->Draw(); + hstatus->GetXaxis()->SetTitle("Anode Status (0=bad 1=good)"); + hstatus->GetXaxis()->SetTitleSize(0.07); + hstatus->GetXaxis()->SetTitleOffset(0.6); + call->Update(); + call->SaveAs("GenStatsPulser.gif"); + + // Draw baselines and noisegain and TestPulse time bin for all modules + + TH1F** hgain = new TH1F*[kModPerDDL*kSides]; + TH1F** htptb = new TH1F*[kModPerDDL*kSides]; + + TCanvas *c1=new TCanvas("c1","DDL: TP position",900,900); + c1->SetBottomMargin(0.14); + c1->Divide(4,6,0.001,0.001); + TCanvas *c2=new TCanvas("c2","DDL: gain",900,900); + c2->SetBottomMargin(0.14); + c2->Divide(4,6,0.001,0.001); + + for(Int_t imod=0; imodSetNDC(); + t3->SetTextSize(0.06); + t3->SetTextColor(4); + sprintf(hisnam,"hgain%ds%d",imod,isid); + hgain[index2]=new TH1F(hisnam,"",256,-0.5,255.5); + sprintf(hisnam,"htptb%ds%d",imod,isid); + htptb[index2]=new TH1F(hisnam,"",256,-0.5,255.5); + for(Int_t ian=0;ian<256;ian++){ + hgain[index2]->SetBinContent(ian+1,anal[index1]->GetChannelGain(ian)); + htptb[index2]->SetBinContent(ian+1,anal[index1]->GetTimeBinTPPeak(ian)); + } + + c1->cd(index2+1); + htptb[index2]->Draw(); + // htptb[imod]->SetMinimum(0); + // htptb[imod]->SetMaximum(75); + htptb[index2]->GetXaxis()->SetTitle("Anode"); + htptb[index2]->GetYaxis()->SetTitle("TP position (Time Bin)"); + htptb[index2]->GetXaxis()->SetTitleSize(0.07); + htptb[index2]->GetYaxis()->SetTitleSize(0.07); + htptb[index2]->GetXaxis()->SetTitleOffset(0.6); + htptb[index2]->GetYaxis()->SetTitleOffset(0.7); + t3->Draw(); + c1->Update(); + + + c2->cd(index2+1); + hgain[index2]->SetMinimum(0.); + hgain[index2]->SetMaximum(4.); + hgain[index2]->Draw(); + hgain[index2]->GetXaxis()->SetTitle("Anode"); + hgain[index2]->GetYaxis()->SetTitle("Gain"); + hgain[index2]->GetXaxis()->SetTitleSize(0.07); + hgain[index2]->GetYaxis()->SetTitleSize(0.07); + hgain[index2]->GetXaxis()->SetTitleOffset(0.6); + hgain[index2]->GetYaxis()->SetTitleOffset(0.7); + hgain[index2]->SetStats(0); + t3->Draw(); + c2->Update(); + } + } + + c1->SaveAs("TPtimebin.gif"); + c2->SaveAs("Gain.gif"); + +} + +void AnalyzeSDDGainAllMod(Int_t nrun, Int_t n2, Int_t nDDL=0, Int_t firstEv=10, Int_t lastEv=18, Float_t pascalDAC=100){ + TGrid::Connect("alien:",0,0,"t"); + Char_t filnam[200]; + sprintf(filnam,"alien:///alice/data/2008/LHC08c_SDD/%09d/raw/08%09d%03d.10.root",nrun,nrun,n2); + printf("Open file %s\n",filnam); + AnalyzeSDDGainAllMod(filnam,nDDL,firstEv,lastEv,pascalDAC); +} diff --git a/ITS/AnalyzeSDDInjectorsAllMod.C b/ITS/AnalyzeSDDInjectorsAllMod.C new file mode 100644 index 00000000000..de468876b16 --- /dev/null +++ b/ITS/AnalyzeSDDInjectorsAllMod.C @@ -0,0 +1,199 @@ +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "AliRawReader.h" +#include "AliRawReaderDate.h" +#include "AliRawReaderRoot.h" +#include "AliITSOnlineSDDInjectors.h" +#include "AliITSRawStreamSDD.h" +#include "AliITSDDLModuleMapSDD.h" +#endif + +// Macro for the analysis of PULSER runs (equivalent to ITSSDDINJda.cxx) +// Two functions named AnalyzeSDDInjectorsAllModules: +// The first is for analyzing a local raw data file and takes as agrument the file name. +// The second is for running on ALIEN +// All DDLs are analyzed, the argument nDDL selects the DDL to be plotted +// Origin: F. Prino (prino@to.infn.it) + + +void AnalyzeSDDInjectorsAllMod(Char_t *datafil, Int_t nDDL, Int_t firstEv=10, Int_t lastEv=15){ + Int_t eqOffset = 256; + Int_t DDLid_range = 24; + // Int_t eqOffset = 100; + // Int_t DDLid_range = 1; + const Int_t kTotDDL=24; + const Int_t kModPerDDL=12; + const Int_t kSides=2; + + AliITSDDLModuleMapSDD* dmap=new AliITSDDLModuleMapSDD(); + dmap->SetJun08Map(); + + TH2F** histo = new TH2F*[kTotDDL*kModPerDDL*kSides]; + Int_t nWrittenEv[kTotDDL*kModPerDDL*kSides]; + TGraphErrors** gvel = new TGraphErrors*[kTotDDL*kModPerDDL*kSides]; + AliITSOnlineSDDInjectors **anal=new AliITSOnlineSDDInjectors*[kTotDDL*kModPerDDL*kSides]; + + Char_t hisnam[20]; + for(Int_t iddl=0; iddlSetPalette(1); + TCanvas* c1 = new TCanvas("c1","",900,900); + Char_t text[50]; + + Int_t iev=firstEv; + AliRawReader *rd; + if(strstr(datafil,".root")!=0){ + rd=new AliRawReaderRoot(datafil,iev); + }else{ + rd=new AliRawReaderDate(datafil,iev); + } + + Char_t gname[15]; + TF1 *funz=new TF1("funz","[0]+[1]*x+[2]*x*x+[3]*x*x*x",0.,255.); + TLatex *t0=new TLatex(); + t0->SetNDC(); + t0->SetTextSize(0.06); + t0->SetTextColor(4); + + do{ + c0->Clear(); + c0->Divide(4,6,0.001,0.001); + c1->Clear(); + c1->Divide(4,6,0.001,0.001); + printf("Event # %d\n",iev); + UInt_t timeSt=rd->GetTimestamp(); + //rd->SelectEvents(7); + rd->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + rd->Reset(); + for(Int_t iddl=0; iddlReset(); + } + } + } + + AliITSRawStreamSDD s(rd); + rd->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + while(s.Next()){ + Int_t iDDL=rd->GetDDLID(); + Int_t iCarlos=s.GetCarlosId(); + if(iDDL>=0 && iDDLFill(s.GetCoord2(),s.GetCoord1(),s.GetSignal()); + } + } + + for(Int_t iddl=0; iddlAnalyzeEvent(histo[index]); + anal[index]->WriteToASCII(iev,timeSt,nWrittenEv[index]); + nWrittenEv[index]++; + if(iev==firstEv && anal[index]->GetInjPadStatus(16)>=6){ + Float_t vel=anal[index]->GetDriftSpeed(16); + Int_t iMod=dmap->GetModuleNumber(iddl,imod); + if(isid==0) gvvsmod0->SetPoint(gvvsmod0->GetN(),(Float_t)iMod,vel); + if(isid==1) gvvsmod1->SetPoint(gvvsmod1->GetN(),(Float_t)iMod,vel); + } + if(iddl==nDDL){ + Int_t index2=kSides*imod+isid; + c0->cd(index2+1); + histo[index]->SetMaximum(100.); + histo[index]->DrawCopy("colz"); + sprintf(text,"DDL %d channel %d Side %d",nDDL,imod,isid); + t0->DrawLatex(0.15,0.92,text); + c0->Update(); + c1->cd(index2+1); + gvel[index]=anal[index]->GetDriftSpeedGraph(); + gvel[index]->SetMarkerStyle(20); + gvel[index]->SetTitle(""); + sprintf(gname,"gvel%dev%d",index,iev); + gvel[index]->SetName(gname); + // gvel[index]->SetMinimum(0); + //gvel[index]->SetMaximum(200); + + gvel[index]->GetXaxis()->SetLimits(0,256); + gvel[index]->GetXaxis()->SetTitle("Anode"); + gvel[index]->GetYaxis()->SetTitle("Drift vel."); + gvel[index]->GetXaxis()->SetTitleSize(0.07); + gvel[index]->GetYaxis()->SetTitleSize(0.07); + gvel[index]->GetXaxis()->SetTitleOffset(0.6); + gvel[index]->GetYaxis()->SetTitleOffset(0.6); + if(gvel[index]->GetN()>0) gvel[index]->Draw("AP"); + Float_t *param=anal[index]->GetDriftSpeedFitParam(); + funz->SetParameters(param[0],param[1],param[2],param[3]); + funz->SetLineColor(2); + funz->DrawCopy("LSAME"); + t0->DrawLatex(0.15,0.92,text); + c1->Update(); + } + } + } + } + iev++; + printf(" --- OK\n"); + }while(rd->NextEvent()&&iev<=lastEv); + + TCanvas* c8=new TCanvas("c8"); + gvvsmod0->SetTitle(""); + gvvsmod1->SetTitle(""); + + gvvsmod0->SetMarkerStyle(20); + gvvsmod1->SetMarkerStyle(21); + gvvsmod1->SetMarkerColor(2); + gvvsmod0->Draw("AP"); + gvvsmod0->SetMinimum(6.2); + gvvsmod0->SetMaximum(7.2); + gvvsmod0->GetXaxis()->SetTitle("Module Number"); + gvvsmod0->GetYaxis()->SetTitle("Vdrift at injector pad 16"); + gvvsmod1->Draw("PSAME"); + TLatex* tleft=new TLatex(0.7,0.82,"Side 0"); + tleft->SetNDC(); + tleft->SetTextColor(1); + tleft->Draw(); + TLatex* tright=new TLatex(0.7,0.75,"Side 1"); + tright->SetNDC(); + tright->SetTextColor(2); + tright->Draw(); + + TLine *lin=new TLine(323,6.2,323,7.2); + lin->SetLineColor(4); + lin->Draw(); + c8->Update(); +} + +void AnalyzeSDDInjectorsAllMod(Int_t nrun, Int_t n2, Int_t nDDL=0, Int_t firstEv=10, Int_t lastEv=15){ + TGrid::Connect("alien:",0,0,"t"); + Char_t filnam[200]; + sprintf(filnam,"alien:///alice/data/2008/LHC08c_SDD/%09d/raw/08%09d%03d.10.root",nrun,nrun,n2); + printf("Open file %s\n",filnam); + AnalyzeSDDInjectorsAllMod(filnam,nDDL,firstEv,lastEv); +} + + + diff --git a/ITS/AnalyzeSDDNoiseAllMod.C b/ITS/AnalyzeSDDNoiseAllMod.C new file mode 100644 index 00000000000..225a14e9403 --- /dev/null +++ b/ITS/AnalyzeSDDNoiseAllMod.C @@ -0,0 +1,385 @@ +#if !defined(__CINT__) || defined(__MAKECINT__) +#include +#include +#include +#include +#include +#include +#include +#include +#include "AliRawReader.h" +#include "AliRawReaderDate.h" +#include "AliRawReaderRoot.h" +#include "AliITSOnlineSDDBase.h" +#include "AliITSOnlineSDDCMN.h" +#include "AliITSRawStreamSDD.h" +#include "TPaveStats.h" +#endif + +// Macro for the analysis of PEDESTAL runs (equivalent to ITSSDDBASda.cxx) +// Two functions named AnalyzeSDDNoiseAllModules: +// The first is for analyzing a local raw data file and takes as agrument the file name. +// The second is for running on ALIEN +// All DDLs are analyzed, the argument nDDL selects the DDL to be plotted +// Origin: F. Prino (prino@to.infn.it) + +void AnalyzeSDDNoiseAllMod(Char_t *datafil, Int_t nDDL, Int_t firstEv=10, Int_t lastEv=12){ + Int_t eqOffset = 256; + Int_t DDLid_range = 24; + // Int_t eqOffset = 100; + // Int_t DDLid_range = 1; + const Int_t kTotDDL=24; + const Int_t kModPerDDL=12; + const Int_t kSides=2; + + AliITSOnlineSDDBase **base=new AliITSOnlineSDDBase*[kTotDDL*kModPerDDL*kSides]; + TH2F **histo=new TH2F*[kTotDDL*kModPerDDL*kSides]; + + Char_t hisnam[20]; + for(Int_t iddl=0; iddlSetFirstGoodTB(5); + base[index]->SetFirstGoodTB(120); + sprintf(hisnam,"h%02dc%02ds%d",iddl,imod,isid); + histo[index]=new TH2F(hisnam,"",128,-0.5,127.5,256,-0.5,255.5); + } + } + } + + + TCanvas* c0 = new TCanvas("c0","Ev Display",900,900); + gStyle->SetPalette(1); + Char_t text[50]; + + Int_t iev=firstEv; + AliRawReader *rd; + if(strstr(datafil,".root")!=0){ + rd=new AliRawReaderRoot(datafil,iev); + }else{ + rd=new AliRawReaderDate(datafil,iev); + } + TLatex *t0=new TLatex(); + t0->SetNDC(); + t0->SetTextSize(0.06); + t0->SetTextColor(4); + + do{ + c0->Clear(); + c0->Divide(4,6,0.001,0.001); + printf("Event # %d ",iev); + //rd->SelectEvents(7); + rd->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + rd->Reset(); + for(Int_t iddl=0; iddlReset(); + } + } + } + AliITSRawStreamSDD s(rd); + rd->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + while(s.Next()){ + Int_t iDDL=rd->GetDDLID(); + Int_t iCarlos=s.GetCarlosId(); + if(iDDL>=0 && iDDLFill(s.GetCoord2(),s.GetCoord1(),s.GetSignal()); + } + } + iev++; + for(Int_t iddl=0; iddlAddEvent(histo[index]); + if(iddl==nDDL){ + Int_t index2=kSides*imod+isid; + c0->cd(index2+1); + histo[index]->DrawCopy("colz"); + sprintf(text,"DDL %d channel %d Side %d",nDDL,imod,isid); + t0->DrawLatex(0.15,0.92,text); + c0->Update(); + } + } + } + } + printf(" --- OK\n"); + }while(rd->NextEvent()&&iev<=lastEv); + + for(Int_t iddl=0; iddlValidateAnodes(); + base[index]->WriteToASCII(); // fondamentale!!!!!!!!! + delete base[index]; + } + } + } + delete rd; + delete [] base; + + printf("Start second analysis for Common Mode correction\n"); + AliITSOnlineSDDCMN **corr=new AliITSOnlineSDDCMN*[kTotDDL*kModPerDDL*kSides]; + Bool_t isFilled[kTotDDL*kModPerDDL*kSides]; + + for(Int_t iddl=0; iddlClear(); + c0->Divide(4,6,0.001,0.001); + printf("Event # %d ",iev); + rd2->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + // rd2->SelectEvents(7); + rd2->Reset(); + for(Int_t iddl=0; iddlReset(); + } + } + } + + AliITSRawStreamSDD s(rd2); + rd2->SelectEquipment(17,eqOffset,eqOffset+DDLid_range); + while(s.Next()){ + Int_t iDDL=rd2->GetDDLID(); + Int_t iCarlos=s.GetCarlosId(); + if(iDDL>=0 && iDDLFill(s.GetCoord2(),s.GetCoord1(),s.GetSignal()); + isFilled[index]=1; + } + } + iev++; + for(Int_t iddl=0; iddlAddEvent(histo[index]); + if(iddl==nDDL){ + Int_t index2=kSides*imod+isid; + c0->cd(index2+1); + histo[index]->DrawCopy("colz"); + sprintf(text,"DDL %d channel %d Side %d",nDDL,imod,isid); + t0->DrawLatex(0.15,0.92,text); + c0->Update(); + } + } + } + } + printf(" --- OK\n"); + }while(rd2->NextEvent()&&iev<=lastEv); + + TH1F *htotbas=new TH1F("htotbas","",100,0.,150.); + TH1F *htotbaseq=new TH1F("htotbaseq","",100,0.,150.); + TH1F *htotnoise=new TH1F("htotnoise","",100,0.,10.); + TH1F *htotnoisecorr=new TH1F("htotnoisecorr","",100,0.,10.); + TH1F *hstatus=new TH1F("hstatus","",2,-0.5,1.5); + + TFile *outfil=new TFile("SDDbase-results.root","recreate"); + for(Int_t iddl=0; iddlValidateAnodes(); + corr[index]->WriteToASCII(); + corr[index]->WriteToROOT(outfil); + for(Int_t ian=0; ian<256;ian++){ + Float_t basl=corr[index]->GetAnodeBaseline(ian); + Float_t basleq=corr[index]->GetAnodeEqualizedBaseline(ian); + Float_t noi=corr[index]->GetAnodeRawNoise(ian); + Float_t cornoi=corr[index]->GetAnodeCorrNoise(ian); + Int_t anstatus=corr[index]->IsAnodeGood(ian); + hstatus->Fill(anstatus); + htotbas->Fill(basl); + htotbaseq->Fill(basleq); + htotnoise->Fill(noi); + htotnoisecorr->Fill(cornoi); + } + } + } + } + } + outfil->Close(); + // Draw Statistics of baselines and noise + TCanvas *call=new TCanvas("call","General stats",700,700); + call->Divide(2,2); + call->cd(1); + htotbas->Draw(); + htotbas->GetXaxis()->SetTitle("Baselines"); + htotbas->GetXaxis()->SetTitleSize(0.07); + htotbas->GetXaxis()->SetTitleOffset(0.6); + call->cd(2); + htotbaseq->Draw(); + htotbaseq->GetXaxis()->SetTitle("Baselines after equalization"); + htotbaseq->GetXaxis()->SetTitleSize(0.07); + htotbaseq->GetXaxis()->SetTitleOffset(0.6); + call->cd(3); + htotnoisecorr->SetLineColor(2); + htotnoisecorr->Draw(); + call->Update(); + TPaveStats *st1=(TPaveStats*)htotnoisecorr->GetListOfFunctions()->FindObject("stats"); + st1->SetY1NDC(0.51); + st1->SetY2NDC(0.7); + htotnoisecorr->GetXaxis()->SetTitle("Noise"); + htotnoisecorr->GetXaxis()->SetTitleSize(0.07); + htotnoisecorr->GetXaxis()->SetTitleOffset(0.6); + htotnoise->Draw("SAMES"); + call->Update(); + TPaveStats *st2=(TPaveStats*)htotnoise->GetListOfFunctions()->FindObject("stats"); + st2->SetY1NDC(0.71); + st2->SetY2NDC(0.9); + + call->cd(4); + hstatus->Draw(); + hstatus->GetXaxis()->SetTitle("Anode Status (0=bad 1=good)"); + hstatus->GetXaxis()->SetTitleSize(0.07); + hstatus->GetXaxis()->SetTitleOffset(0.6); + call->Update(); + call->SaveAs("GenStatsPedestal.gif"); + + // Draw baselines and noise for all modules of the selected DDL + + TH1F** hbas = new TH1F*[kSides*kModPerDDL]; + TH1F** hrawn = new TH1F*[kSides*kModPerDDL]; + TH1F** hcorrn = new TH1F*[kSides*kModPerDDL]; + TH1F** hdbas = new TH1F*[kSides*kModPerDDL]; + TH1F** hdrawn = new TH1F*[kSides*kModPerDDL]; + TH1F** hdcorrn = new TH1F*[kSides*kModPerDDL]; + TCanvas *c1=new TCanvas("c1","DDL: Baselines vs anode",900,900); + c1->SetBottomMargin(0.14); + c1->Divide(4,6,0.001,0.001); + TCanvas *c2=new TCanvas("c2","DDL: Noise vs anode",900,900); + c2->SetBottomMargin(0.14); + c2->Divide(4,6,0.001,0.001); + TCanvas *c3=new TCanvas("c3","DDL: Baselines distr",900,900); + c3->SetBottomMargin(0.14); + c3->Divide(4,6,0.001,0.001); + TCanvas *c4=new TCanvas("c4","DDL: Noise Distr",900,900); + c4->SetBottomMargin(0.14); + c4->Divide(4,6,0.001,0.001); + TLatex *t1=new TLatex(0.15,0.2,"Raw Noise"); + t1->SetNDC(); + t1->SetTextSize(0.05); + TLatex *t2=new TLatex(0.4,0.2,"Corrected Noise"); + t2->SetNDC(); + t2->SetTextSize(0.05); + t2->SetTextColor(2); + TLatex *t3=new TLatex(); + t3->SetNDC(); + t3->SetTextSize(0.06); + t3->SetTextColor(4); + + for(Int_t imod=0; imodGetBaselineAnodeHisto(); + hrawn[index2]=corr[index1]->GetRawNoiseAnodeHisto(); + hcorrn[index2]=corr[index1]->GetCorrNoiseAnodeHisto(); + hdbas[index2]=corr[index1]->GetBaselineHisto(); + hdrawn[index2]=corr[index1]->GetRawNoiseHisto(); + hdcorrn[index2]=corr[index1]->GetCorrNoiseHisto(); + c1->cd(index2+1); + hbas[index2]->Draw(); + hbas[index2]->SetMinimum(0); + hbas[index2]->SetMaximum(75); + hbas[index2]->GetXaxis()->SetTitle("Anode"); + hbas[index2]->GetYaxis()->SetTitle("Baseline"); + hbas[index2]->GetXaxis()->SetTitleSize(0.07); + hbas[index2]->GetYaxis()->SetTitleSize(0.07); + hbas[index2]->GetXaxis()->SetTitleOffset(0.6); + hbas[index2]->GetYaxis()->SetTitleOffset(0.7); + t3->DrawLatex(0.15,0.92,text); + c1->Update(); + + + c2->cd(index2+1); + hrawn[index2]->SetMinimum(1.); + hrawn[index2]->SetMaximum(6.); + hrawn[index2]->Draw(); + hrawn[index2]->GetXaxis()->SetTitle("Anode"); + hrawn[index2]->GetYaxis()->SetTitle("Noise"); + hrawn[index2]->GetXaxis()->SetTitleSize(0.07); + hrawn[index2]->GetYaxis()->SetTitleSize(0.07); + hrawn[index2]->GetXaxis()->SetTitleOffset(0.6); + hrawn[index2]->GetYaxis()->SetTitleOffset(0.7); + gStyle->SetOptStat(0); + hrawn[index2]->SetStats(0); + hcorrn[index2]->SetLineColor(2); + hcorrn[index2]->Draw("SAME"); + t1->Draw(); + t2->Draw(); + t3->DrawLatex(0.15,0.92,text); + c2->Update(); + + c3->cd(index2+1); + hdbas[index2]->Draw(); + hdbas[index2]->GetXaxis()->SetTitle("Baseline"); + hdbas[index2]->GetXaxis()->SetTitleSize(0.07); + hdbas[index2]->GetXaxis()->SetTitleOffset(0.6); + t3->DrawLatex(0.15,0.92,text); + c3->Update(); + + c4->cd(index2+1); + hdrawn[index2]->Draw(); + hdrawn[index2]->GetXaxis()->SetTitle("Noise"); + hdrawn[index2]->GetXaxis()->SetTitleSize(0.07); + hdrawn[index2]->GetXaxis()->SetTitleOffset(0.6); + hdcorrn[index2]->SetLineColor(2); + hdcorrn[index2]->Draw("SAME"); + t1->Draw(); + t2->Draw(); + t3->DrawLatex(0.15,0.92,text); + c4->Update(); + } + } + + c1->SaveAs("Baselines.gif"); + c2->SaveAs("Noise.gif"); + c3->SaveAs("BaselinesDist.gif"); + c4->SaveAs("NoiseDist.gif"); + + Char_t delfil[100]; + for(Int_t iddl=0; iddlExec(delfil); + } + } + } + +} + +void AnalyzeSDDNoiseAllMod(Int_t nrun, Int_t n2, Int_t nDDL=0, Int_t firstEv=10, Int_t lastEv=15){ + TGrid::Connect("alien:",0,0,"t"); + Char_t filnam[200]; + sprintf(filnam,"alien:///alice/data/2008/LHC08c_SDD/%09d/raw/08%09d%03d.10.root",nrun,nrun,n2); + printf("Open file %s\n",filnam); + AnalyzeSDDNoiseAllMod(filnam,nDDL,firstEv,lastEv); +} -- 2.43.0