AliDebug instead of AliInfo
[u/mrichter/AliRoot.git] / TRD / AliTRDQADataMakerRec.cxx
index ba26e0b465fb8d8d449eeef9a4accf8a50c4dcc9..5c10634c38bcbd70a50b296fc3563ace99bc80be 100644 (file)
@@ -88,61 +88,160 @@ void AliTRDQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX task, TObjArray *
   //
   // Detector specific actions at end of cycle
   //
-
-  //AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task));
-
+  //TStopwatch watch;
+  //watch.Start();
+  
+  AliInfo("End of TRD cycle");
+  
   if (task == AliQA::kRECPOINTS) {
-
+    
+    TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
     //list->Print();
     
+    // fill detector map;
+    for(int i=0; i<540; i++) {
+      Double_t v = ((TH1D*)list->At(0))->GetBinContent(i+1);
+      Int_t sm = i/30;
+      Int_t det = i%30;
+
+      TH2D *detMap = (TH2D*)list->At(87);
+      Int_t bin = detMap->FindBin(sm, det);
+      detMap->SetBinContent(bin, v);
+    }
+
+
     // Rec points full chambers
-    if (((TH2D*)list->At(1))->GetEntries() > 1e4) {
-      for (Int_t i=0; i<540; i++) {
-       
-       TH1D *h = ((TH2D*)list->At(1))->ProjectionY(Form("qaTRD_recPoints_amp_%d",i), i+1, i+1);
-       if (h->GetSum() < 100) continue; // chamber not present
-       
-       h->Fit("landau", "q0", "goff", 10, 180);
-       TF1 *fit = h->GetFunction("landau");
-       ((TH1D*)list->At(12))->Fill(fit->GetParameter(1));
-       ((TH1D*)list->At(13))->Fill(fit->GetParameter(2));
-       delete h;      
+    for (Int_t i=0; i<540; i++) {
+      
+      //AliInfo(Form("I = %d", i));
+
+      //TH1D *h = ((TH2D*)list->At(1))->ProjectionY(Form("qaTRD_recPoints_amp_%d",i), i+1, i+1);
+      hist->Reset();
+      for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
+       Double_t xvalue = hist->GetBinCenter(b);
+       Int_t bin = ((TH2D*)list->At(1))->FindBin(i,xvalue);
+       Double_t value =  ((TH2D*)list->At(1))->GetBinContent(bin);
+       hist->SetBinContent(b, value);
       }
+      
+      //printf("Sum = %d %f\n", i, hist->GetSum());
+      if (hist->GetSum() < 100) continue; // chamber not present
+      
+      hist->Fit("landau", "q0", "goff", 10, 180);
+      TF1 *fit = hist->GetFunction("landau");
+      ((TH1D*)list->At(12))->Fill(fit->GetParameter(1));
+      ((TH1D*)list->At(13))->Fill(fit->GetParameter(2));
     }
     
-    
-    if (((TH2D*)list->At(10))->GetEntries() > 1e5) {
-      for (Int_t i=0; i<540; i++) {
+    // time-bin by time-bin sm by sm
+    for(Int_t i=0; i<18; i++) { // loop over super-modules
+      
+      for(Int_t j=0; j<35; j++) { // loop over time bins
+       
+       //TH1D *h =  ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, j+1, j+1);     
+       hist->Reset();
+       for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
+         Double_t xvalue = hist->GetBinCenter(b);
+         Double_t svalue = 0;
+         
+         for(Int_t det=i*30; det<(i+1)*30; det++) { // loop over detectors
+           Int_t bin = ((TH3D*)list->At(10))->FindBin(det,j,xvalue);
+           Double_t value =  ((TH3D*)list->At(10))->GetBinContent(bin);
+           svalue += value;
+         }
+         //printf("v = %f\n", value);
+         hist->SetBinContent(b, svalue);
+       }
        
-       TH1D *test = ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, 0, 35);     
-       if (test->GetSum() < 100) continue;
+       if (hist->GetSum() < 100) continue;
+       //printf("fitting %d %d %f\n", i, j, hist->GetSum());
        
-       //AliInfo(Form("fitting det = %d", i));
+       hist->Fit("landau", "q0", "goff", 10, 180);
+       TF1 *fit = hist->GetFunction("landau");
        
-       for(Int_t j=0; j<35; j++) {
-         
-         TH1D *h =  ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, j+1, j+1);     
-         if (h->GetSum() < 50) continue;
-         
-         h->Fit("landau", "q0", "goff", 10, 180);
-         TF1 *fit = h->GetFunction("landau");
-         
-         Int_t sm = i/18;
-         Int_t det = i%18;
-         TH2D *h2 = (TH2D*)list->At(14+sm);
-         Int_t bin = h2->FindBin(det,j);
-         // printf("%d %d %d\n", det, j, bin);
-         h2->SetBinContent(bin, fit->GetParameter(1));
+       TH1D *h1 = (TH1D*)list->At(14+18+i);
+       Int_t bin = h1->FindBin(j);
+       // printf("%d %d %d\n", det, j, bin);
+       h1->SetBinContent(bin, TMath::Abs(fit->GetParameter(1)));
+      }
+    }
+      
+
+    // time-bin by time-bin chamber by chamber
+    for (Int_t i=0; i<540; i++) {
+      
+      //TH1D *test = ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, 0, 35);     
+      //if (test->GetSum() < 100) continue;
+      
+      //AliInfo(Form("fitting det = %d", i));
+      
+      for(Int_t j=0; j<35; j++) {
+       
+       //TH1D *h =  ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, j+1, j+1);     
+       hist->Reset();
+       for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
+         Double_t xvalue = hist->GetBinCenter(b);
+         Int_t bin = ((TH3D*)list->At(10))->FindBin(i,j,xvalue);
+         Double_t value =  ((TH3D*)list->At(10))->GetBinContent(bin);
+         //printf("v = %f\n", value);
+         hist->SetBinContent(b, value);
        }
+       
+       if (hist->GetSum() < 100) continue;
+       //printf("fitting %d %d %f\n", i, j, hist->GetSum());
+       
+       hist->Fit("landau", "q0", "goff", 10, 180);
+       TF1 *fit = hist->GetFunction("landau");
+       
+       Int_t sm = i/30;
+       Int_t det = i%30;
+       TH2D *h2 = (TH2D*)list->At(14+sm);
+       Int_t bin = h2->FindBin(det,j);
+       // printf("%d %d %d\n", det, j, bin);
+       h2->SetBinContent(bin, TMath::Abs(fit->GetParameter(1)));
+       h2->SetBinError(bin,fit->GetParError(1));
       }
     }
+    
+    if (hist) delete hist;
   }
   
-  // call the checker
-  AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;    
+  //////////////////////////
+  // const Int_t knbits = 6;
+  // const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
+  //const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
 
+  if (task == AliQA::kESDS) {
+    
+    const Int_t knRatio = 4;
+    const Int_t kN[knRatio] = {4,3,4,5};
+    const Int_t kD[knRatio] = {3,1,1,3}; 
+    
+    // create ratios
+    for(Int_t type=0; type<2; type++) {
+      for(Int_t i=0; i<knRatio; i++) {
+
+       TH1D *ratio = (TH1D*)list->At(19 + 2*i + type);
+       TH1D *histN = (TH1D*)list->At(3 + 2*kN[i] + type);
+       TH1D *histD = (TH1D*)list->At(3 + 2*kD[i] + type);
+
+       BuildRatio(ratio, histN, histD);
+       //ratio->Reset();
+       //ratio->Add(histN);
+       //ratio->Divide(histD);
+      }
+    }
 
+    // ratio for the fraction of electrons per stack
+    TH1D *histN = (TH1D*)list->At(33);
+    TH1D *histD = (TH1D*)list->At(32);
+    TH1D *ratio = (TH1D*)list->At(34);
+    BuildRatio(ratio, histN, histD);
+  }
+
+  
+  // call the checker
+  AliQAChecker::Instance()->Run(AliQA::kTRD, task, list) ;    
 }
 
 //____________________________________________________________________________ 
@@ -152,30 +251,86 @@ void AliTRDQADataMakerRec::InitESDs()
   // Create ESDs histograms in ESDs subdir
   //
 
-  const Int_t kNhist = 19;
+  const Int_t kNhist = 36+5+4;
+
   TH1 *hist[kNhist];
   Int_t histoCounter = -1 ;
 
-  hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", ":Number of tracks", 300, -0.5, 299.5);
-  hist[++histoCounter] = new TH1D("qaTRD_esd_sector", ":Sector", 18, -0.5, 17.7);
+  hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", ";Number of tracks", 300, -0.5, 299.5);
+  hist[++histoCounter] = new TH1D("qaTRD_esd_sector", ";Sector", 18, -0.5, 17.7);
   hist[++histoCounter] = new TH1D("qaTRD_esd_bits", ";Bits", 64, -0.5, 63.5);
 
   const Int_t knbits = 6;
   const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
 
-  for(Int_t i=0; i<knbits; i++) {
-    hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), ";p_{T} (GeV/c);", 50, 0, 10);
+  // histo = 3
+  for(Int_t i=0; i<knbits; i++) { 
+    hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), ";p_{T} (GeV/c);", 100, 0, 10);
     hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400); 
   }
 
-  hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters", 130, -0.5, 129.5);;
-  hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters", 130, -0.5, 129.5);;
-  hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters", 130, -0.5, 129.5);;
+  hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters", 180, -0.5, 179.5);;
+  hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters", 180, -0.5, 179.5);;
+  hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters", 180, -0.5, 179.5);;
   //hist[++histoCounter] = new TH1D("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
 
   hist[++histoCounter] = new TH2D("qaTRD_esd_sigMom", ";momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
 
-  for(Int_t i=0; i<=histoCounter; i++) {
+  // end of cycle plots (hist 19)
+  const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
+
+  for(int i=0; i<4; i++) {
+    hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",sufRatio[i]), 
+                                   Form("Efficiency in Pt %s;p_{T};eff", sufRatio[i]),
+                                   100, 0, 10);
+
+    hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s",sufRatio[i]), 
+                                   Form("Efficiency in Z %s;z (cm);eff", sufRatio[i]),
+                                   200, -400, 400);
+  }
+
+  // 27 - 31
+  hist[27] = new TH1D("qaTRD_esd_quality", ";quality", 120, 0, 12);
+  hist[28] = new TH1D("qaTRD_esd_budget", ";NN", 110, -1000, 100);
+  hist[29] = new TH1D("qaTRD_esd_chi2", ";chi2", 200, 0, 100);
+  hist[30] = new TH1D("qaTRD_esd_timeBin", ";time bin", 7, -0.5, 6.5);
+  hist[31] = new TH1D("qaTRD_esd_pidQuality", "pid Quality", 7, -0.5, 6.5);
+
+  // stack by stack electron identyfication
+  hist[32] = new TH1D("qaTRD_esd_tracksStack", "number of all tracks;stack", 90, -0.5, 89.5);
+  hist[33] = new TH1D("qaTRD_esd_electronStack", "number of electron tracks;stack", 90, -0.5, 89.5);
+  hist[34] = new TH1D("qaTRD_esd_elRatioStack", "fraction of electron tracks;stack", 90, -0.5, 89.5);
+  hist[35] = new TH1D("qaTRD_esd_thetaOut", ";tan(theta);", 100, -1, 1);
+  
+  const char *partType[5] = {"Electron", "Muon", "Pion", "Kaon", "Proton"}; 
+
+  for(Int_t i=0; i<AliPID::kSPECIES; i++)
+    hist[36+i] = new TH1D(Form("qaTRD_esd_pid%d",i),
+                         Form("%s;probability",partType[i]), 100, 0, 1);
+  // dE/dX vs momentum in three regions
+  const char *zoneName[4] = {"total charge", "ampilification range", "plateau", "TR range"};
+  // prepare the scale from 0.1 to 10 GeV
+  Double_t scalex[101];
+  Double_t dd = (TMath::Log(10) - TMath::Log(0.5)) / 100.;
+  for(Int_t ix=0; ix<101; ix++) {
+    scalex[ix] = 0.5 * TMath::Exp(dd * ix);
+  }
+
+  Double_t scaley[101];
+  for(Int_t iy=0; iy<101; iy++) {
+    scaley[iy] = iy * (3e3/100.);
+  }
+    
+
+  for(Int_t i=0; i<4; i++) {
+    hist[41+i] = new TH2D(Form("qaTRD_esd_signalPzone_%d",i), 
+                         Form("%s;momentum (GeV/c);singal (a.u.)", zoneName[i]),
+                         100, scalex, 100, scaley);
+  }
+
+  for(Int_t i=0; i<kNhist; i++) {
     //hist[i]->Sumw2();
     Add2ESDsList(hist[i], i);
   }
@@ -189,7 +344,7 @@ void AliTRDQADataMakerRec::InitRecPoints()
   // Create Reconstructed Points histograms in RecPoints subdir
   //
 
-  const Int_t kNhist = 14 + 18;
+  const Int_t kNhist = 14 + 4 * 18 + 2;
   TH1 *hist[kNhist];
 
   hist[0] = new TH1D("qaTRD_recPoints_det", ";Detector ID of the cluster", 540, -0.5, 539.5);
@@ -206,25 +361,52 @@ void AliTRDQADataMakerRec::InitRecPoints()
   hist[9] = new TH1D("qaTRD_recPoints_nCls", ";number of clusters", 500, -0.5, 499.5);
 
   hist[10] = new TH3D("qaTRD_recPoints_sigTime", ";chamber;time bin;signal", 
-                     540, -0.5, 539.5, 35, -0.5, 34.5, 100, 0, 200);
+                     540, -0.5, 539.5, 35, -0.5, 34.5, 200, -0.5, 199.5);
   hist[11] = new TProfile("qaTRD_recPoints_prf", ";distance;center of gravity"
                          , 120, -0.6, 0.6, -1.2, 1.2, "");
 
-  hist[12] = new TH1D("qaTRD_recPoints_ampMPV", ";amplitude MPV", 100, 0, 100);
-  hist[13] = new TH1D("qaTRD_recPoints_ampSigma", ";amplitude Sigma", 100, 0, 100); 
-
+  hist[12] = new TH1D("qaTRD_recPoints_ampMPV", ";amplitude MPV", 200, 0, 200);
+  hist[13] = new TH1D("qaTRD_recPoints_ampSigma", ";amplitude Sigma", 200, 0, 200); 
+  
+  // chamber by chamber
   for(Int_t i=0; i<18; i++) {
     hist[14+i] = new TH2D(Form("qaTRD_recPoints_sigTime_sm%d",i), Form("sm%d;det;time bin"), 
                        30, -0.5, 29.5, 35, -0.5, 34.5);
     hist[14+i]->SetMinimum(20);
     hist[14+i]->SetMaximum(40);
   }
+  // time bin by time bin sm-by-sm
+  for(Int_t i=0; i<18; i++) {
+    hist[14+18+i] = new TH1D(Form("qaTRD_recPoints_sigTimeShape_sm%d", i), 
+                            Form("sm%d;time bin;signal"),
+                            35, -0.5, 34.5);
+
+    hist[14+18+i]->SetMaximum(120);    
+  }
+
+  // str = 50
+  for(Int_t i=0; i<18; i++) {
+    hist[50+i] = new TH1D(Form("qaTRD_recPoints_nCls_sm%d",i),
+                         Form("sm%d;time bin;number of clusters",i),
+                         35, -0.5, 34.5);
+  }
+
+  // str = 68
+  for(Int_t i=0; i<18; i++) {
+    hist[68+i] = new TH1D(Form("qaTRD_recPoints_totalCharge_sm%d", i),
+                         Form("sm%d;time bin;total charge", i),
+                         35, -0.5, 34.5);
+  }
+
+  hist[86] = new TH1D("qaTRD_recPoints_signal", ";amplitude", 200, -0.5, 199.5);
+  hist[87] = new TH2D("qaTRD_recPoints_detMap", ";sm;chamber", 18, -0.5, 17.5, 30, -0.5, 29.5);
+
 
   for(Int_t i=0; i<kNhist; i++) {
     //hist[i]->Sumw2();
     Add2RecPointsList(hist[i], i);
   }
-
 }
 
 //____________________________________________________________________________ 
@@ -288,7 +470,7 @@ void AliTRDQADataMakerRec::MakeESDs(AliESDEvent * esd)
 
     // .. in the acceptance
     Int_t sector = GetSector(paramOut->GetAlpha());
-    GetESDsData(1)->Fill(sector);
+    Int_t stack = GetStack(paramOut);
 
     UInt_t u = 1;
     UInt_t status = track->GetStatus();
@@ -317,7 +499,7 @@ void AliTRDQADataMakerRec::MakeESDs(AliESDEvent * esd)
 
     // clusters
     for(Int_t b=0; b<3; b++) 
-      if (bit[3+b]) GetESDsData(b+15)->Fill(track->GetTRDncls());
+      if (bit[3+b]) GetESDsData(b+15)->Fill(track->GetTRDncls0());
 
     // refitted only
     if (!bit[4]) continue;
@@ -325,9 +507,51 @@ void AliTRDQADataMakerRec::MakeESDs(AliESDEvent * esd)
     //fQuality->Fill(track->GetTRDQuality());
     //fBudget->Fill(track->GetTRDBudget());
     //fSignal->Fill(track->GetTRDsignal());
-       
+
+    GetESDsData(1)->Fill(sector);
     GetESDsData(18)->Fill(track->GetP(), track->GetTRDsignal());
 
+    GetESDsData(27)->Fill(track->GetTRDQuality());
+    GetESDsData(28)->Fill(track->GetTRDBudget());
+    GetESDsData(29)->Fill(track->GetTRDchi2());
+    GetESDsData(30)->Fill(track->GetTRDTimBin(0));
+    GetESDsData(31)->Fill(track->GetTRDpidQuality());
+    
+    
+    // dedx
+    for(Int_t i=0; i<4; i++) {
+      Double_t dedx = 0;
+      for(Int_t j=0; j<6; j++) {
+       dedx += track->GetTRDsignals(j, i-1);
+      }
+      GetESDsData(41+i)->Fill(paramOut->GetP(), dedx/6.);
+    }
+
+    // probabilities
+    if (status & AliESDtrack::kTRDpid) {
+      for(Int_t i=0; i<AliPID::kSPECIES; i++) 
+       GetESDsData(36+i)->Fill(track->GetTRDpid(i));
+    }
+
+    // probabilities uniformity
+    if (track->GetTRDpidQuality() < 6) continue;
+    GetESDsData(35)->Fill(paramOut->GetZ()/paramOut->GetX());
+    
+    Int_t idx = 5 * sector + stack;
+    GetESDsData(32)->Fill(idx); // all tracks
+    if (track->GetTRDpid(AliPID::kElectron) > 0.9) 
+      GetESDsData(33)->Fill(idx); // electrons only
+
+    
+
+    /*
+    hist[27] = new TH1D("qaTRD_esd_quality", ";quality", 120, 0, 12);
+    hist[28] = new TH1D("qaTRD_esd_budget", ";NN", 110, -1000, 100);
+    hist[29] = new TH1D("qaTRD_esd_chi2", ";chi2", 300, 0, 100);
+    hist[30] = new TH1D("qaTRD_esd_timeBin", 7, -0.5, 6.5);
+    hist[31] = new TH1D("qaTRD_esd_pidQuality", 7, -0.5, 6.5);
+    */
+
     /*
     // PID only
     if (status & AliESDtrack::kTRDpid) {
@@ -367,17 +591,33 @@ void AliTRDQADataMakerRec::MakeESDs(AliESDEvent * esd)
 }
 
 //______________________________________________________________________________
-Int_t AliTRDQADataMakerRec::GetSector(const Double_t alpha) const 
+Int_t AliTRDQADataMakerRec::GetSector(Double_t alpha) const 
 {
   //
   // Gets the sector number 
   //
 
   Double_t size = TMath::DegToRad() * 20.; // shall use TRDgeo
-  Int_t sector = (Int_t)((alpha + TMath::Pi())/size);
+  if (alpha < 0) alpha += 2*TMath::Pi();
+  Int_t sector = (Int_t)(alpha/size);
   return sector;
 
 }
+//______________________________________________________________________________
+
+Int_t AliTRDQADataMakerRec::GetStack(const AliExternalTrackParam *paramOut) const
+{
+  //
+  // calculates the stack the track is in
+  //
+  
+  const Double_t L = -0.9;
+  const Double_t W = (2*L)/5;
+
+  Double_t tan = paramOut->GetZ() / paramOut->GetX();
+  Double_t pos = (tan - L) / W;
+  return (Int_t) pos;
+}
 
 //______________________________________________________________________________
 Double_t AliTRDQADataMakerRec::GetExtZ(const AliExternalTrackParam *in) const 
@@ -417,10 +657,9 @@ void AliTRDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
   const Int_t kMCM = 16;
   //  const Int_t kADC = 22;
 
-  AliTRDrawStreamTB *raw = new AliTRDrawStreamTB(rawReader);
-
-  raw->SetRawVersion(3);
-  raw->Init();
+  //AliTRDrawStreamBase::SetRawStreamVersion("TB");
+  AliTRDrawStreamBase *raw = AliTRDrawStreamBase::GetRawStream(rawReader);
+  AliDebug(2,Form("Stream version: %s", raw->IsA()->GetName()));
 
   while (raw->Next()) {
 
@@ -445,6 +684,8 @@ void AliTRDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
     GetRawsData(3)->Fill(sm);
     GetRawsData(4+sm)->Fill(index);
   }
+
+  delete raw;
 }
 
 //____________________________________________________________________________
@@ -453,6 +694,8 @@ void AliTRDQADataMakerRec::MakeRecPoints(TTree * clustersTree)
   //  
   // Makes data from RecPoints
   // 
+  
+  //  Info("MakeRecPoints", "making");
 
   Int_t nsize = Int_t(clustersTree->GetTotBytes() / (sizeof(AliTRDcluster))); 
   TObjArray *clusterArray = new TObjArray(nsize+1000); 
@@ -486,6 +729,7 @@ void AliTRDQADataMakerRec::MakeRecPoints(TTree * clustersTree)
       Int_t iDet = c->GetDetector();
       nDet[iDet]++;
       GetRecPointsData(0)->Fill(iDet);
+      GetRecPointsData(86)->Fill(c->GetQ());
       GetRecPointsData(1)->Fill(iDet, c->GetQ());
       GetRecPointsData(2)->Fill(c->GetNPads());
       if (c->GetNPads() < 6)
@@ -496,6 +740,10 @@ void AliTRDQADataMakerRec::MakeRecPoints(TTree * clustersTree)
       GetRecPointsData(8)->Fill(c->GetPadTime());
 
       ((TH3D*)GetRecPointsData(10))->Fill(iDet, c->GetPadTime(), c->GetQ());
+      
+      Int_t iSM = iDet / 30;
+      GetRecPointsData(50+iSM)->Fill(c->GetPadTime());
+      GetRecPointsData(68+iSM)->Fill(c->GetPadTime(), c->GetQ());
 
       // PRF for 2pad
       //if (c->GetNPads() == 2) {
@@ -539,5 +787,37 @@ Int_t AliTRDQADataMakerRec::CheckPointer(TObject *obj, const char *name)
 
   if (!obj) AliWarning(Form("null pointer: %s", name));
   return !!obj;
+}
+//__________________________________________________________________________
+void AliTRDQADataMakerRec::BuildRatio(TH1D *ratio, TH1D *histN, TH1D*histD) {
+  //
+  // Calculate the ratio of two histograms 
+  // error are calculated assuming the histos have the same counts
+  //
+
+  // calclate
+
+  Int_t nbins = histN->GetXaxis()->GetNbins();
+  for(Int_t i=1; i<nbins+2; i++) {
+    
+    Double_t valueN = histN->GetBinContent(i);
+    Double_t valueD = histD->GetBinContent(i);
+    
+    if (valueD < 1) {
+      ratio->SetBinContent(i, 0);
+      ratio->SetBinError(i, 0);
+      continue;
+    }
 
+    Double_t eps = (valueN < valueD-valueN)? valueN : valueD-valueN;
+    
+    ratio->SetBinContent(i, valueN/valueD);
+    ratio->SetBinError(i, TMath::Sqrt(eps)/valueD);
+  }
+
+  // style
+  ratio->SetMinimum(-0.1);
+  ratio->SetMaximum(1.1);
+  ratio->SetMarkerStyle(20);
 }
+//__________________________________________________________________________