Updates in SDD drift speed calculation from injector runs (F. Prino)

diff --git a/ITS/AliITSDriftSpeedArraySDD.h b/ITS/AliITSDriftSpeedArraySDD.h
index dbe75f0e08a9e58942ed996fa17230d7526ca950..4ebfca476c8a766fede81e7259e36eab5f1959d1 100644 (file)
--- a/ITS/AliITSDriftSpeedArraySDD.h
+++ b/ITS/AliITSDriftSpeedArraySDD.h
@@ -31,7 +31,11 @@ class AliITSDriftSpeedArraySDD : public TObject{
   UInt_t GetTimestamp(Int_t iElement);
   UInt_t GetInjectorStatus() const {return fInjectorStatus;}
   Double_t GetDriftSpeed(Int_t iEvent, Double_t iAnode);
-  
+  AliITSDriftSpeedSDD* GetDriftSpeedObject(Int_t iEvent) const{
+    if(iEvent>=0 && iEvent<fNEvents) return (AliITSDriftSpeedSDD*)fDriftSpeedSDD.At(iEvent);
+    else return 0;
+  }
+
  protected:  
   Int_t fNEvents;               // number of drift speed determination
   TObjArray fDriftSpeedSDD; // array of AliITSDriftSpeedSDD objects

diff --git a/ITS/AliITSDriftSpeedSDD.h b/ITS/AliITSDriftSpeedSDD.h
index 93973ba25821c9fd143a26969792059a0062b480..96d1cfc78b67ea436a05ed3f1d0a2dfb014deffb 100644 (file)
--- a/ITS/AliITSDriftSpeedSDD.h
+++ b/ITS/AliITSDriftSpeedSDD.h
@@ -35,6 +35,7 @@ class AliITSDriftSpeedSDD : public TObject {
 
   void PrintDriftSpeedParameters() const;
 
+  Int_t GetDegreeofPoly() const {return fPolDeg;}
   Int_t GetEventNumber() const {return fEvNum;}
   UInt_t GetEventTimestamp() const {return fTimestamp;}
   Float_t GetDriftSpeedParameter(Int_t i) const {return fDriftSpeedParam[i];}

diff --git a/ITS/AliITSOnlineSDDInjectors.cxx b/ITS/AliITSOnlineSDDInjectors.cxx
index 00a855729b0090f9af7f96b1e5da8e7a72cc5688..763af5fb143b10b0e26404382e31698fdaaf9671 100644 (file)
--- a/ITS/AliITSOnlineSDDInjectors.cxx
+++ b/ITS/AliITSOnlineSDDInjectors.cxx
@@ -16,6 +16,7 @@
 #include "AliITSOnlineSDDInjectors.h"
 #include "AliLog.h"
 #include <TH2F.h>
+#include <TF1.h>
 #include <TGraphErrors.h>
 #include <TMath.h>
 
@@ -36,13 +37,13 @@ const Float_t AliITSOnlineSDDInjectors::fgkDefaultHThreshold = 25.;
 const Float_t AliITSOnlineSDDInjectors::fgkDefaultMinSpeed = 5.5;
 const Float_t AliITSOnlineSDDInjectors::fgkDefaultMaxSpeed = 9.0;
 const Float_t AliITSOnlineSDDInjectors::fgkDefaultMaxErr = 1.5;
-const Int_t   AliITSOnlineSDDInjectors::fgkDefaultPolOrder = 3;
+const Int_t   AliITSOnlineSDDInjectors::fgkDefaultPolDegree = 3;
 const Float_t AliITSOnlineSDDInjectors::fgkDefaultTimeStep = 50.;
 const UShort_t AliITSOnlineSDDInjectors::fgkDefaultTbMin[kInjLines] = {10,50,100};
 const UShort_t AliITSOnlineSDDInjectors::fgkDefaultTbMax[kInjLines] = {20,70,120};
 
 //______________________________________________________________________
-AliITSOnlineSDDInjectors::AliITSOnlineSDDInjectors():AliITSOnlineSDD(),fHisto(),fTbZero(0.),fRMSTbZero(0.),fNEvents(0),fParam(),fPolOrder(0),fMinDriftSpeed(0.),fMaxDriftSpeed(0.),fMaxDriftSpeedErr(0.),fLowThreshold(0.),fHighThreshold(0.),fFirstPadForFit(0),fLastPadForFit(0),fPadStatusCutForFit(0),fTimeStep(0.),fUseTimeZeroSignal(kFALSE)
+AliITSOnlineSDDInjectors::AliITSOnlineSDDInjectors():AliITSOnlineSDD(),fHisto(),fTbZero(0.),fRMSTbZero(0.),fNEvents(0),fParam(),fPolDegree(0),fActualPolDegree(0),fMinDriftSpeed(0.),fMaxDriftSpeed(0.),fMaxDriftSpeedErr(0.),fLowThreshold(0.),fHighThreshold(0.),fFirstPadForFit(0),fLastPadForFit(0),fPadStatusCutForFit(0),fTimeStep(0.),fUseTimeZeroSignal(kFALSE)
 {
   // default constructor
   SetPositions();
@@ -50,7 +51,7 @@ AliITSOnlineSDDInjectors::AliITSOnlineSDDInjectors():AliITSOnlineSDD(),fHisto(),
   SetTimeStep(fgkDefaultTimeStep);
 }
 //______________________________________________________________________
-AliITSOnlineSDDInjectors::AliITSOnlineSDDInjectors(Int_t nddl, Int_t ncarlos, Int_t sid):AliITSOnlineSDD(nddl,ncarlos,sid),fHisto(),fTbZero(0.),fRMSTbZero(0.),fNEvents(0),fParam(),fPolOrder(0),fMinDriftSpeed(0.),fMaxDriftSpeed(0.),fMaxDriftSpeedErr(0.),fLowThreshold(0.),fHighThreshold(0.),fFirstPadForFit(0),fLastPadForFit(0),fPadStatusCutForFit(0),fTimeStep(0.),fUseTimeZeroSignal(kFALSE)
+AliITSOnlineSDDInjectors::AliITSOnlineSDDInjectors(Int_t nddl, Int_t ncarlos, Int_t sid):AliITSOnlineSDD(nddl,ncarlos,sid),fHisto(),fTbZero(0.),fRMSTbZero(0.),fNEvents(0),fParam(),fPolDegree(0),fActualPolDegree(0),fMinDriftSpeed(0.),fMaxDriftSpeed(0.),fMaxDriftSpeedErr(0.),fLowThreshold(0.),fHighThreshold(0.),fFirstPadForFit(0),fLastPadForFit(0),fPadStatusCutForFit(0),fTimeStep(0.),fUseTimeZeroSignal(kFALSE)
 { 
 // standard constructor
   SetPositions();
@@ -72,7 +73,7 @@ void AliITSOnlineSDDInjectors::SetDefaults(){
     SetUseLine(i,kTRUE);
   }
   SetThresholds(fgkDefaultLThreshold,fgkDefaultHThreshold);
-  SetPolOrder(fgkDefaultPolOrder);
+  SetPolDegree(fgkDefaultPolDegree);
   SetMinDriftSpeed(fgkDefaultMinSpeed);
   SetMaxDriftSpeed(fgkDefaultMaxSpeed);
   SetMaxDriftSpeedErr(fgkDefaultMaxErr);
@@ -233,10 +234,81 @@ void AliITSOnlineSDDInjectors::CalcTimeBinZero(){
   }
   if(nTbUsed==1) fRMSTbZero=0.5; 
 }
+
 //______________________________________________________________________
 void AliITSOnlineSDDInjectors::FitDriftSpeedVsAnode(){
   // fits the anode dependence of drift speed with a polynomial function
-  const Int_t kNn=fPolOrder+1;
+
+  TGraphErrors *fitGraph=new TGraphErrors(0);
+  Int_t npts = 0;
+  for(Int_t jpad=fFirstPadForFit; jpad<=fLastPadForFit; jpad++){
+    if(fDriftSpeed[jpad]>0. && GetInjPadStatus(jpad)>fPadStatusCutForFit){
+      
+      Double_t x=(Double_t)GetAnodeNumber(jpad);
+      fitGraph->SetPoint(npts,x,fDriftSpeed[jpad]);
+      fitGraph->SetPointError(npts,0.,fDriftSpeedErr[jpad]);
+      ++npts;
+    }
+  }
+  
+
+  const Int_t kNn=fPolDegree+1;
+  TString funcName=Form("pol%d",fPolDegree);
+  TF1* fitFunc=new TF1("fitFunc",funcName.Data(),0.,256.);
+  if(fParam) delete [] fParam;
+  fParam=new Double_t[kNn];
+  for(Int_t i=0; i<kNn;i++){ 
+    fitFunc->SetParameter(i,0.);  
+    fParam[i]=0.;
+  }
+  Float_t rangeForMax[2]={78.,178.};
+  if(fitGraph->GetN()>fPolDegree+1){ 
+    fitGraph->Fit("fitFunc","RQN");
+    for(Int_t i=0; i<kNn;i++)fParam[i]=fitFunc->GetParameter(i);
+    fActualPolDegree=fPolDegree;
+    if(fPolDegree==3){
+      Double_t deltasq=fitFunc->GetParameter(2)*fitFunc->GetParameter(2)-3*fitFunc->GetParameter(1)*fitFunc->GetParameter(3);
+      Double_t zero1=-999.;
+      Double_t zero2=-999.;
+      if(deltasq>=0. && TMath::Abs(fitFunc->GetParameter(3))>0.){
+       Double_t delta=TMath::Sqrt(deltasq);
+       zero1=(-fitFunc->GetParameter(2)+delta)/3./fitFunc->GetParameter(3);
+       zero2=(-fitFunc->GetParameter(2)-delta)/3./fitFunc->GetParameter(3);
+      }
+      Bool_t twoZeroes=kFALSE;
+      Bool_t oneZero=kFALSE;
+      if(zero1>0. && zero1<256. && zero2>0. && zero2<256.) twoZeroes=kTRUE;
+      if(zero1>rangeForMax[0] && zero1<rangeForMax[1]) oneZero=kTRUE;
+      if(zero2>rangeForMax[0] && zero2<rangeForMax[1]) oneZero=kTRUE;
+      if(!oneZero || twoZeroes){
+       TF1* parabola=new TF1("parabola","pol2",0.,256.);
+       fitGraph->Fit("parabola","RQN");        
+       fParam[3]=0.;
+       Double_t xmax=-999.;
+       if(parabola->GetParameter(2)<0.) xmax=-parabola->GetParameter(1)/2./parabola->GetParameter(2);
+       if(xmax>rangeForMax[0] && xmax<rangeForMax[1]){
+         for(Int_t i2=0; i2<3;i2++)fParam[i2]=parabola->GetParameter(i2);
+         fActualPolDegree=2;
+       }else{
+         TF1* constval=new TF1("constval","pol0",0.,256.);       
+         fitGraph->Fit("constval","RQN");
+         fParam[2]=0.;
+         fParam[1]=0.;
+         fParam[0]=constval->GetParameter(0);
+         fActualPolDegree=0;
+         delete constval;
+       }
+       delete parabola;
+      }
+    }
+  }
+  delete fitFunc;  
+  delete fitGraph;
+}
+//______________________________________________________________________
+void AliITSOnlineSDDInjectors::FitDriftSpeedVsAnodeOld(){
+  // fits the anode dependence of drift speed with a polynomial function
+  const Int_t kNn=fPolDegree+1;
   Double_t **mat = new Double_t*[kNn];
   for(Int_t i=0; i < kNn; i++) mat[i] = new Double_t[kNn];
   Double_t *vect = new Double_t[kNn];
@@ -260,7 +332,7 @@ void AliITSOnlineSDDInjectors::FitDriftSpeedVsAnode(){
       }
     }
   }
-  if(npts<fPolOrder+1){ 
+  if(npts<fPolDegree+1){ 
     if(fParam) delete [] fParam;
     fParam=new Double_t[kNn];
     for(Int_t i=0; i<kNn;i++)fParam[i]=0;
@@ -520,11 +592,11 @@ void AliITSOnlineSDDInjectors::WriteToASCII(Int_t evNumb, UInt_t timeStamp, Int_
   FILE* outf;
   if(optAppend==0){ 
     outf=fopen(outfilnam,"w");
-    fprintf(outf,"%d\n",fPolOrder);
+    fprintf(outf,"%d\n",fActualPolDegree);
   }
   else outf=fopen(outfilnam,"a");
   fprintf(outf,"%d   %d   ",evNumb,timeStamp);
-  for(Int_t ic=0;ic<fPolOrder+1;ic++){
+  for(Int_t ic=0;ic<fPolDegree+1;ic++){
     fprintf(outf,"%G ",fParam[ic]);
   }
   fprintf(outf,"\n");

diff --git a/ITS/AliITSOnlineSDDInjectors.h b/ITS/AliITSOnlineSDDInjectors.h
index 3769fb28496d5bfeda8c5598270a56166156a42f..f21246ec4732041d455af9efde570a0bad95dc7b 100644 (file)
--- a/ITS/AliITSOnlineSDDInjectors.h
+++ b/ITS/AliITSOnlineSDDInjectors.h
@@ -45,7 +45,7 @@ class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {
     SetInjLineRange(2,170,240);
     SetTimeStep(25.);
   }
-  void SetPolOrder(Int_t n){fPolOrder=n;}
+  void SetPolDegree(Int_t n){fPolDegree=n;}
   void SetMinDriftSpeed(Float_t vmin){fMinDriftSpeed=vmin;}
   void SetMaxDriftSpeed(Float_t vmax){fMaxDriftSpeed=vmax;}
   void SetMaxDriftSpeedErr(Float_t maxval){
@@ -55,7 +55,7 @@ class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {
     fFirstPadForFit=firstpad;
     fLastPadForFit=lastpad;
   }
-  void SetPadStatusCutForFit(Int_t cutval=1){
+  void SetPadStatusCutForFit(Int_t cutval=4){
     fPadStatusCutForFit=cutval;
   }
   void SetDefaults();
@@ -107,6 +107,7 @@ class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {
   void CalcDriftSpeed(Int_t jpad);
   void CalcTimeBinZero();
   void FitDriftSpeedVsAnode();
+  void FitDriftSpeedVsAnodeOld();
   Double_t GetMeanDriftSpeed(Int_t ipad) const{
     if(fNEvents==0) return 0.;
     return fSumDriftSpeed[ipad]/(Double_t)fNEvents;
@@ -129,7 +130,7 @@ class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {
   static const Float_t fgkDefaultMinSpeed;   // Default for fMinDriftSpeed
   static const Float_t fgkDefaultMaxSpeed;   // Default for fMaxDriftSpeed
   static const Float_t fgkDefaultMaxErr;     // Default for fMaxDriftSpeedErr
-  static const Int_t   fgkDefaultPolOrder;   // Default for fPolOrder
+  static const Int_t   fgkDefaultPolDegree;   // Default for fPolDegree
   static const Float_t fgkDefaultTimeStep;   // Default for fTimeStep
   static const UShort_t   fgkDefaultTbMin[kInjLines];  // Defaults for fTbMin
   static const UShort_t   fgkDefaultTbMax[kInjLines];  // Defaults for fTbMax
@@ -152,7 +153,8 @@ class AliITSOnlineSDDInjectors : public AliITSOnlineSDD {
   
   Double_t *fParam;                           // parameters of polinomial fit to
                                              // drift speed vs. anode number
-  Int_t fPolOrder;                   // order of polinomial fit
+  Int_t fPolDegree;                   // Degree of polynomial fit
+  Int_t fActualPolDegree;             // Degree actually used (<=fPolDegree)
   Float_t fMinDriftSpeed;            // Minimum value for drift speed
   Float_t fMaxDriftSpeed;            // Maximum value for drift speed
   Float_t fMaxDriftSpeedErr;         // Maximum value for error on drift speed

diff --git a/ITS/AliITSPreprocessorSDD.cxx b/ITS/AliITSPreprocessorSDD.cxx
index 1c81b3295c5bcd83146738dad433f20924120369..4f1616aca85f06f172445c0807b8cf1dbdc3fa45 100644 (file)
--- a/ITS/AliITSPreprocessorSDD.cxx
+++ b/ITS/AliITSPreprocessorSDD.cxx
@@ -227,8 +227,8 @@ UInt_t AliITSPreprocessorSDD::ProcessInjector(AliITSDDLModuleMapSDD* ddlmap){
   Double_t nPtLay4 = 0;
 
   Double_t param[4];    // parameters of poly fit
-  Double_t minValP0=4.; // min value for param[0]
-  Double_t maxValP0=9.; // max value for param[0]
+  Double_t minValP0=5.; // min value for param[0]
+  Double_t maxValP0=8.; // max value for param[0]
   Double_t minValP1=0.; // min value for param[1]
   Double_t aveCoefLay3[4]={0.,0.,0.,0.};  // average param for good mod.
   Double_t aveCoefLay4[4]={0.,0.,0.,0.};  // average param for good mod.
@@ -284,16 +284,20 @@ UInt_t AliITSPreprocessorSDD::ProcessInjector(AliITSDDLModuleMapSDD* ddlmap){
            }
 
            if(param[0]>minValP0 && param[0]<maxValP0 && param[1]>minValP1){
-             if(modID<kNumberOfSDDLay3){ 
-               for(Int_t ic=0;ic<4;ic++) aveCoefLay3[ic]+=param[ic];
-               nPtLay3++;
-             }else{ 
-               for(Int_t ic=0;ic<4;ic++) aveCoefLay4[ic]+=param[ic];
-               nPtLay4++;
+             if(polDeg==3){
+               if(modID<kNumberOfSDDLay3){ 
+                 for(Int_t ic=0;ic<4;ic++) aveCoefLay3[ic]+=param[ic];
+                 nPtLay3++;
+               }else{ 
+                 for(Int_t ic=0;ic<4;ic++) aveCoefLay4[ic]+=param[ic];
+                 nPtLay4++;
+               }
              }
              AliITSDriftSpeedSDD *dsp=new AliITSDriftSpeedSDD(evNumb,timeStamp,polDeg,param);
              arr->AddDriftSpeed(dsp);
              modSet[2*modID+isid]=1;
+           }else{
+             Log(Form("Module %d side %d not accepted, degree=%d, params=%g %g %g %g",modID+240,isid,polDeg,param[0],param[1],param[2],param[3]));
            }
          }
        }

diff --git a/ITS/ShowDriftSpeedSDD.C b/ITS/ShowDriftSpeedSDD.C
index 6b5f1ee60eedab19741bccc140b18b5e80cfd94f..f25d1f69f75e152d977b78f0ae8b234f190d156d 100644 (file)
--- a/ITS/ShowDriftSpeedSDD.C
+++ b/ITS/ShowDriftSpeedSDD.C
@@ -36,23 +36,58 @@ void ShowDriftSpeedSDD(Char_t filnam[150]="$ALICE_ROOT/ITS/Calib/DriftSpeedSDD/R
 
   TGraph *vvsmod0=new TGraph(0);
   TGraph *vvsmod1=new TGraph(0);
+  TGraph *poldegvsmod0=new TGraph(0); 
+  TGraph *poldegvsmod1=new TGraph(0); 
+  TGraph *anmaxvsmod0=new TGraph(0); 
+  TGraph *anmaxvsmod1=new TGraph(0); 
+  TGraph *dvcevsmod0=new TGraph(0);
+  TGraph *dvcevsmod1=new TGraph(0);
+  TGraph *dveevsmod0=new TGraph(0);
+  TGraph *dveevsmod1=new TGraph(0);
+
   char tit0[100];
   sprintf(tit0,"Drift Speed vs. mod. number");
   if(nrun!=0)sprintf(tit0,"Drift Speed vs. mod. number - Run %d",nrun);
   vvsmod0->SetTitle(tit0);
   vvsmod1->SetTitle(tit0);
+
+  sprintf(tit0,"Degree of poly fit vs. mod. number");
+  if(nrun!=0)sprintf(tit0,"Degree of poly fit vs. mod. number - Run %d",nrun);
+  poldegvsmod0->SetTitle(tit0);
+  poldegvsmod1->SetTitle(tit0);
+
+  sprintf(tit0,"Anode with max. vdrift vs. mod. number");
+  if(nrun!=0)sprintf(tit0,"Anode with max. vdrift vs. mod. number - Run %d",nrun);
+  anmaxvsmod0->SetTitle(tit0);
+  anmaxvsmod1->SetTitle(tit0);
+
+  sprintf(tit0,"Delta Vdrift 128-0 vs. mod. number");
+  if(nrun!=0)sprintf(tit0,"Delta Vdrift 128-0 vs. mod. number - Run %d",nrun);
+  dvcevsmod0->SetTitle(tit0);
+  dvcevsmod1->SetTitle(tit0);
+
+  sprintf(tit0,"Delta Vdrift 256-0 vs. mod. number");
+  if(nrun!=0)sprintf(tit0,"Delta Vdrift 256-0 vs. mod. number - Run %d",nrun);
+  dveevsmod0->SetTitle(tit0);
+  dveevsmod1->SetTitle(tit0);
+
+  TF1* fPoly=new TF1("fPoly","[0]+[1]*x+[2]*x*x+[3]*x*x*x",0.,256.);
   Char_t tit[100];
+  Int_t iGoodInj=0;
+  Int_t iAverSpeed=0;
   for(Int_t i=firstmod; i<lastmod; i++){
     Int_t iMod=i+240;
     if(!kNoDraw){
-      c0->Clear();
-      c0->Divide(2,1);
     }
     Int_t i0=2*i;
     Int_t i1=1+2*i;
     vdriftarr0=(AliITSDriftSpeedArraySDD*)drspSDD->At(i0);
     vdriftarr1=(AliITSDriftSpeedArraySDD*)drspSDD->At(i1);
-    
+    AliITSDriftSpeedSDD* vdrift0=0x0;
+    if(vdriftarr0) vdrift0=vdriftarr0->GetDriftSpeedObject(0);
+    AliITSDriftSpeedSDD* vdrift1=0x0;
+    if(vdriftarr1) vdrift1=vdriftarr1->GetDriftSpeedObject(0);
+
     gvdr0[i]=new TGraph(0);
     gvdr1[i]=new TGraph(0);
     gvdr0[i]->SetMarkerStyle(7);
@@ -67,34 +102,74 @@ void ShowDriftSpeedSDD(Char_t filnam[150]="$ALICE_ROOT/ITS/Calib/DriftSpeedSDD/R
 
     for(Int_t iAn=0; iAn<256; iAn++){
       Float_t vel0=0;
-      if(vdriftarr0) vel0=vdriftarr0->GetDriftSpeed(1,iAn);
+      if(vdrift0) vel0=vdrift0->GetDriftSpeedAtAnode(iAn);
       Float_t vel1=0;
-      if(vdriftarr1) vel1=vdriftarr1->GetDriftSpeed(1,iAn);
+      if(vdrift1) vel1=vdrift1->GetDriftSpeedAtAnode(iAn);
       gvdr0[i]->SetPoint(iAn,(Float_t)iAn,vel0);
       gvdr1[i]->SetPoint(iAn,(Float_t)iAn,vel1);
     }
+    if(vdriftarr0->GetInjectorStatus()>0) iGoodInj++;
+    else iAverSpeed++;
+    if(vdriftarr1->GetInjectorStatus()>0) iGoodInj++;
+    else iAverSpeed++;
+
     printf(" Mod. %d \tStatusLR=%X %X \t v(an 128l)= %f",iMod,vdriftarr0->GetInjectorStatus(),vdriftarr1->GetInjectorStatus(),vdriftarr0->GetDriftSpeed(0,128));
-    printf("        \t v(an 128r)= %f\n",vdriftarr1->GetDriftSpeed(0,128));
-    if(!kNoDraw){
-      c0->cd(1);
-      gvdr0[i]->Draw("AP");
-      gvdr0[i]->GetXaxis()->SetTitle("Anode");
-      gvdr0[i]->GetYaxis()->SetTitle("Vdrift (#mum/ns)");
-      c0->cd(2);
-      gvdr1[i]->Draw("AP");
-      gvdr1[i]->GetXaxis()->SetTitle("Anode");
-      gvdr1[i]->GetYaxis()->SetTitle("Vdrift (#mum/ns)");
-      c0->Update();
-    }
+    printf("        \t v(an 128r)= %f  Degree=%d %d\n",vdriftarr1->GetDriftSpeed(0,128),vdrift0->GetDegreeofPoly(),vdrift1->GetDegreeofPoly());
+    c0->Clear();
+    c0->Divide(2,1);
+    c0->cd(1);
+    gvdr0[i]->Draw("AP");
+    gvdr0[i]->GetXaxis()->SetTitle("Anode");
+    gvdr0[i]->GetYaxis()->SetTitle("Vdrift (#mum/ns)");
+    c0->cd(2);
+    gvdr1[i]->Draw("AP");
+    gvdr1[i]->GetXaxis()->SetTitle("Anode");
+    gvdr1[i]->GetYaxis()->SetTitle("Vdrift (#mum/ns)");
+    c0->Update();
+    
     Float_t vel0=0;
-    if(vdriftarr0) vel0=vdriftarr0->GetDriftSpeed(0,128);
+    Float_t pd0=0;
+    if(vdrift0){ 
+      vel0=vdrift0->GetDriftSpeedAtAnode(128);
+      pd0=vdrift0->GetDegreeofPoly();
+    }
     Float_t vel1=0;
-    if(vdriftarr1) vel1=vdriftarr1->GetDriftSpeed(0,128);
+    Float_t pd1=0;
+    if(vdrift1){ 
+      vel1=vdrift1->GetDriftSpeedAtAnode(128);
+      pd1=vdrift1->GetDegreeofPoly();
+    }
     vvsmod0->SetPoint(vvsmod0->GetN(),(Float_t)iMod,vel0);
     vvsmod1->SetPoint(vvsmod1->GetN(),(Float_t)iMod,vel1);
+    poldegvsmod0->SetPoint(poldegvsmod0->GetN(),(Float_t)iMod,pd0);
+    poldegvsmod1->SetPoint(poldegvsmod1->GetN(),(Float_t)iMod,pd1);
+
+    for(Int_t ipar=0; ipar<=vdrift0->GetDegreeofPoly(); ipar++){
+      fPoly->SetParameter(ipar,vdrift0->GetDriftSpeedParameter(ipar));
+    }
+    if(vdrift0->GetDegreeofPoly()<3){
+      for(Int_t ipar=vdrift0->GetDegreeofPoly()+1; ipar<=3; ipar++) fPoly->SetParameter(ipar,0.);
+    }
+
+    anmaxvsmod0->SetPoint(anmaxvsmod0->GetN(),(Float_t)iMod,fPoly->GetMaximumX(0.,256.));
+    dvcevsmod0->SetPoint(dvcevsmod0->GetN(),(Float_t)iMod,fPoly->Eval(128)-fPoly->Eval(0));
+    dveevsmod0->SetPoint(dveevsmod0->GetN(),(Float_t)iMod,fPoly->Eval(256)-fPoly->Eval(0));
     
+    for(Int_t ipar=0; ipar<=vdrift1->GetDegreeofPoly(); ipar++){
+      fPoly->SetParameter(ipar,vdrift1->GetDriftSpeedParameter(ipar));
+    }
+    if(vdrift1->GetDegreeofPoly()<3){
+      for(Int_t ipar=vdrift1->GetDegreeofPoly()+1; ipar<=3; ipar++) fPoly->SetParameter(ipar,0.);
+    }
+    anmaxvsmod1->SetPoint(anmaxvsmod1->GetN(),(Float_t)iMod,fPoly->GetMaximumX(0.,256.));
+    dvcevsmod1->SetPoint(dvcevsmod1->GetN(),(Float_t)iMod,fPoly->Eval(128)-fPoly->Eval(0));
+    dveevsmod1->SetPoint(dveevsmod1->GetN(),(Float_t)iMod,fPoly->Eval(256)-fPoly->Eval(0));
     //    getchar();
   }
+
+  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);
+
   TCanvas* c2;
   c2=new TCanvas("c2","",1000,700);
   vvsmod0->SetMarkerStyle(20);
@@ -113,6 +188,60 @@ void ShowDriftSpeedSDD(Char_t filnam[150]="$ALICE_ROOT/ITS/Calib/DriftSpeedSDD/R
   tright->SetTextColor(2);
   tright->Draw();
 
+  TCanvas* c3;
+  c3=new TCanvas("c3","",900,900);
+  c3->Divide(2,2);
+  
+  c3->cd(1);
+  gPad->SetLeftMargin(0.14);
+  poldegvsmod0->SetMarkerStyle(20);
+  poldegvsmod0->Draw("AP");
+  poldegvsmod0->GetXaxis()->SetTitle("Module Number");
+  poldegvsmod0->GetYaxis()->SetTitle("Degree of Polynomial fit");
+  poldegvsmod0->GetYaxis()->SetTitleOffset(1.4);
+  poldegvsmod1->SetMarkerStyle(21);
+  poldegvsmod1->SetMarkerColor(2);
+  poldegvsmod1->Draw("SAMEP");
+  tleft->Draw();
+  tright->Draw();
+  c3->cd(2);
+  gPad->SetLeftMargin(0.14);
+  anmaxvsmod0->SetMarkerStyle(20);
+  anmaxvsmod0->Draw("AP");
+  anmaxvsmod0->GetXaxis()->SetTitle("Module Number");
+  anmaxvsmod0->GetYaxis()->SetTitle("Anode with max. drift speed");
+  anmaxvsmod0->GetYaxis()->SetTitleOffset(1.4);
+  anmaxvsmod1->SetMarkerStyle(21);
+  anmaxvsmod1->SetMarkerColor(2);
+  anmaxvsmod1->Draw("SAMEP");
+  tleft->Draw();
+  tright->Draw();
+  c3->cd(3);
+  gPad->SetLeftMargin(0.14);
+  dvcevsmod0->SetMarkerStyle(20);
+  dvcevsmod0->Draw("AP");
+  dvcevsmod0->GetXaxis()->SetTitle("Module Number");
+  dvcevsmod0->GetYaxis()->SetTitle("vdrift(anode128)-vdrift(anode0)");
+  dvcevsmod0->GetYaxis()->SetTitleOffset(1.4);
+  dvcevsmod1->SetMarkerStyle(21);
+  dvcevsmod1->SetMarkerColor(2);
+  dvcevsmod1->Draw("SAMEP");
+  tleft->Draw();
+  tright->Draw();
+  c3->cd(4);
+  gPad->SetLeftMargin(0.14);
+  dveevsmod0->SetMarkerStyle(20);
+  dveevsmod0->Draw("AP");
+  dveevsmod0->GetYaxis()->SetTitleOffset(1.4);
+  dveevsmod0->GetXaxis()->SetTitle("Module Number");
+  dveevsmod0->GetYaxis()->SetTitle("vdrift(anode256)-vdrift(anode0)");
+  dveevsmod1->SetMarkerStyle(21);
+  dveevsmod1->SetMarkerColor(2);
+  dveevsmod1->Draw("SAMEP");
+  tleft->Draw();
+  tright->Draw();
+
+  
 }