[u/mrichter/AliRoot.git] / ITS / PlotDriftSpeedSDDVsTime.C

#if !defined(__CINT__) || defined(__MAKECINT__)
#include <Riostream.h>
#include <TFile.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TGraph.h>
#include <TStyle.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TLine.h>
#include <TSystem.h>
#include <TGrid.h>
#include <TMath.h>
#include <TGraphErrors.h>
#include <TCanvas.h>
#include <TLatex.h>
#include <TObjArray.h>
#include "AliCDBEntry.h"
#include "AliITSDriftSpeedArraySDD.h"
#include "AliITSgeomTGeo.h"
#endif

/*  $Id$    */


// Macro to plot the drift speed vs. time from the OCDB files 
// created from INJECTOR runs (OCDB/ITS/Calib/DriftSpeedSDD)
// Origin: F. Prino (prino@to.infn.it)

void FillErrors(Float_t errSpeed[260]);

void PlotDriftSpeedSDDVsTime(Int_t year=2010, Int_t firstRun=62840, 
			     Int_t lastRun=999999999,
			     Int_t anode=128){
  TGrid::Connect("alien:",0,0,"t");
  Float_t errSpeed[260];
  FillErrors(errSpeed);
  TString cmd=Form("gbbox find \"/alice/data/%d/OCDB/ITS/Calib/DriftSpeedSDD\" \"Run*.root\" > runSpeedAlien.txt",year);
  gSystem->Exec(cmd.Data());
  FILE* listruns=fopen("runSpeedAlien.txt","r");
  Char_t filnam[200],filnamalien[200];
  TGraphErrors** gvdrvstime=new TGraphErrors*[520];
  TGraphErrors** gvdrvsrun=new TGraphErrors*[520];
  TGraph* gGoodInjVsRun=new TGraph(0);
  gGoodInjVsRun->SetName("gGoodInjVsRun");
  TGraph* gAverSpeedVsRun=new TGraph(0);
  gAverSpeedVsRun->SetName("gAverSpeedVsRun");
  TGraph* gGoodInjVsTime=new TGraph(0);
  gGoodInjVsTime->SetName("gGoodInjVsTime");
  TGraph* gAverSpeedVsTime=new TGraph(0);
  gAverSpeedVsTime->SetName("gAverSpeedVsIime");
  
  for(Int_t iMod=0; iMod<260;iMod++){
    gvdrvstime[iMod]=new TGraphErrors(0);    
    gvdrvstime[iMod]->SetTitle(Form("Module %d",iMod+240));
    gvdrvstime[iMod]->SetName(Form("gspmod%dt",iMod+240));
    gvdrvsrun[iMod]=new TGraphErrors(0);    
    gvdrvsrun[iMod]->SetTitle(Form("Module %d",iMod+240));
    gvdrvsrun[iMod]->SetName(Form("gspmod%dr",iMod+240));
  }
  Float_t Edrift=(1800-45)/291/0.012;  
  Int_t nrun,nrun2,nv,ns;
  while(!feof(listruns)){
    fscanf(listruns,"%s\n",filnam);
    Char_t directory[100];
    sprintf(directory,"/alice/data/%d",year);
    if(!strstr(filnam,directory)) continue;
       sscanf(filnam,"/alice/data/%d/OCDB/ITS/Calib/DriftSpeedSDD/Run%d_%d_v%d_s%d.root",&year,&nrun,&nrun2,&nv,&ns);

       if(year==2009 && (nrun<85639 && nrun2> 85639)) continue;// protection for files with swapped ladders 4-5 of layer 3 
       if(year==2009 && (nrun>100000 && nv< 325)) continue; // protection for files with swapped ladder 0-1 of layer 4
  
    if(nrun<firstRun) continue;
    if(nrun>lastRun) continue;
    sprintf(filnamalien,"alien://%s",filnam);
    printf("Open file: %s\n",filnam);
    TFile *f= TFile::Open(filnamalien);
    AliCDBEntry *ent=(AliCDBEntry*)f->Get("AliCDBEntry");
    TObjArray *drspSDD = (TObjArray *)ent->GetObject();
    
    Int_t iGoodInj=0;
    Int_t iAverSpeed=0;
    Float_t timeday=0;
    
    AliITSDriftSpeedArraySDD *vdriftarr;
    AliITSDriftSpeedArraySDD *vdriftarr0;
    AliITSDriftSpeedArraySDD *vdriftarr1;

    for(Int_t iMod=0; iMod<260;iMod++){
      Int_t index=-1;
      if(anode<256) index=2*iMod;
      else index=2*iMod+1;
      vdriftarr=(AliITSDriftSpeedArraySDD*)drspSDD->At(index);
	  
      Int_t i0=2*iMod;
      Int_t i1=1+2*iMod;
      vdriftarr0=(AliITSDriftSpeedArraySDD*)drspSDD->At(i0);
      vdriftarr1=(AliITSDriftSpeedArraySDD*)drspSDD->At(i1);
	  
      Int_t statusInj0=vdriftarr0->GetInjectorStatus();
      Int_t statusInj1=vdriftarr1->GetInjectorStatus();
      if(statusInj0>0) iGoodInj++;
      else iAverSpeed++;
      if(statusInj1>0) iGoodInj++;
      else iAverSpeed++;
	  
      Int_t iAn=anode;
      if(anode>256) iAn=anode-256;
      Float_t vdrift=vdriftarr->GetDriftSpeed(0,iAn);
      if(vdrift<4. || vdrift > 8.) continue;
      UInt_t timest=vdriftarr->GetTimestamp(0);
      if(timest==0) continue;
      Int_t npt=gvdrvsrun[iMod]->GetN();
      gvdrvsrun[iMod]->SetPoint(npt,(Float_t)nrun,vdrift);
      gvdrvsrun[iMod]->SetPointError(npt,0,errSpeed[iMod]);
      
      Float_t timeZero;
      if(year==2009) timeZero=1247762992;
      else timeZero=1262300400;
      if(timest<timeZero) continue;
      timeday=float(timest-timeZero)/60./60./24.;
      Float_t mob=vdrift*1.E5/Edrift;  
      Float_t temper=293.15*TMath::Power((mob/1350.),-1/2.4); 
      if(iMod==497-240) printf("Run %s   Time %d Day %f Speed=%f Temp=%f\n",filnam,timest,timeday,vdrift,temper);
      npt=gvdrvstime[iMod]->GetN();
      gvdrvstime[iMod]->SetPoint(npt,timeday,vdrift);
      gvdrvstime[iMod]->SetPointError(npt,0,errSpeed[iMod]);
    }
    Int_t npt=gGoodInjVsRun->GetN();
    gGoodInjVsRun->SetPoint(npt,(Float_t)nrun,iGoodInj);
    gAverSpeedVsRun->SetPoint(npt,(Float_t)nrun,iAverSpeed);
	
    npt=gGoodInjVsTime->GetN();
    gGoodInjVsTime->SetPoint(npt,timeday,iGoodInj);
    gAverSpeedVsTime->SetPoint(npt,timeday,iAverSpeed);
	
    printf("Number of half-modules with drift speed from injectors = %d\n",iGoodInj);
    printf("Number of half-modules with average drift speed        = %d\n",iAverSpeed);
	f->Close();
  }

  Int_t mod1=244-240;
  Int_t mod2=277-240;
//   Int_t mod1=268-240;
//   Int_t mod2=274-240;
  Int_t mod3=327-240;
   Int_t mod4=453-240;
   //  Int_t mod4=497-240;
  Int_t lay1,lad1,det1;
  Int_t lay2,lad2,det2;
  Int_t lay3,lad3,det3;
  Int_t lay4,lad4,det4;
  AliITSgeomTGeo::GetModuleId(mod1+240,lay1,lad1,det1);
  AliITSgeomTGeo::GetModuleId(mod2+240,lay2,lad2,det2);
  AliITSgeomTGeo::GetModuleId(mod3+240,lay3,lad3,det3);
  AliITSgeomTGeo::GetModuleId(mod4+240,lay4,lad4,det4);
  Char_t filout[100];
  sprintf(filout,"DriftSpVsTime_%d.root",year);
  TFile *ofil=new TFile(filout,"recreate");
  for(Int_t iMod=0; iMod<260;iMod++){
    gvdrvstime[iMod]->Write();
    gvdrvsrun[iMod]->Write();
  }
  gGoodInjVsRun->Write();
  gGoodInjVsTime->Write();
  gAverSpeedVsRun->Write();
  gAverSpeedVsTime->Write();
  ofil->Close();

  gStyle->SetOptTitle(0);
  TCanvas* c0=new TCanvas("c0","Vdrift vs. time");
  c0->SetGridx();
  c0->SetGridy();
  gvdrvstime[mod1]->SetMarkerStyle(20);
  gvdrvstime[mod2]->SetMarkerStyle(22);
  gvdrvstime[mod2]->SetMarkerColor(2);
  gvdrvstime[mod2]->SetLineColor(2);
  gvdrvstime[mod3]->SetMarkerStyle(29);
  gvdrvstime[mod3]->SetMarkerColor(3);
  gvdrvstime[mod3]->SetLineColor(3);
  gvdrvstime[mod4]->SetMarkerStyle(27);
  gvdrvstime[mod4]->SetMarkerColor(4);
  gvdrvstime[mod4]->SetLineColor(4);
  gvdrvstime[mod1]->Draw("AP");
  gvdrvstime[mod1]->SetMinimum(6.3);
  gvdrvstime[mod1]->SetMaximum(6.75);
  Char_t title[100];
  if(year==2009){
  sprintf(title,"Time (days since July 16th 2009)");
  }else if (year==2010){
  sprintf(title,"Time (days since January 1st 2010)");
  }
  gvdrvstime[mod1]->GetXaxis()->SetTitle(title);
  gvdrvstime[mod1]->GetYaxis()->SetTitle("Drift speed (#mum/ns)");
  gvdrvstime[mod2]->Draw("PSAME");
  gvdrvstime[mod3]->Draw("PSAME");
  gvdrvstime[mod4]->Draw("PSAME");
  TLegend* leg=new TLegend(0.6,0.7,0.89,0.89);
  leg->SetBorderSize(0);
  leg->SetFillColor(0);
  leg->SetFillStyle(0);
  TLegendEntry* lent=leg->AddEntry(gvdrvstime[mod1],Form("Lay %d Lad %d Det %d",lay1,lad1,det1),"P");
  lent=leg->AddEntry(gvdrvstime[mod2],Form("Lay %d Lad %d Det %d",lay2,lad2,det2),"P");
  lent->SetTextColor(2);
  lent=leg->AddEntry(gvdrvstime[mod3],Form("Lay %d Lad %d Det %d",lay3,lad3,det3),"P");
  lent->SetTextColor(3);
  lent=leg->AddEntry(gvdrvstime[mod4],Form("Lay %d Lad %d Det %d",lay4,lad4,det4),"P");
  lent->SetTextColor(4);
  leg->Draw();

  TCanvas* c1=new TCanvas("c1","Vdrift vs. run");
  c1->SetGridx();
  c1->SetGridy();
  gvdrvsrun[mod1]->SetMarkerStyle(20);
  gvdrvsrun[mod2]->SetMarkerStyle(22);
  gvdrvsrun[mod2]->SetMarkerColor(2);
  gvdrvsrun[mod2]->SetLineColor(2);
  gvdrvsrun[mod3]->SetMarkerStyle(29);
  gvdrvsrun[mod3]->SetMarkerColor(3);
  gvdrvsrun[mod3]->SetLineColor(3);
  gvdrvsrun[mod4]->SetMarkerStyle(27);
  gvdrvsrun[mod4]->SetMarkerColor(4);
  gvdrvsrun[mod4]->SetLineColor(4);
  gvdrvsrun[mod1]->Draw("AP");
  gvdrvsrun[mod1]->SetMinimum(6.3);
  gvdrvsrun[mod1]->SetMaximum(6.75);

  gvdrvsrun[mod1]->GetXaxis()->SetTitle("Run number");
  gvdrvsrun[mod1]->GetYaxis()->SetTitle("Drift speed (#mum/ns)");
  gvdrvsrun[mod2]->Draw("PSAME");
  gvdrvsrun[mod3]->Draw("PSAME");
  gvdrvsrun[mod4]->Draw("PSAME");
  leg->Draw();


  TH2F* hlay3=new TH2F("hlay3","Variation of the drift speed (%) Layer 3",6,-0.5,5.5,14,-0.5,13.5);
  hlay3->GetXaxis()->SetTitle("Detector");
  hlay3->GetYaxis()->SetTitle("Ladder");
  hlay3->GetXaxis()->SetTickLength(0);
  hlay3->GetYaxis()->SetTickLength(0);
  hlay3->SetStats(0);

  TH2F* hlay4=new TH2F("hlay4","Variation of the drift speed (%) Layer 4",8,-0.5,7.5,22,-0.5,21.5);
  hlay4->GetXaxis()->SetTitle("Detector");
  hlay4->GetYaxis()->SetTitle("Ladder");
  hlay4->GetXaxis()->SetTickLength(0);
  hlay4->GetYaxis()->SetTickLength(0);
  hlay4->GetYaxis()->SetTitle("Ladder");
  hlay4->SetStats(0);

  Double_t run1,run2,vdr1,vdr2;
  Int_t lay,lad,det;
  for(Int_t iMod=0; iMod<260; iMod++){
    Int_t lastPoint=gvdrvsrun[iMod]->GetN()-1;
    gvdrvsrun[iMod]->GetPoint(lastPoint,run2,vdr2);
    gvdrvsrun[iMod]->GetPoint(lastPoint-1,run1,vdr1);
    Float_t diff=0.;
    if(vdr1>0.) diff=100*(vdr2-vdr1)/vdr1;
    AliITSgeomTGeo::GetModuleId(iMod+240,lay,lad,det);
    if(lay==3) hlay3->SetBinContent(det,lad,diff);
    if(lay==4) hlay4->SetBinContent(det,lad,diff);
  }
  TLine* lin=new TLine(0,0,0,23);  
  gStyle->SetPalette(1);

  TCanvas *c0b=new TCanvas("c0b","Percent difference Last Run - Previous Run",900,600);
  c0b->Divide(2,1);
  c0b->cd(1);
  hlay3->DrawCopy("colz");
  for(Int_t i=0;i<6;i++){
    lin->SetY1(-0.5);
    lin->SetY2(13.5);
    lin->SetX1(i+0.5);
    lin->SetX2(i+0.5);
    lin->DrawClone();
  }
  for(Int_t i=0;i<14;i++){
    lin->SetX1(-0.5);
    lin->SetX2(5.5);
    lin->SetY1(i+0.5);
    lin->SetY2(i+0.5);
    lin->DrawClone();
  }
  c0b->cd(2);
  hlay4->DrawCopy("colz");
  for(Int_t i=0;i<8;i++){
    lin->SetY1(-0.5);
    lin->SetY2(21.5);
    lin->SetX1(i+0.5);
    lin->SetX2(i+0.5);
    lin->DrawClone();
  }
  for(Int_t i=0;i<22;i++){
    lin->SetX1(-0.5);
    lin->SetX2(7.5);
    lin->SetY1(i+0.5);
    lin->SetY2(i+0.5);
    lin->DrawClone();
  }

  TCanvas* c4=new TCanvas("c4","GoodMod vs. run");
  c4->SetGridx();
  c4->SetGridy();
  gGoodInjVsRun->SetMarkerStyle(20);
  gGoodInjVsRun->SetMarkerColor(2);
  gGoodInjVsRun->GetXaxis()->SetTitle("Run number");
  gGoodInjVsRun->GetYaxis()->SetTitle("Half-modules with drift speed from injectors");
  gGoodInjVsRun->Draw("AP");
  
  TCanvas* c5=new TCanvas("c5","GoodMod vs. time");
  c5->SetGridx();
  c5->SetGridy();
  gGoodInjVsTime->SetMarkerStyle(20);
  gGoodInjVsTime->SetMarkerColor(2);
  gGoodInjVsTime->GetXaxis()->SetTitle(title);
  gGoodInjVsTime->GetYaxis()->SetTitle("Half-modules with drift speed from injectors");
  gGoodInjVsTime->Draw("AP");
}

void FillErrors(Float_t errSpeed[260]){
  Float_t err[260]={
    0.002308,0.005120,0.004632,0.001000,0.001735,
    0.001000,0.001000,0.002667,0.004237,0.005297,
    0.001000,0.005460,0.005149,0.003921,0.001000,
    0.003906,0.001000,0.004871,0.001000,0.001000,
    0.001000,0.001000,0.002261,0.002986,0.002056,
    0.002848,0.001000,0.001777,0.002822,0.004651,
    0.001000,0.003551,0.006466,0.001000,0.002083,
    0.004531,0.001000,0.002213,0.001000,0.001000,
    0.001000,0.001000,0.001000,0.003223,0.002800,
    0.002147,0.001000,0.003364,0.001000,0.001000,
    0.002515,0.003229,0.002552,0.005765,0.002368,
    0.003473,0.002363,0.001000,0.003413,0.001000,
    0.004906,0.001000,0.004346,0.004887,0.007138,
    0.007242,0.004289,0.003970,0.002914,0.002199,
    0.001000,0.003483,0.002154,0.002914,0.003097,
    0.006034,0.003101,0.001000,0.002425,0.002651,
    0.002771,0.002409,0.002260,0.003109,0.001000,
    0.003384,0.003374,0.002212,0.004441,0.001000,
    0.001000,0.001000,0.003578,0.001000,0.001000,
    0.003517,0.003590,0.001787,0.003329,0.001000,
    0.002770,0.001000,0.004032,0.003059,0.001000,
    0.001000,0.001000,0.001000,0.001000,0.001000,
    0.001000,0.004556,0.001000,0.001000,0.001000,
    0.001000,0.001000,0.001000,0.004819,0.002100,
    0.002624,0.003784,0.003772,0.002483,0.002792,
    0.001000,0.004713,0.003214,0.003180,0.002145,
    0.002470,0.003078,0.001000,0.007131,0.002770,
    0.002533,0.001000,0.004362,0.002819,0.001000,
    0.003630,0.004215,0.002975,0.001000,0.003790,
    0.002345,0.001000,0.003999,0.004555,0.003989,
    0.001000,0.001000,0.001000,0.003136,0.002426,
    0.005144,0.002844,0.002310,0.002467,0.002503,
    0.003811,0.003440,0.004773,0.003114,0.001000,
    0.000583,0.001000,0.001000,0.003385,0.001000,
    0.001000,0.001000,0.001000,0.003108,0.002109,
    0.005325,0.003750,0.002810,0.003559,0.001000,
    0.001000,0.003262,0.003903,0.001000,0.003622,
    0.002533,0.002121,0.003733,0.005353,0.002221,
    0.004767,0.003267,0.004892,0.002152,0.003398,
    0.001000,0.003146,0.001000,0.002952,0.003310,
    0.002644,0.002573,0.001000,0.003989,0.001000,
    0.005294,0.003095,0.003479,0.002250,0.001000,
    0.001000,0.005221,0.001000,0.001653,0.004330,
    0.013188,0.007375,0.003226,0.003875,0.001000,
    0.003653,0.001000,0.002655,0.001000,0.001000,
    0.001000,0.001000,0.004718,0.001000,0.001000,
    0.001000,0.002780,0.003680,0.001000,0.002787,
    0.001000,0.004617,0.001000,0.001000,0.003231,
    0.001887,0.002090,0.003326,0.129970,0.004907,
    0.004334,0.001000,0.001000,0.003489,0.002573,
    0.002566,0.002982,0.001000,0.001000,0.003436,
    0.004016,0.003736,0.001784,0.004775,0.008090};
  for(Int_t i=0;i<260;i++) errSpeed[i]=err[i];
  
  
}
Commit	Line	Data
8d024204	1	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
78018435	2	#include <Riostream.h>
8d024204	3	#include <TFile.h>
8d024204	4	#include <TH1F.h>
de18f32b	5	#include <TH2F.h>
8d024204	6	#include <TGraph.h>
	7	#include <TStyle.h>
	8	#include <TLegend.h>
	9	#include <TLegendEntry.h>
de18f32b	10	#include <TLine.h>
8d024204	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$ */
	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
672154f3	32	void PlotDriftSpeedSDDVsTime(Int_t year=2010, Int_t firstRun=62840,
78018435	33	Int_t lastRun=999999999,
8d024204	34	Int_t anode=128){
8d024204	35	TGrid::Connect("alien:",0,0,"t");
8d024204	36	Float_t errSpeed[260];
8d024204	37	FillErrors(errSpeed);
78018435	38	TString cmd=Form("gbbox find \"/alice/data/%d/OCDB/ITS/Calib/DriftSpeedSDD\" \"Run*.root\" > runSpeedAlien.txt",year);
78018435	39	gSystem->Exec(cmd.Data());
8d024204	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];
55d5b638	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
8d024204	53	for(Int_t iMod=0; iMod<260;iMod++){
	54	gvdrvstime[iMod]=new TGraphErrors(0);
	55	gvdrvstime[iMod]->SetTitle(Form("Module %d",iMod+240));
	56	gvdrvstime[iMod]->SetName(Form("gspmod%dt",iMod+240));
	57	gvdrvsrun[iMod]=new TGraphErrors(0);
	58	gvdrvsrun[iMod]->SetTitle(Form("Module %d",iMod+240));
	59	gvdrvsrun[iMod]->SetName(Form("gspmod%dr",iMod+240));
8d024204	60	}
8d024204	61	Float_t Edrift=(1800-45)/291/0.012;
9c3758ab	62	Int_t nrun,nrun2,nv,ns;
8d024204	63	while(!feof(listruns)){
8d024204	64	fscanf(listruns,"%s\n",filnam);
78018435	65	Char_t directory[100];
	66	sprintf(directory,"/alice/data/%d",year);
	67	if(!strstr(filnam,directory)) continue;
	68	sscanf(filnam,"/alice/data/%d/OCDB/ITS/Calib/DriftSpeedSDD/Run%d_%d_v%d_s%d.root",&year,&nrun,&nrun2,&nv,&ns);
	69
	70	if(year==2009 && (nrun<85639 && nrun2> 85639)) continue;// protection for files with swapped ladders 4-5 of layer 3
2420973e	71	if(year==2009 && (nrun>100000 && nv< 325)) continue; // protection for files with swapped ladder 0-1 of layer 4
78018435	72
8d024204	73	if(nrun<firstRun) continue;
	74	if(nrun>lastRun) continue;
	75	sprintf(filnamalien,"alien://%s",filnam);
	76	printf("Open file: %s\n",filnam);
	77	TFile *f= TFile::Open(filnamalien);
	78	AliCDBEntry ent=(AliCDBEntry)f->Get("AliCDBEntry");
	79	TObjArray drspSDD = (TObjArray )ent->GetObject();
	80
55d5b638	81	Int_t iGoodInj=0;
	82	Int_t iAverSpeed=0;
	83	Float_t timeday=0;
	84
8d024204	85	AliITSDriftSpeedArraySDD *vdriftarr;
55d5b638	86	AliITSDriftSpeedArraySDD *vdriftarr0;
	87	AliITSDriftSpeedArraySDD *vdriftarr1;
	88
8d024204	89	for(Int_t iMod=0; iMod<260;iMod++){
	90	Int_t index=-1;
	91	if(anode<256) index=2*iMod;
	92	else index=2*iMod+1;
	93	vdriftarr=(AliITSDriftSpeedArraySDD*)drspSDD->At(index);
55d5b638	94
	95	Int_t i0=2*iMod;
	96	Int_t i1=1+2*iMod;
	97	vdriftarr0=(AliITSDriftSpeedArraySDD*)drspSDD->At(i0);
	98	vdriftarr1=(AliITSDriftSpeedArraySDD*)drspSDD->At(i1);
	99
	100	Int_t statusInj0=vdriftarr0->GetInjectorStatus();
	101	Int_t statusInj1=vdriftarr1->GetInjectorStatus();
	102	if(statusInj0>0) iGoodInj++;
	103	else iAverSpeed++;
	104	if(statusInj1>0) iGoodInj++;
	105	else iAverSpeed++;
	106
8d024204	107	Int_t iAn=anode;
	108	if(anode>256) iAn=anode-256;
	109	Float_t vdrift=vdriftarr->GetDriftSpeed(0,iAn);
672154f3	110	if(vdrift<4. \|\| vdrift > 8.) continue;
8d024204	111	UInt_t timest=vdriftarr->GetTimestamp(0);
672154f3	112	if(timest==0) continue;
017c17a3	113	Int_t npt=gvdrvsrun[iMod]->GetN();
	114	gvdrvsrun[iMod]->SetPoint(npt,(Float_t)nrun,vdrift);
	115	gvdrvsrun[iMod]->SetPointError(npt,0,errSpeed[iMod]);
	116
	117	Float_t timeZero;
	118	if(year==2009) timeZero=1247762992;
	119	else timeZero=1262300400;
	120	if(timest<timeZero) continue;
55d5b638	121	timeday=float(timest-timeZero)/60./60./24.;
8d024204	122	Float_t mob=vdrift*1.E5/Edrift;
	123	Float_t temper=293.15*TMath::Power((mob/1350.),-1/2.4);
	124	if(iMod==497-240) printf("Run %s Time %d Day %f Speed=%f Temp=%f\n",filnam,timest,timeday,vdrift,temper);
017c17a3	125	npt=gvdrvstime[iMod]->GetN();
	126	gvdrvstime[iMod]->SetPoint(npt,timeday,vdrift);
	127	gvdrvstime[iMod]->SetPointError(npt,0,errSpeed[iMod]);
8d024204	128	}
55d5b638	129	Int_t npt=gGoodInjVsRun->GetN();
	130	gGoodInjVsRun->SetPoint(npt,(Float_t)nrun,iGoodInj);
	131	gAverSpeedVsRun->SetPoint(npt,(Float_t)nrun,iAverSpeed);
	132
	133	npt=gGoodInjVsTime->GetN();
	134	gGoodInjVsTime->SetPoint(npt,timeday,iGoodInj);
	135	gAverSpeedVsTime->SetPoint(npt,timeday,iAverSpeed);
	136
	137	printf("Number of half-modules with drift speed from injectors = %d\n",iGoodInj);
	138	printf("Number of half-modules with average drift speed = %d\n",iAverSpeed);
	139	f->Close();
8d024204	140	}
	141
	142	Int_t mod1=244-240;
	143	Int_t mod2=277-240;
78018435	144	// Int_t mod1=268-240;
78018435	145	// Int_t mod2=274-240;
8d024204	146	Int_t mod3=327-240;
78018435	147	Int_t mod4=453-240;
78018435	148	// Int_t mod4=497-240;
8d024204	149	Int_t lay1,lad1,det1;
	150	Int_t lay2,lad2,det2;
	151	Int_t lay3,lad3,det3;
	152	Int_t lay4,lad4,det4;
	153	AliITSgeomTGeo::GetModuleId(mod1+240,lay1,lad1,det1);
	154	AliITSgeomTGeo::GetModuleId(mod2+240,lay2,lad2,det2);
	155	AliITSgeomTGeo::GetModuleId(mod3+240,lay3,lad3,det3);
	156	AliITSgeomTGeo::GetModuleId(mod4+240,lay4,lad4,det4);
78018435	157	Char_t filout[100];
	158	sprintf(filout,"DriftSpVsTime_%d.root",year);
	159	TFile *ofil=new TFile(filout,"recreate");
8d024204	160	for(Int_t iMod=0; iMod<260;iMod++){
	161	gvdrvstime[iMod]->Write();
	162	gvdrvsrun[iMod]->Write();
	163	}
55d5b638	164	gGoodInjVsRun->Write();
	165	gGoodInjVsTime->Write();
	166	gAverSpeedVsRun->Write();
	167	gAverSpeedVsTime->Write();
8d024204	168	ofil->Close();
	169
	170	gStyle->SetOptTitle(0);
55d5b638	171	TCanvas* c0=new TCanvas("c0","Vdrift vs. time");
8d024204	172	c0->SetGridx();
	173	c0->SetGridy();
	174	gvdrvstime[mod1]->SetMarkerStyle(20);
	175	gvdrvstime[mod2]->SetMarkerStyle(22);
	176	gvdrvstime[mod2]->SetMarkerColor(2);
	177	gvdrvstime[mod2]->SetLineColor(2);
	178	gvdrvstime[mod3]->SetMarkerStyle(29);
	179	gvdrvstime[mod3]->SetMarkerColor(3);
	180	gvdrvstime[mod3]->SetLineColor(3);
	181	gvdrvstime[mod4]->SetMarkerStyle(27);
	182	gvdrvstime[mod4]->SetMarkerColor(4);
	183	gvdrvstime[mod4]->SetLineColor(4);
	184	gvdrvstime[mod1]->Draw("AP");
	185	gvdrvstime[mod1]->SetMinimum(6.3);
	186	gvdrvstime[mod1]->SetMaximum(6.75);
78018435	187	Char_t title[100];
	188	if(year==2009){
	189	sprintf(title,"Time (days since July 16th 2009)");
	190	}else if (year==2010){
017c17a3	191	sprintf(title,"Time (days since January 1st 2010)");
78018435	192	}
78018435	193	gvdrvstime[mod1]->GetXaxis()->SetTitle(title);
8d024204	194	gvdrvstime[mod1]->GetYaxis()->SetTitle("Drift speed (#mum/ns)");
	195	gvdrvstime[mod2]->Draw("PSAME");
	196	gvdrvstime[mod3]->Draw("PSAME");
	197	gvdrvstime[mod4]->Draw("PSAME");
	198	TLegend* leg=new TLegend(0.6,0.7,0.89,0.89);
	199	leg->SetBorderSize(0);
	200	leg->SetFillColor(0);
	201	leg->SetFillStyle(0);
	202	TLegendEntry* lent=leg->AddEntry(gvdrvstime[mod1],Form("Lay %d Lad %d Det %d",lay1,lad1,det1),"P");
	203	lent=leg->AddEntry(gvdrvstime[mod2],Form("Lay %d Lad %d Det %d",lay2,lad2,det2),"P");
	204	lent->SetTextColor(2);
	205	lent=leg->AddEntry(gvdrvstime[mod3],Form("Lay %d Lad %d Det %d",lay3,lad3,det3),"P");
	206	lent->SetTextColor(3);
	207	lent=leg->AddEntry(gvdrvstime[mod4],Form("Lay %d Lad %d Det %d",lay4,lad4,det4),"P");
	208	lent->SetTextColor(4);
	209	leg->Draw();
	210
55d5b638	211	TCanvas* c1=new TCanvas("c1","Vdrift vs. run");
8d024204	212	c1->SetGridx();
	213	c1->SetGridy();
	214	gvdrvsrun[mod1]->SetMarkerStyle(20);
	215	gvdrvsrun[mod2]->SetMarkerStyle(22);
	216	gvdrvsrun[mod2]->SetMarkerColor(2);
	217	gvdrvsrun[mod2]->SetLineColor(2);
	218	gvdrvsrun[mod3]->SetMarkerStyle(29);
	219	gvdrvsrun[mod3]->SetMarkerColor(3);
	220	gvdrvsrun[mod3]->SetLineColor(3);
	221	gvdrvsrun[mod4]->SetMarkerStyle(27);
	222	gvdrvsrun[mod4]->SetMarkerColor(4);
	223	gvdrvsrun[mod4]->SetLineColor(4);
	224	gvdrvsrun[mod1]->Draw("AP");
	225	gvdrvsrun[mod1]->SetMinimum(6.3);
	226	gvdrvsrun[mod1]->SetMaximum(6.75);
	227
	228	gvdrvsrun[mod1]->GetXaxis()->SetTitle("Run number");
	229	gvdrvsrun[mod1]->GetYaxis()->SetTitle("Drift speed (#mum/ns)");
	230	gvdrvsrun[mod2]->Draw("PSAME");
	231	gvdrvsrun[mod3]->Draw("PSAME");
	232	gvdrvsrun[mod4]->Draw("PSAME");
	233	leg->Draw();
194bd524	234
	235
	236	TH2F* hlay3=new TH2F("hlay3","Variation of the drift speed (%) Layer 3",6,-0.5,5.5,14,-0.5,13.5);
	237	hlay3->GetXaxis()->SetTitle("Detector");
	238	hlay3->GetYaxis()->SetTitle("Ladder");
	239	hlay3->GetXaxis()->SetTickLength(0);
	240	hlay3->GetYaxis()->SetTickLength(0);
	241	hlay3->SetStats(0);
	242
	243	TH2F* hlay4=new TH2F("hlay4","Variation of the drift speed (%) Layer 4",8,-0.5,7.5,22,-0.5,21.5);
	244	hlay4->GetXaxis()->SetTitle("Detector");
	245	hlay4->GetYaxis()->SetTitle("Ladder");
	246	hlay4->GetXaxis()->SetTickLength(0);
	247	hlay4->GetYaxis()->SetTickLength(0);
	248	hlay4->GetYaxis()->SetTitle("Ladder");
	249	hlay4->SetStats(0);
	250
	251	Double_t run1,run2,vdr1,vdr2;
	252	Int_t lay,lad,det;
	253	for(Int_t iMod=0; iMod<260; iMod++){
	254	Int_t lastPoint=gvdrvsrun[iMod]->GetN()-1;
	255	gvdrvsrun[iMod]->GetPoint(lastPoint,run2,vdr2);
	256	gvdrvsrun[iMod]->GetPoint(lastPoint-1,run1,vdr1);
	257	Float_t diff=0.;
	258	if(vdr1>0.) diff=100*(vdr2-vdr1)/vdr1;
	259	AliITSgeomTGeo::GetModuleId(iMod+240,lay,lad,det);
	260	if(lay==3) hlay3->SetBinContent(det,lad,diff);
	261	if(lay==4) hlay4->SetBinContent(det,lad,diff);
	262	}
	263	TLine* lin=new TLine(0,0,0,23);
	264	gStyle->SetPalette(1);
	265
	266	TCanvas *c0b=new TCanvas("c0b","Percent difference Last Run - Previous Run",900,600);
	267	c0b->Divide(2,1);
	268	c0b->cd(1);
	269	hlay3->DrawCopy("colz");
	270	for(Int_t i=0;i<6;i++){
	271	lin->SetY1(-0.5);
	272	lin->SetY2(13.5);
	273	lin->SetX1(i+0.5);
	274	lin->SetX2(i+0.5);
	275	lin->DrawClone();
	276	}
	277	for(Int_t i=0;i<14;i++){
	278	lin->SetX1(-0.5);
	279	lin->SetX2(5.5);
	280	lin->SetY1(i+0.5);
	281	lin->SetY2(i+0.5);
	282	lin->DrawClone();
	283	}
	284	c0b->cd(2);
	285	hlay4->DrawCopy("colz");
	286	for(Int_t i=0;i<8;i++){
	287	lin->SetY1(-0.5);
	288	lin->SetY2(21.5);
	289	lin->SetX1(i+0.5);
	290	lin->SetX2(i+0.5);
	291	lin->DrawClone();
	292	}
	293	for(Int_t i=0;i<22;i++){
	294	lin->SetX1(-0.5);
	295	lin->SetX2(7.5);
	296	lin->SetY1(i+0.5);
	297	lin->SetY2(i+0.5);
298	lin->DrawClone();
299	}
55d5b638	300
	301	TCanvas* c4=new TCanvas("c4","GoodMod vs. run");
	302	c4->SetGridx();
	303	c4->SetGridy();
	304	gGoodInjVsRun->SetMarkerStyle(20);
	305	gGoodInjVsRun->SetMarkerColor(2);
	306	gGoodInjVsRun->GetXaxis()->SetTitle("Run number");
	307	gGoodInjVsRun->GetYaxis()->SetTitle("Half-modules with drift speed from injectors");
	308	gGoodInjVsRun->Draw("AP");
194bd524	309
55d5b638	310	TCanvas* c5=new TCanvas("c5","GoodMod vs. time");
	311	c5->SetGridx();
	312	c5->SetGridy();
	313	gGoodInjVsTime->SetMarkerStyle(20);
	314	gGoodInjVsTime->SetMarkerColor(2);
	315	gGoodInjVsTime->GetXaxis()->SetTitle(title);
	316	gGoodInjVsTime->GetYaxis()->SetTitle("Half-modules with drift speed from injectors");
	317	gGoodInjVsTime->Draw("AP");
8d024204	318	}
	319
	320	void FillErrors(Float_t errSpeed[260]){
	321	Float_t err[260]={
	322	0.002308,0.005120,0.004632,0.001000,0.001735,
	323	0.001000,0.001000,0.002667,0.004237,0.005297,
	324	0.001000,0.005460,0.005149,0.003921,0.001000,
	325	0.003906,0.001000,0.004871,0.001000,0.001000,
	326	0.001000,0.001000,0.002261,0.002986,0.002056,
	327	0.002848,0.001000,0.001777,0.002822,0.004651,
	328	0.001000,0.003551,0.006466,0.001000,0.002083,
	329	0.004531,0.001000,0.002213,0.001000,0.001000,
	330	0.001000,0.001000,0.001000,0.003223,0.002800,
	331	0.002147,0.001000,0.003364,0.001000,0.001000,
	332	0.002515,0.003229,0.002552,0.005765,0.002368,
	333	0.003473,0.002363,0.001000,0.003413,0.001000,
	334	0.004906,0.001000,0.004346,0.004887,0.007138,
	335	0.007242,0.004289,0.003970,0.002914,0.002199,
	336	0.001000,0.003483,0.002154,0.002914,0.003097,
	337	0.006034,0.003101,0.001000,0.002425,0.002651,
	338	0.002771,0.002409,0.002260,0.003109,0.001000,
	339	0.003384,0.003374,0.002212,0.004441,0.001000,
	340	0.001000,0.001000,0.003578,0.001000,0.001000,
	341	0.003517,0.003590,0.001787,0.003329,0.001000,
	342	0.002770,0.001000,0.004032,0.003059,0.001000,
	343	0.001000,0.001000,0.001000,0.001000,0.001000,
	344	0.001000,0.004556,0.001000,0.001000,0.001000,
	345	0.001000,0.001000,0.001000,0.004819,0.002100,
	346	0.002624,0.003784,0.003772,0.002483,0.002792,
	347	0.001000,0.004713,0.003214,0.003180,0.002145,
	348	0.002470,0.003078,0.001000,0.007131,0.002770,
	349	0.002533,0.001000,0.004362,0.002819,0.001000,
	350	0.003630,0.004215,0.002975,0.001000,0.003790,
	351	0.002345,0.001000,0.003999,0.004555,0.003989,
	352	0.001000,0.001000,0.001000,0.003136,0.002426,
	353	0.005144,0.002844,0.002310,0.002467,0.002503,
	354	0.003811,0.003440,0.004773,0.003114,0.001000,
	355	0.000583,0.001000,0.001000,0.003385,0.001000,
	356	0.001000,0.001000,0.001000,0.003108,0.002109,
	357	0.005325,0.003750,0.002810,0.003559,0.001000,
	358	0.001000,0.003262,0.003903,0.001000,0.003622,
	359	0.002533,0.002121,0.003733,0.005353,0.002221,
	360	0.004767,0.003267,0.004892,0.002152,0.003398,
	361	0.001000,0.003146,0.001000,0.002952,0.003310,
	362	0.002644,0.002573,0.001000,0.003989,0.001000,
	363	0.005294,0.003095,0.003479,0.002250,0.001000,
	364	0.001000,0.005221,0.001000,0.001653,0.004330,
	365	0.013188,0.007375,0.003226,0.003875,0.001000,
	366	0.003653,0.001000,0.002655,0.001000,0.001000,
	367	0.001000,0.001000,0.004718,0.001000,0.001000,
	368	0.001000,0.002780,0.003680,0.001000,0.002787,
	369	0.001000,0.004617,0.001000,0.001000,0.003231,
	370	0.001887,0.002090,0.003326,0.129970,0.004907,
	371	0.004334,0.001000,0.001000,0.003489,0.002573,
	372	0.002566,0.002982,0.001000,0.001000,0.003436,
	373	0.004016,0.003736,0.001784,0.004775,0.008090};
	374	for(Int_t i=0;i<260;i++) errSpeed[i]=err[i];
	375
	376
	377	}