ITS/macrosSDD/PlotDriftSpeedSDDVsTime.C

   1 #if !defined(__CINT__) || defined(__MAKECINT__)
   2 #include <Riostream.h>
   3 #include <TFile.h>
   4 #include <TH1F.h>
   5 #include <TH2F.h>
   6 #include <TGraph.h>
   7 #include <TStyle.h>
   8 #include <TLegend.h>
   9 #include <TLegendEntry.h>
  10 #include <TLine.h>
  11 #include <TSystem.h>
  12 #include <TGrid.h>
  13 #include <TMath.h>
  14 #include <TGraphErrors.h>
  15 #include <TCanvas.h>
  16 #include <TLatex.h>
  17 #include <TObjArray.h>
  18 #include "AliCDBEntry.h"
  19 #include "AliITSDriftSpeedArraySDD.h"
  20 #include "AliITSgeomTGeo.h"
  21 #endif
  22
  23 /*  $Id: PlotDriftSpeedSDDVsTime.C 41510 2010-06-01 09:21:24Z prino $    */
  24
  25
  26 // Macro to plot the drift speed vs. time from the OCDB files
  27 // created from INJECTOR runs (OCDB/ITS/Calib/DriftSpeedSDD)
  28 // Origin: F. Prino (prino@to.infn.it)
  29
  30 void FillErrors(Float_t errSpeed[260]);
  31
  32 void PlotDriftSpeedSDDVsTime(Int_t year=2011, Int_t firstRun=142600,
  33                              Int_t lastRun=999999999,
  34                              Int_t anode=128){
  35   TGrid::Connect("alien:",0,0,"t");
  36   Float_t errSpeed[260];
  37   FillErrors(errSpeed);
  38   TString cmd=Form("gbbox find \"/alice/data/%d/OCDB/ITS/Calib/DriftSpeedSDD\" \"Run*.root\" > runSpeedAlien.txt",year);
  39   gSystem->Exec(cmd.Data());
  40   FILE* listruns=fopen("runSpeedAlien.txt","r");
  41   Char_t filnam[200],filnamalien[200];
  42   TGraphErrors** gvdrvstime=new TGraphErrors*[520];
  43   TGraphErrors** gvdrvsrun=new TGraphErrors*[520];
  44   TGraph* gGoodInjVsRun=new TGraph(0);
  45   gGoodInjVsRun->SetName("gGoodInjVsRun");
  46   TGraph* gAverSpeedVsRun=new TGraph(0);
  47   gAverSpeedVsRun->SetName("gAverSpeedVsRun");
  48   TGraph* gGoodInjVsTime=new TGraph(0);
  49   gGoodInjVsTime->SetName("gGoodInjVsTime");
  50   TGraph* gAverSpeedVsTime=new TGraph(0);
  51   gAverSpeedVsTime->SetName("gAverSpeedVsIime");
  52
  53   TGraph* gGoodInjVsRunL3=new TGraph(0);
  54   gGoodInjVsRunL3->SetName("gGoodInjVsRunL3");
  55   TGraph* gAverSpeedVsRunL3=new TGraph(0);
  56   gAverSpeedVsRunL3->SetName("gAverSpeedVsRunL3");
  57   TGraph* gGoodInjVsTimeL3=new TGraph(0);
  58   gGoodInjVsTimeL3->SetName("gGoodInjVsTimeL3");
  59   TGraph* gAverSpeedVsTimeL3=new TGraph(0);
  60   gAverSpeedVsTimeL3->SetName("gAverSpeedVsIimeL3");
  61
  62   TGraph* gGoodInjVsRunL4=new TGraph(0);
  63   gGoodInjVsRunL4->SetName("gGoodInjVsRunL4");
  64   TGraph* gAverSpeedVsRunL4=new TGraph(0);
  65   gAverSpeedVsRunL4->SetName("gAverSpeedVsRunL4");
  66   TGraph* gGoodInjVsTimeL4=new TGraph(0);
  67   gGoodInjVsTimeL4->SetName("gGoodInjVsTimeL4");
  68   TGraph* gAverSpeedVsTimeL4=new TGraph(0);
  69   gAverSpeedVsTimeL4->SetName("gAverSpeedVsIimeL4");
  70
  71   TGraph* gFracGoodInjVsRun=new TGraph(0);
  72   gFracGoodInjVsRun->SetName("gFracGoodInjVsRun");
  73   TGraph* gFracAverSpeedVsRun=new TGraph(0);
  74   gFracAverSpeedVsRun->SetName("gFracAverSpeedVsRun");
  75   TGraph* gFracGoodInjVsTime=new TGraph(0);
  76   gFracGoodInjVsTime->SetName("gFracGoodInjVsTime");
  77   TGraph* gFracAverSpeedVsTime=new TGraph(0);
  78   gFracAverSpeedVsTime->SetName("gAverSpeedVsIime");
  79
  80   TGraph* gFracGoodInjVsRunL3=new TGraph(0);
  81   gFracGoodInjVsRunL3->SetName("gFracGoodInjVsRunL3");
  82   TGraph* gFracAverSpeedVsRunL3=new TGraph(0);
  83   gFracAverSpeedVsRunL3->SetName("gFracAverSpeedVsRunL3");
  84   TGraph* gFracGoodInjVsTimeL3=new TGraph(0);
  85   gFracGoodInjVsTimeL3->SetName("gFracGoodInjVsTimeL3");
  86   TGraph* gFracAverSpeedVsTimeL3=new TGraph(0);
  87   gFracAverSpeedVsTimeL3->SetName("gFracAverSpeedVsIimeL3");
  88
  89   TGraph* gFracGoodInjVsRunL4=new TGraph(0);
  90   gFracGoodInjVsRunL4->SetName("gFracGoodInjVsRunL4");
  91   TGraph* gFracAverSpeedVsRunL4=new TGraph(0);
  92   gFracAverSpeedVsRunL4->SetName("gFracAverSpeedVsRunL4");
  93   TGraph* gFracGoodInjVsTimeL4=new TGraph(0);
  94   gFracGoodInjVsTimeL4->SetName("gFracGoodInjVsTimeL4");
  95   TGraph* gFracAverSpeedVsTimeL4=new TGraph(0);
  96   gFracAverSpeedVsTimeL4->SetName("gFracAverSpeedVsIimeL4");
  97
  98   for(Int_t iMod=0; iMod<260;iMod++){
  99     gvdrvstime[iMod]=new TGraphErrors(0);
 100     gvdrvstime[iMod]->SetTitle(Form("Module %d",iMod+240));
 101     gvdrvstime[iMod]->SetName(Form("gspmod%dt",iMod+240));
 102     gvdrvsrun[iMod]=new TGraphErrors(0);
 103     gvdrvsrun[iMod]->SetTitle(Form("Module %d",iMod+240));
 104     gvdrvsrun[iMod]->SetName(Form("gspmod%dr",iMod+240));
 105   }
 106   Float_t Edrift=(1800-45)/291/0.012;
 107   Int_t nrun,nrun2,nv,ns;
 108   Float_t timeZero;
 109   if(year==2009) timeZero=1247762992;
 110   else if(year==2010) timeZero=1262300400;
 111   else timeZero=1293861600;
 112
 113   while(!feof(listruns)){
 114     fscanf(listruns,"%s\n",filnam);
 115     Char_t directory[100];
 116     sprintf(directory,"/alice/data/%d",year);
 117     if(!strstr(filnam,directory)) continue;
 118        sscanf(filnam,"/alice/data/%d/OCDB/ITS/Calib/DriftSpeedSDD/Run%d_%d_v%d_s%d.root",&year,&nrun,&nrun2,&nv,&ns);
 119
 120        if(year==2009 && (nrun<85639 && nrun2> 85639)) continue;// protection for files with swapped ladders 4-5 of layer 3
 121        if(year==2009 && (nrun>100000 && nv< 325)) continue; // protection for files with swapped ladder 0-1 of layer 4
 122
 123     if(nrun<firstRun) continue;
 124     if(nrun>lastRun) continue;
 125     sprintf(filnamalien,"alien://%s",filnam);
 126     printf("Open file: %s\n",filnam);
 127     TFile *f= TFile::Open(filnamalien);
 128     if(f==0x0)continue;
 129     AliCDBEntry *ent=(AliCDBEntry*)f->Get("AliCDBEntry");
 130     TObjArray *drspSDD = (TObjArray *)ent->GetObject();
 131
 132     Int_t iGoodInj=0;
 133     Int_t iAverSpeed=0;
 134
 135     Int_t iGoodInjL3=0;
 136     Int_t iAverSpeedL3=0;
 137
 138     Int_t iGoodInjL4=0;
 139     Int_t iAverSpeedL4=0;
 140
 141     Int_t totalgoodinj=520;
 142     Int_t totalgoodinjL3=168;
 143     Int_t totalgoodinjL4=352;
 144
 145     Float_t fracGoodInj=0.;
 146     Float_t fracGoodInjL3=0.;
 147     Float_t fracGoodInjL4=0.;
 148
 149     Float_t fracAverSpeed=0.;
 150     Float_t fracAverSpeedL3=0.;
 151     Float_t fracAverSpeedL4=0.;
 152
 153
 154     Float_t timeday=0;
 155
 156     AliITSDriftSpeedArraySDD *vdriftarr;
 157     AliITSDriftSpeedArraySDD *vdriftarr0;
 158     AliITSDriftSpeedArraySDD *vdriftarr1;
 159
 160     for(Int_t iMod=0; iMod<260;iMod++){
 161       Int_t index=-1;
 162       if(anode<256) index=2*iMod;
 163       else index=2*iMod+1;
 164       vdriftarr=(AliITSDriftSpeedArraySDD*)drspSDD->At(index);
 165
 166       Int_t i0=2*iMod;
 167       Int_t i1=1+2*iMod;
 168       vdriftarr0=(AliITSDriftSpeedArraySDD*)drspSDD->At(i0);
 169       vdriftarr1=(AliITSDriftSpeedArraySDD*)drspSDD->At(i1);
 170
 171       Int_t statusInj0=vdriftarr0->GetInjectorStatus();
 172       Int_t statusInj1=vdriftarr1->GetInjectorStatus();
 173       if(statusInj0>0){
 174         iGoodInj++;
 175         if(iMod<84)iGoodInjL3++;
 176         else iGoodInjL4++;
 177       }
 178       else{
 179         iAverSpeed++;
 180         if(iMod<84)iAverSpeedL3++;
 181         else iAverSpeedL4++;
 182       }
 183       if(statusInj1>0){
 184         iGoodInj++;
 185         if(iMod<84)iGoodInjL3++;
 186         else iGoodInjL4++;
 187       }else{
 188         iAverSpeed++;
 189         if(iMod<84)iAverSpeedL3++;
 190         else iAverSpeedL4++;
 191       }
 192
 193       Int_t iAn=anode;
 194       if(anode>256) iAn=anode-256;
 195       Float_t vdrift=vdriftarr->GetDriftSpeed(0,iAn);
 196       if(vdrift<4. || vdrift > 8.) continue;
 197       if(statusInj0==0) continue;
 198       Int_t npt=gvdrvsrun[iMod]->GetN();
 199       gvdrvsrun[iMod]->SetPoint(npt,(Float_t)nrun,vdrift);
 200       gvdrvsrun[iMod]->SetPointError(npt,0,errSpeed[iMod]);
 201
 202       UInt_t timest=vdriftarr->GetTimestamp(0);
 203       if(timest==0) continue;
 204       if(timest<timeZero) continue;
 205       timeday=float(timest-timeZero)/60./60./24.;
 206       Float_t mob=vdrift*1.E5/Edrift;
 207       Float_t temper=293.15*TMath::Power((mob/1350.),-1/2.4);
 208       if(iMod==497-240) printf("Run %s   Time %d Day %f Speed=%f Temp=%f\n",filnam,timest,timeday,vdrift,temper);
 209       npt=gvdrvstime[iMod]->GetN();
 210       gvdrvstime[iMod]->SetPoint(npt,timeday,vdrift);
 211       gvdrvstime[iMod]->SetPointError(npt,0,errSpeed[iMod]);
 212     }
 213     Int_t npt=gGoodInjVsRun->GetN();
 214     fracGoodInj=(Float_t)iGoodInj/(Float_t)totalgoodinj;
 215     fracGoodInjL3=(Float_t)iGoodInjL3/(Float_t)totalgoodinjL3;
 216     fracGoodInjL4=(Float_t)iGoodInjL4/(Float_t)totalgoodinjL4;
 217
 218     fracAverSpeed   = (Float_t)iAverSpeed/(Float_t)totalgoodinj;
 219     fracAverSpeedL3 = (Float_t)iAverSpeedL3/(Float_t)totalgoodinjL3;
 220     fracAverSpeedL4 = (Float_t)iAverSpeedL4/(Float_t)totalgoodinjL4;
 221
 222     gGoodInjVsRun->SetPoint(npt,(Float_t)nrun,iGoodInj);
 223     gAverSpeedVsRun->SetPoint(npt,(Float_t)nrun,iAverSpeed);
 224
 225     gGoodInjVsRunL3->SetPoint(npt,(Float_t)nrun,iGoodInjL3);
 226     gAverSpeedVsRunL3->SetPoint(npt,(Float_t)nrun,iAverSpeedL3);
 227
 228     gGoodInjVsRunL4->SetPoint(npt,(Float_t)nrun,iGoodInjL4);
 229     gAverSpeedVsRunL4->SetPoint(npt,(Float_t)nrun,iAverSpeedL4);
 230
 231
 232     gFracGoodInjVsRun->SetPoint(npt,(Float_t)nrun,(Double_t)fracGoodInj);
 233     gFracAverSpeedVsRun->SetPoint(npt,(Float_t)nrun,(Double_t)fracAverSpeed);
 234
 235     gFracGoodInjVsRunL3->SetPoint(npt,(Float_t)nrun,(Double_t)fracGoodInjL3);
 236     gFracAverSpeedVsRunL3->SetPoint(npt,(Float_t)nrun,(Double_t)fracAverSpeedL3);
 237
 238     gFracGoodInjVsRunL4->SetPoint(npt,(Float_t)nrun,(Double_t)fracGoodInjL4);
 239     gFracAverSpeedVsRunL4->SetPoint(npt,(Float_t)nrun,(Double_t)fracAverSpeedL4);
 240
 241     npt=gGoodInjVsTime->GetN();
 242
 243     gGoodInjVsTime->SetPoint(npt,timeday,iGoodInj);
 244     gAverSpeedVsTime->SetPoint(npt,timeday,iAverSpeed);
 245
 246     gGoodInjVsTimeL3->SetPoint(npt,timeday,iGoodInjL3);
 247     gAverSpeedVsTimeL3->SetPoint(npt,timeday,iAverSpeedL3);
 248
 249     gGoodInjVsTimeL4->SetPoint(npt,timeday,iGoodInjL4);
 250     gAverSpeedVsTimeL4->SetPoint(npt,timeday,iAverSpeedL4);
 251
 252
 253     gFracGoodInjVsTime->SetPoint(npt,timeday,(Double_t)fracGoodInj);
 254     gFracAverSpeedVsTime->SetPoint(npt,timeday,(Double_t)fracAverSpeed);
 255
 256     gFracGoodInjVsTimeL3->SetPoint(npt,timeday,(Double_t)fracGoodInjL3);
 257     gFracAverSpeedVsTimeL3->SetPoint(npt,timeday,(Double_t)fracAverSpeedL3);
 258
 259     gFracGoodInjVsTimeL4->SetPoint(npt,timeday,(Double_t)fracGoodInjL4);
 260     gFracAverSpeedVsTimeL4->SetPoint(npt,timeday,(Double_t)fracAverSpeedL4);
 261
 262
 263     printf("Number of half-modules with drift speed from injectors = %d\n",iGoodInj);
 264     printf("Number of half-modules with average drift speed        = %d\n",iAverSpeed);
 265     printf("Number of half-modules with drift speed from injectors L3 = %d\n",iGoodInjL3);
 266     printf("Number of half-modules with drift speed from injectors L4 = %d\n",iGoodInjL4);
 267
 268     f->Close();
 269   }
 270
 271   Int_t mod1=244-240;
 272   Int_t mod2=277-240;
 273   //  Int_t mod2=259-240;
 274 //   Int_t mod2=274-240;
 275   Int_t mod3=327-240;
 276    Int_t mod4=453-240;
 277    //  Int_t mod4=497-240;
 278   Int_t lay1,lad1,det1;
 279   Int_t lay2,lad2,det2;
 280   Int_t lay3,lad3,det3;
 281   Int_t lay4,lad4,det4;
 282   AliITSgeomTGeo::GetModuleId(mod1+240,lay1,lad1,det1);
 283   AliITSgeomTGeo::GetModuleId(mod2+240,lay2,lad2,det2);
 284   AliITSgeomTGeo::GetModuleId(mod3+240,lay3,lad3,det3);
 285   AliITSgeomTGeo::GetModuleId(mod4+240,lay4,lad4,det4);
 286   Char_t filout[100];
 287   sprintf(filout,"DriftSpVsTime_%d.root",year);
 288   TFile *ofil=new TFile(filout,"recreate");
 289   for(Int_t iMod=0; iMod<260;iMod++){
 290     gvdrvstime[iMod]->Write();
 291     gvdrvsrun[iMod]->Write();
 292   }
 293   gGoodInjVsRun->Write();
 294   gGoodInjVsTime->Write();
 295   gAverSpeedVsRun->Write();
 296   gAverSpeedVsTime->Write();
 297   ofil->Close();
 298
 299   gStyle->SetOptTitle(0);
 300   TCanvas* c0=new TCanvas("c0","Vdrift vs. time");
 301   c0->SetGridx();
 302   c0->SetGridy();
 303   gvdrvstime[mod1]->SetMarkerStyle(20);
 304   gvdrvstime[mod2]->SetMarkerStyle(22);
 305   gvdrvstime[mod2]->SetMarkerColor(2);
 306   gvdrvstime[mod2]->SetLineColor(2);
 307   gvdrvstime[mod3]->SetMarkerStyle(29);
 308   gvdrvstime[mod3]->SetMarkerColor(3);
 309   gvdrvstime[mod3]->SetLineColor(3);
 310   gvdrvstime[mod4]->SetMarkerStyle(27);
 311   gvdrvstime[mod4]->SetMarkerColor(4);
 312   gvdrvstime[mod4]->SetLineColor(4);
 313   gvdrvstime[mod1]->Draw("AP");
 314   gvdrvstime[mod1]->SetMinimum(6.3);
 315   gvdrvstime[mod1]->SetMaximum(6.75);
 316   Char_t title[100];
 317   if(year==2009){
 318     sprintf(title,"Time (days since July 16th 2009)");
 319   }else if (year==2010){
 320     sprintf(title,"Time (days since January 1st 2010)");
 321   }else{
 322     sprintf(title,"Time (days since January 1st 2011)");
 323   }
 324   gvdrvstime[mod1]->GetXaxis()->SetTitle(title);
 325   gvdrvstime[mod1]->GetYaxis()->SetTitle("Drift speed (#mum/ns)");
 326   gvdrvstime[mod2]->Draw("PSAME");
 327   gvdrvstime[mod3]->Draw("PSAME");
 328   gvdrvstime[mod4]->Draw("PSAME");
 329   TLegend* leg=new TLegend(0.6,0.7,0.89,0.89);
 330   leg->SetBorderSize(0);
 331   leg->SetFillColor(0);
 332   leg->SetFillStyle(0);
 333   TLegendEntry* lent=leg->AddEntry(gvdrvstime[mod1],Form("Lay %d Lad %d Det %d",lay1,lad1,det1),"P");
 334   lent=leg->AddEntry(gvdrvstime[mod2],Form("Lay %d Lad %d Det %d",lay2,lad2,det2),"P");
 335   lent->SetTextColor(2);
 336   lent=leg->AddEntry(gvdrvstime[mod3],Form("Lay %d Lad %d Det %d",lay3,lad3,det3),"P");
 337   lent->SetTextColor(3);
 338   lent=leg->AddEntry(gvdrvstime[mod4],Form("Lay %d Lad %d Det %d",lay4,lad4,det4),"P");
 339   lent->SetTextColor(4);
 340   leg->Draw();
 341
 342   TCanvas* c1=new TCanvas("c1","Vdrift vs. run");
 343   c1->SetGridx();
 344   c1->SetGridy();
 345   gvdrvsrun[mod1]->SetMarkerStyle(20);
 346   gvdrvsrun[mod2]->SetMarkerStyle(22);
 347   gvdrvsrun[mod2]->SetMarkerColor(2);
 348   gvdrvsrun[mod2]->SetLineColor(2);
 349   gvdrvsrun[mod3]->SetMarkerStyle(29);
 350   gvdrvsrun[mod3]->SetMarkerColor(3);
 351   gvdrvsrun[mod3]->SetLineColor(3);
 352   gvdrvsrun[mod4]->SetMarkerStyle(27);
 353   gvdrvsrun[mod4]->SetMarkerColor(4);
 354   gvdrvsrun[mod4]->SetLineColor(4);
 355   gvdrvsrun[mod1]->Draw("AP");
 356   gvdrvsrun[mod1]->SetMinimum(6.3);
 357   gvdrvsrun[mod1]->SetMaximum(6.75);
 358
 359   gvdrvsrun[mod1]->GetXaxis()->SetTitle("Run number");
 360   gvdrvsrun[mod1]->GetYaxis()->SetTitle("Drift speed (#mum/ns)");
 361   gvdrvsrun[mod2]->Draw("PSAME");
 362   gvdrvsrun[mod3]->Draw("PSAME");
 363   gvdrvsrun[mod4]->Draw("PSAME");
 364   leg->Draw();
 365
 366
 367   TH2F* hlay3=new TH2F("hlay3","Variation of the drift speed (%) Layer 3",6,-0.5,5.5,14,-0.5,13.5);
 368   hlay3->GetXaxis()->SetTitle("Detector");
 369   hlay3->GetYaxis()->SetTitle("Ladder");
 370   hlay3->GetXaxis()->SetTickLength(0);
 371   hlay3->GetYaxis()->SetTickLength(0);
 372   hlay3->SetStats(0);
 373
 374   TH2F* hlay4=new TH2F("hlay4","Variation of the drift speed (%) Layer 4",8,-0.5,7.5,22,-0.5,21.5);
 375   hlay4->GetXaxis()->SetTitle("Detector");
 376   hlay4->GetYaxis()->SetTitle("Ladder");
 377   hlay4->GetXaxis()->SetTickLength(0);
 378   hlay4->GetYaxis()->SetTickLength(0);
 379   hlay4->GetYaxis()->SetTitle("Ladder");
 380   hlay4->SetStats(0);
 381
 382   Double_t run1,run2,vdr1,vdr2;
 383   Int_t lay,lad,det;
 384   for(Int_t iMod=0; iMod<260; iMod++){
 385     Int_t lastPoint=gvdrvsrun[iMod]->GetN()-1;
 386     gvdrvsrun[iMod]->GetPoint(lastPoint,run2,vdr2);
 387     gvdrvsrun[iMod]->GetPoint(lastPoint-1,run1,vdr1);
 388     Float_t diff=0.;
 389     if(vdr1>0.) diff=100*(vdr2-vdr1)/vdr1;
 390     AliITSgeomTGeo::GetModuleId(iMod+240,lay,lad,det);
 391     if(lay==3) hlay3->SetBinContent(det,lad,diff);
 392     if(lay==4) hlay4->SetBinContent(det,lad,diff);
 393   }
 394   TLine* lin=new TLine(0,0,0,23);
 395   gStyle->SetPalette(1);
 396
 397   TCanvas *c0b=new TCanvas("c0b","Percent difference Last Run - Previous Run",900,600);
 398   c0b->Divide(2,1);
 399   c0b->cd(1);
 400   hlay3->DrawCopy("colz");
 401   for(Int_t i=0;i<6;i++){
 402     lin->SetY1(-0.5);
 403     lin->SetY2(13.5);
 404     lin->SetX1(i+0.5);
 405     lin->SetX2(i+0.5);
 406     lin->DrawClone();
 407   }
 408   for(Int_t i=0;i<14;i++){
 409     lin->SetX1(-0.5);
 410     lin->SetX2(5.5);
 411     lin->SetY1(i+0.5);
 412     lin->SetY2(i+0.5);
 413     lin->DrawClone();
 414   }
 415   c0b->cd(2);
 416   hlay4->DrawCopy("colz");
 417   for(Int_t i=0;i<8;i++){
 418     lin->SetY1(-0.5);
 419     lin->SetY2(21.5);
 420     lin->SetX1(i+0.5);
 421     lin->SetX2(i+0.5);
 422     lin->DrawClone();
 423   }
 424   for(Int_t i=0;i<22;i++){
 425     lin->SetX1(-0.5);
 426     lin->SetX2(7.5);
 427     lin->SetY1(i+0.5);
 428     lin->SetY2(i+0.5);
 429     lin->DrawClone();
 430   }
 431
 432   TCanvas* c4=new TCanvas("c4","GoodMod vs. run");
 433   c4->SetGridx();
 434   c4->SetGridy();
 435   gGoodInjVsRun->SetMarkerStyle(20);
 436   gGoodInjVsRun->SetMinimum(50.);
 437   gGoodInjVsRun->SetMaximum(370.);
 438   gGoodInjVsRunL3->SetMarkerStyle(22);
 439   gGoodInjVsRunL3->SetMarkerColor(2);
 440   gGoodInjVsRunL3->SetLineColor(2);
 441   gGoodInjVsRunL4->SetMarkerStyle(23);
 442   gGoodInjVsRunL4->SetMarkerColor(4);
 443   gGoodInjVsRunL4->SetLineColor(4);
 444   gGoodInjVsRun->Draw("AP");
 445   gGoodInjVsRunL3->Draw("PSAME");
 446   gGoodInjVsRunL4->Draw("PSAME");
 447   gGoodInjVsRun->GetXaxis()->SetTitle("Run number");
 448   gGoodInjVsRun->GetYaxis()->SetTitle("Half-modules with drift speed from injectors");
 449   TLegend* leg2=new TLegend(0.6,0.3,0.89,0.5);
 450   leg2->SetBorderSize(0);
 451   leg2->SetFillColor(0);
 452   leg2->SetFillStyle(0);
 453   TLegendEntry* lent2=leg2->AddEntry(gGoodInjVsRun,"All","P");
 454   lent2->SetTextColor(1);
 455   lent2=leg2->AddEntry(gGoodInjVsRunL3,"Layer 3 ","P");
 456   lent2->SetTextColor(2);
 457   lent2=leg2->AddEntry(gGoodInjVsRunL4,"Layer 4","P");
 458   lent2->SetTextColor(4);
 459   leg2->Draw();
 460
 461
 462   TCanvas* c4bis=new TCanvas("c4bis"," Frac GoodMod vs. run");
 463   c4bis->SetGridx();
 464   c4bis->SetGridy();
 465   gFracGoodInjVsRun->SetMarkerStyle(20);
 466   gFracGoodInjVsRun->SetMinimum(0.);
 467   gFracGoodInjVsRun->SetMaximum(0.9);
 468   gFracGoodInjVsRunL3->SetMarkerStyle(22);
 469   gFracGoodInjVsRunL3->SetMarkerColor(2);
 470   gFracGoodInjVsRunL3->SetLineColor(2);
 471   gFracGoodInjVsRunL4->SetMarkerStyle(23);
 472   gFracGoodInjVsRunL4->SetMarkerColor(4);
 473   gFracGoodInjVsRunL4->SetLineColor(4);
 474   gFracGoodInjVsRun->Draw("AP");
 475   gFracGoodInjVsRunL3->Draw("PSAME");
 476   gFracGoodInjVsRunL4->Draw("PSAME");
 477   gFracGoodInjVsRun->GetXaxis()->SetTitle("Run number");
 478   gFracGoodInjVsRun->GetYaxis()->SetTitle("Fraction of Half-modules with drift speed from injectors");
 479   gFracGoodInjVsRun->GetYaxis()->SetTitleSize(0.03);
 480   gFracGoodInjVsRun->GetYaxis()->SetTitleOffset(1.5);
 481   leg2->Draw();
 482
 483   TCanvas* c5=new TCanvas("c5","GoodMod vs. time");
 484   c5->SetGridx();
 485   c5->SetGridy();
 486   gGoodInjVsTime->SetMarkerStyle(20);
 487   gGoodInjVsTime->SetMinimum(50.);
 488   gGoodInjVsTime->SetMaximum(370.);
 489   gGoodInjVsTimeL3->SetMarkerStyle(22);
 490   gGoodInjVsTimeL3->SetMarkerColor(2);
 491   gGoodInjVsTimeL3->SetLineColor(2);
 492   gGoodInjVsTimeL4->SetMarkerStyle(23);
 493   gGoodInjVsTimeL4->SetMarkerColor(4);
 494   gGoodInjVsTimeL4->SetLineColor(4);
 495   gGoodInjVsTime->Draw("AP");
 496   gGoodInjVsTimeL3->Draw("PSAME");
 497   gGoodInjVsTimeL4->Draw("PSAME");
 498   gGoodInjVsTime->GetXaxis()->SetTitle(title);
 499   gGoodInjVsTime->GetYaxis()->SetTitle("Half-modules with drift speed from injectors");
 500   leg2->Draw();
 501
 502   TCanvas* c5bis=new TCanvas("c5bis","Frac GoodMod vs. time");
 503   c5bis->SetGridx();
 504   c5bis->SetGridy();
 505   gFracGoodInjVsTime->SetMarkerStyle(20);
 506   gFracGoodInjVsTime->SetMinimum(0.);
 507   gFracGoodInjVsTime->SetMaximum(0.9);
 508   gFracGoodInjVsTimeL3->SetMarkerStyle(22);
 509   gFracGoodInjVsTimeL3->SetMarkerColor(2);
 510   gFracGoodInjVsTimeL3->SetLineColor(2);
 511   gFracGoodInjVsTimeL4->SetMarkerStyle(23);
 512   gFracGoodInjVsTimeL4->SetMarkerColor(4);
 513   gFracGoodInjVsTimeL4->SetLineColor(4);
 514   gFracGoodInjVsTime->Draw("AP");
 515   gFracGoodInjVsTimeL3->Draw("PSAME");
 516   gFracGoodInjVsTimeL4->Draw("PSAME");
 517   gFracGoodInjVsTime->GetXaxis()->SetTitle(title);
 518   gFracGoodInjVsTime->GetYaxis()->SetTitleSize(0.03);
 519   gFracGoodInjVsTime->GetYaxis()->SetTitleOffset(1.5);
 520   gFracGoodInjVsTime->GetYaxis()->SetTitle("Fraction of Half-modules with drift speed from injectors");
 521   leg2->Draw();
 522
 523 }
 524
 525 void FillErrors(Float_t errSpeed[260]){
 526   Float_t err[260]={
 527     0.002308,0.005120,0.004632,0.001000,0.001735,
 528     0.001000,0.001000,0.002667,0.004237,0.005297,
 529     0.001000,0.005460,0.005149,0.003921,0.001000,
 530     0.003906,0.001000,0.004871,0.001000,0.001000,
 531     0.001000,0.001000,0.002261,0.002986,0.002056,
 532     0.002848,0.001000,0.001777,0.002822,0.004651,
 533     0.001000,0.003551,0.006466,0.001000,0.002083,
 534     0.004531,0.001000,0.002213,0.001000,0.001000,
 535     0.001000,0.001000,0.001000,0.003223,0.002800,
 536     0.002147,0.001000,0.003364,0.001000,0.001000,
 537     0.002515,0.003229,0.002552,0.005765,0.002368,
 538     0.003473,0.002363,0.001000,0.003413,0.001000,
 539     0.004906,0.001000,0.004346,0.004887,0.007138,
 540     0.007242,0.004289,0.003970,0.002914,0.002199,
 541     0.001000,0.003483,0.002154,0.002914,0.003097,
 542     0.006034,0.003101,0.001000,0.002425,0.002651,
 543     0.002771,0.002409,0.002260,0.003109,0.001000,
 544     0.003384,0.003374,0.002212,0.004441,0.001000,
 545     0.001000,0.001000,0.003578,0.001000,0.001000,
 546     0.003517,0.003590,0.001787,0.003329,0.001000,
 547     0.002770,0.001000,0.004032,0.003059,0.001000,
 548     0.001000,0.001000,0.001000,0.001000,0.001000,
 549     0.001000,0.004556,0.001000,0.001000,0.001000,
 550     0.001000,0.001000,0.001000,0.004819,0.002100,
 551     0.002624,0.003784,0.003772,0.002483,0.002792,
 552     0.001000,0.004713,0.003214,0.003180,0.002145,
 553     0.002470,0.003078,0.001000,0.007131,0.002770,
 554     0.002533,0.001000,0.004362,0.002819,0.001000,
 555     0.003630,0.004215,0.002975,0.001000,0.003790,
 556     0.002345,0.001000,0.003999,0.004555,0.003989,
 557     0.001000,0.001000,0.001000,0.003136,0.002426,
 558     0.005144,0.002844,0.002310,0.002467,0.002503,
 559     0.003811,0.003440,0.004773,0.003114,0.001000,
 560     0.000583,0.001000,0.001000,0.003385,0.001000,
 561     0.001000,0.001000,0.001000,0.003108,0.002109,
 562     0.005325,0.003750,0.002810,0.003559,0.001000,
 563     0.001000,0.003262,0.003903,0.001000,0.003622,
 564     0.002533,0.002121,0.003733,0.005353,0.002221,
 565     0.004767,0.003267,0.004892,0.002152,0.003398,
 566     0.001000,0.003146,0.001000,0.002952,0.003310,
 567     0.002644,0.002573,0.001000,0.003989,0.001000,
 568     0.005294,0.003095,0.003479,0.002250,0.001000,
 569     0.001000,0.005221,0.001000,0.001653,0.004330,
 570     0.013188,0.007375,0.003226,0.003875,0.001000,
 571     0.003653,0.001000,0.002655,0.001000,0.001000,
 572     0.001000,0.001000,0.004718,0.001000,0.001000,
 573     0.001000,0.002780,0.003680,0.001000,0.002787,
 574     0.001000,0.004617,0.001000,0.001000,0.003231,
 575     0.001887,0.002090,0.003326,0.129970,0.004907,
 576     0.004334,0.001000,0.001000,0.003489,0.002573,
 577     0.002566,0.002982,0.001000,0.001000,0.003436,
 578     0.004016,0.003736,0.001784,0.004775,0.008090};
 579   for(Int_t i=0;i<260;i++) errSpeed[i]=err[i];
 580
 581
 582 }