Updates of the calibration code after calibration of the cosmics from CERN
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 15 Dec 2008 16:45:39 +0000 (16:45 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 15 Dec 2008 16:45:39 +0000 (16:45 +0000)
TRD/AliTRDCalibraFillHisto.cxx
TRD/AliTRDCalibraFillHisto.h
TRD/AliTRDCalibraFit.cxx
TRD/AliTRDCalibraFit.h
TRD/AliTRDCalibraMode.cxx
TRD/AliTRDCalibraMode.h
TRD/AliTRDCalibraVdriftLinearFit.cxx
TRD/AliTRDCalibraVdriftLinearFit.h
TRD/AliTRDPreprocessor.cxx

index 8c52989..645d2bc 100644 (file)
@@ -1,17 +1,17 @@
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- *                                                                        *
- * Author: The ALICE Off-line Project.                                    *
- * Contributors are mentioned in the code where appropriate.              *
- *                                                                        *
- * Permission to use, copy, modify and distribute this software and its   *
- * documentation strictly for non-commercial purposes is hereby granted   *
- * without fee, provided that the above copyright notice appears in all   *
- * copies and that both the copyright notice and this permission notice   *
- * appear in the supporting documentation. The authors make no claims     *
- * about the suitability of this software for any purpose. It is          *
- * provided "as is" without express or implied warranty.                  *
- **************************************************************************/
+//**************************************************************************
+// * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+// *                                                                        *
+// * Author: The ALICE Off-line Project.                                    *
+// * Contributors are mentioned in the code where appropriate.              *
+//   *                                                                        *
+//   * Permission to use, copy, modify and distribute this software and its   *
+//  * documentation strictly for non-commercial purposes is hereby granted   *
+//    * without fee, provided that the above copyright notice appears in all   *
+//    * copies and that both the copyright notice and this permission notice   *
+//* appear in the supporting documentation. The authors make no claims     *
+//* about the suitability of this software for any purpose. It is          *
+//* provided "as is" without express or implied warranty.                  *
+//**************************************************************************/
 
 /* $Id$ */
 
@@ -121,6 +121,7 @@ void AliTRDCalibraFillHisto::Terminate()
 AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   :TObject()
   ,fGeo(0)
+  ,fIsHLT(kFALSE)
   ,fMcmCorrectAngle(kFALSE)
   ,fCH2dOn(kFALSE)
   ,fPH2dOn(kFALSE)
@@ -133,13 +134,16 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   ,fThresholdClusterPRF2(15.0)
   ,fLimitChargeIntegration(kFALSE)
   ,fFillWithZero(kFALSE)
+  ,fNormalizeNbOfCluster(kFALSE)
+  ,fMaxCluster(0)
+  ,fNbMaxCluster(0)
   ,fCalibraMode(new AliTRDCalibraMode())
   ,fDebugStreamer(0)
   ,fDebugLevel(0)
   ,fDetectorPreviousTrack(-1)
   ,fMCMPrevious(-1)
   ,fROBPrevious(-1)
-  ,fNumberClusters(0)
+  ,fNumberClusters(1)
   ,fNumberClustersf(30)
   ,fProcent(6.0)
   ,fDifference(17)
@@ -186,6 +190,7 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
 AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   :TObject(c)
   ,fGeo(0)
+  ,fIsHLT(c.fIsHLT)
   ,fMcmCorrectAngle(c.fMcmCorrectAngle)
   ,fCH2dOn(c.fCH2dOn)
   ,fPH2dOn(c.fPH2dOn)
@@ -198,6 +203,9 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   ,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
   ,fLimitChargeIntegration(c.fLimitChargeIntegration)
   ,fFillWithZero(c.fFillWithZero)
+  ,fNormalizeNbOfCluster(c.fNormalizeNbOfCluster)
+  ,fMaxCluster(c.fMaxCluster)
+  ,fNbMaxCluster(c.fNbMaxCluster)
   ,fCalibraMode(0x0)
   ,fDebugStreamer(0)
   ,fDebugLevel(c.fDebugLevel)
@@ -310,6 +318,7 @@ void AliTRDCalibraFillHisto::DestroyDebugStreamer()
   //
 
   if ( fDebugStreamer ) delete fDebugStreamer;
+  fDebugStreamer = 0x0;
  
 }
 //_____________________________________________________________________________
@@ -359,14 +368,15 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
   // Some parameters
   fTimeMax            = cal->GetNumberOfTimeBins();
   fSf                 = parCom->GetSamplingFrequency();
-  fRelativeScale      = 20;
+  if(!fNormalizeNbOfCluster) fRelativeScale = 20.0;
+  else fRelativeScale = 1.18;
   fNumberClustersf    = fTimeMax;
   fNumberClusters     = (Int_t)(0.5*fTimeMax);
  
   // Init linear fitter
   if(!fLinearFitterTracklet) {
     fLinearFitterTracklet = new TLinearFitter(2,"pol1");
-    fLinearFitterTracklet->StoreData(kFALSE);
+    fLinearFitterTracklet->StoreData(kTRUE);
   }
 
   //calib object from database used for reconstruction
@@ -560,8 +570,10 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistograms(AliTRDtrack *t)
       
       // Get calib objects
       if( fCalROCGain ){ 
-        fCalROCGain->~AliTRDCalROC();
-        new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+       if(!fIsHLT){
+         fCalROCGain->~AliTRDCalROC();
+         new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+       }
       }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
       
     }
@@ -667,8 +679,10 @@ Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(AliTRDtrackV1 *t)
       LocalisationDetectorXbins(detector);
       // Get calib objects
       if( fCalROCGain ){ 
-        fCalROCGain->~AliTRDCalROC();
-        new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+       if(!fIsHLT){    
+         fCalROCGain->~AliTRDCalROC();
+         new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+       }
       }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
       
       // reset
@@ -946,6 +960,7 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
   pointError  =  TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
   errorpar    =  fLinearFitterTracklet->GetParError(1)*pointError;
   dydt        = pars[1]; 
+  //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",fLinearFitterTracklet->GetChisquare(),nbli,pointError,fLinearFitterTracklet->GetParError(1),errorpar);
   fLinearFitterTracklet->ClearPoints();  
  
   ////////////////////////////////
@@ -963,9 +978,10 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
     
 
     Int_t layer = GetLayer(fDetectorPreviousTrack);
-        
+           
     (* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
       //"snpright="<<snpright<<
+      "nbli="<<nbli<<
       "nbclusters="<<nbclusters<<
       "detector="<<fDetectorPreviousTrack<<
       "layer="<<layer<<
@@ -988,7 +1004,7 @@ Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtrackletV1(const AliTRDseedV1 *track
 
   if(nbclusters < fNumberClusters) return kFALSE;
   if(nbclusters > fNumberClustersf) return kFALSE;
-  if(pointError >= 0.1) return kFALSE;
+  if(pointError >= 0.3) return kFALSE;
   if(crossrow == 1) return kFALSE;
   
   ///////////////////////
@@ -1751,6 +1767,22 @@ Int_t AliTRDCalibraFillHisto::CalculateTotalNumberOfBins(Int_t i)
   //
   
   Int_t ntotal = 0;
+
+  // All together
+  if((fCalibraMode->GetNz(i)==100) && (fCalibraMode->GetNrphi(i)==100)){
+    ntotal = 1;
+    AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+    return ntotal;
+  }
+
+  // Per Supermodule
+  if((fCalibraMode->GetNz(i)==10) && (fCalibraMode->GetNrphi(i)==10)){
+    ntotal = 18;
+    AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+    return ntotal;
+  }
+
+  // More
   fCalibraMode->ModePadCalibration(2,i);
   fCalibraMode->ModePadFragmentation(0,2,0,i);
   fCalibraMode->SetDetChamb2(i);
@@ -1795,6 +1827,35 @@ void AliTRDCalibraFillHisto::SetNrphi(Int_t i, Short_t Nrphi)
   }
 
 }
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetAllTogether(Int_t i)
+{
+  //
+  // Set the mode of calibration group all together
+  //
+  if(fVector2d == kTRUE) {
+    AliInfo("Can not work with the vector method");
+    return;
+  }
+  fCalibraMode->SetAllTogether(i);
+  
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetPerSuperModule(Int_t i)
+{
+  //
+  // Set the mode of calibration group per supermodule
+  //
+  if(fVector2d == kTRUE) {
+    AliInfo("Can not work with the vector method");
+    return;
+  }
+  fCalibraMode->SetPerSuperModule(i);
+  
+}
+
 //____________Set the pad calibration variables for the detector_______________
 Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
 {
@@ -1856,7 +1917,9 @@ void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(AliTRDcluster *cl, Double_t dqdl
   Int_t    time     = cl->GetPadTime();
    
   //Correct for the gain coefficient used in the database for reconstruction
-  Float_t correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
+  Float_t correctthegain = 1.0;
+  if(fIsHLT) correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack);
+  else correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
   Float_t correction    = 1.0;
   Float_t normalisation = 6.67;
   // we divide with gain in AliTRDclusterizer::Transform...
@@ -1920,7 +1983,11 @@ void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
 
   if(nbclusters < fNumberClusters) return;
   if(nbclusters > fNumberClustersf) return;
-  
+
+
+  // Normalize with the number of clusters
+  Double_t normalizeCst = fRelativeScale;
+  if(fNormalizeNbOfCluster) normalizeCst = normalizeCst*nbclusters;
   
   // See if the track goes through different zones
   for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
@@ -1940,11 +2007,11 @@ void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
       fNumberUsedCh[0]++;
       fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
       if (fHisto2d) {
-       FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-       //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+       FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+       //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
       }
       if (fVector2d) {
-       fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+       fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
       }
       break;
     case 2:
@@ -1953,22 +2020,22 @@ void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
        // One of the two very big
        if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
          if (fHisto2d) {
-           FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-           //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+           FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+           //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
          }
          if (fVector2d) {
-           fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+           fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
          }
          fNumberUsedCh[1]++;
          fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
        }
        if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
          if (fHisto2d) {
-           FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/fRelativeScale);
-           //fCH2d->Fill(fAmpTotal[fd+1]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+1.5);
+           FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/normalizeCst);
+           //fCH2d->Fill(fAmpTotal[fd+1]/normalizeCst,fCalibraMode->GetXbins(0)+fd+1.5);
          }
          if (fVector2d) {
-           fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/fRelativeScale);
+           fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/normalizeCst);
          }
          fNumberUsedCh[1]++;
          fEntriesCH[fCalibraMode->GetXbins(0)+fd+1]++;
@@ -1981,24 +2048,24 @@ void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackCH(Int_t nbclusters)
              // One of the two very big
              if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
                if (fHisto2d) {
-                 FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
-                 //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+                 FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+                 //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
                }
                if (fVector2d) {
-                 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+                 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
                }
                fNumberUsedCh[1]++;
                fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
              }
              if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
                if (fHisto2d) {
-                 FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
-                 //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
+                 FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
+                 //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
                }
                fNumberUsedCh[1]++;
                fEntriesCH[fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)]++;
                if (fVector2d) {
-                 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
+                 fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
                }
              }
            }
@@ -2048,6 +2115,16 @@ void AliTRDCalibraFillHisto::FillTheInfoOfTheTrackPH()
     }
   }
 
+  // See if noise before and after
+  if(fMaxCluster > 0) {
+    if(fPHValue[0] > fMaxCluster) return;
+    if(fTimeMax > fNbMaxCluster) {
+      for(Int_t k = (fTimeMax-fNbMaxCluster); k < fTimeMax; k++){
+       if(fPHValue[k] > fMaxCluster) return;
+      }
+    }
+  }
+
   //printf("nbclusters %d, low limit %d, high limit %d\n",nbclusters,fNumberClusters,fNumberClustersf);
 
   if(nbclusters < fNumberClusters) return;
index 0c26d25..71329c5 100644 (file)
@@ -91,12 +91,17 @@ class AliTRDCalibraFillHisto : public TObject {
          Double_t *StatH(TH2 *ch, Int_t i);
          Double_t *GetMeanMedianRMSNumberCH();
          Double_t *GetMeanMedianRMSNumberLinearFitter() const;
+ // LinearFitter
+         void     AnalyseLinearFitter();
        
         
   //
   // Set of Get the variables
   //
 
+         void     SetIsHLT(Bool_t isHLT = kTRUE)                            { fIsHLT = isHLT;                       }  
+         Bool_t   IsHLT() const                                             { return fIsHLT;                        }  
+
   // Choice to fill or not the 2D
           void     SetMcmCorrectAngle(Bool_t mcmcorrectangle = kTRUE)        { fMcmCorrectAngle = mcmcorrectangle;   }
           void     SetPH2dOn(Bool_t ph2don = kTRUE)                          { fPH2dOn          = ph2don;            }
@@ -132,11 +137,16 @@ class AliTRDCalibraFillHisto : public TObject {
           void     SetThresholdClusterPRF2(Float_t thresholdClusterPRF2)     { fThresholdClusterPRF2 = thresholdClusterPRF2; }
          void     SetLimitChargeIntegration(Bool_t limitChargeIntegration)  { fLimitChargeIntegration = limitChargeIntegration; }
          void     SetFillWithZero(Bool_t fillWithZero)                      { fFillWithZero = fillWithZero;   }
+         void     SetNormalizeNbOfCluster(Bool_t normalizeNbOfCluster)      { fNormalizeNbOfCluster = normalizeNbOfCluster; }
+         void     SetMaxCluster(Float_t maxCluster)                         { fMaxCluster = maxCluster; }
+         void     SetNbMaxCluster(Short_t nbMaxCluster)                     { fNbMaxCluster = nbMaxCluster; }
          void     SetNz(Int_t i, Short_t nz);
           void     SetNrphi(Int_t i, Short_t nrphi);
-          void     SetProcent(Float_t procent)                               { fProcent              = procent;              }
+          void     SetAllTogether(Int_t i);
+         void     SetPerSuperModule(Int_t i);
+         void     SetProcent(Float_t procent)                               { fProcent              = procent;              }
           void     SetDifference(Short_t difference)                         { fDifference           = difference;           }
-          void     SetNumberClusters(Short_t numberClusters)                 { fNumberClusters       = numberClusters;       }
+          void     SetNumberClusters(Short_t numberClusters)                 { if(numberClusters > 0) fNumberClusters       = numberClusters;       }
          void     SetNumberClustersf(Short_t numberClustersf)               { fNumberClustersf      = numberClustersf;      }
           void     SetNumberBinCharge(Short_t numberBinCharge)               { fNumberBinCharge      = numberBinCharge;      }
           void     SetNumberBinPRF(Short_t numberBinPRF)                     { fNumberBinPRF         = numberBinPRF;         }
@@ -146,6 +156,9 @@ class AliTRDCalibraFillHisto : public TObject {
           Float_t  GetThresholdClusterPRF2() const                           { return fThresholdClusterPRF2;   }
          Bool_t   GetLimitChargeIntegration() const                         { return fLimitChargeIntegration; }
          Bool_t   GetFillWithZero() const                                   { return fFillWithZero;           }
+         Bool_t   GetNormalizeNbOfCluster() const                           { return fNormalizeNbOfCluster;   }
+         Float_t  GetMaxCluster() const                                     { return fMaxCluster;             }
+         Short_t  GetNbMaxCluster() const                                   { return fNbMaxCluster;           }
          Float_t  GetProcent() const                                        { return fProcent;                }
           Short_t  GetDifference() const                                     { return fDifference;             }
           Short_t  GetNumberClusters() const                                 { return fNumberClusters;         }
@@ -166,6 +179,9 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
   // Geometry
   AliTRDgeometry  *fGeo;                    //! The TRD geometry
 
+  // Is HLT
+          Bool_t   fIsHLT;                  // Now if HLT, the per detector
+
   // Choice to fill or not the 2D
           Bool_t   fMcmCorrectAngle;        // Apply correction due to the mcmtrackletangle in the z direction (only) assuming  from vertex
           Bool_t   fCH2dOn;                 // Chose to fill the 2D histos or vectors for the relative gain calibration 
@@ -181,6 +197,9 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
           Float_t  fThresholdClusterPRF2;   // Threshold on cluster pad signals
           Bool_t   fLimitChargeIntegration; // Integration range for the gain calibration
          Bool_t   fFillWithZero;           // Fill with zero or not the average pulse height
+         Bool_t   fNormalizeNbOfCluster;   // Normalize with the number of cluster for the gain
+         Float_t  fMaxCluster;             // Max amplitude of one cluster
+         Short_t  fNbMaxCluster;           // Number of tb at the end
   // Calibration mode
          AliTRDCalibraMode *fCalibraMode;  // Calibration mode
 
@@ -270,9 +289,6 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
          void     CheckGoodTrackletV0(Int_t detector, Int_t row, Int_t col);
          void     CheckGoodTrackletV1(AliTRDcluster *cl);
          Int_t    CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const;
-  // LinearFitter
-         void     AnalyseLinearFitter();
          
   // Clear
           void     ClearHistos();
index 55ac675..dba5ced 100644 (file)
 // previous calibration procedure.
 // The function SetDebug enables the user to see:                                     
 // _fDebug = 0: nothing, only the values are written in the tree if wanted
-// _fDebug = 1: a comparaison of the coefficients found and the default values 
+// _fDebug = 1: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
+// _fDebug = 2: a comparaison of the coefficients found and the default values 
 //              in the choosen database.
 //              fCoef , histogram of the coefs as function of the calibration group number
 //              fDelta , histogram of the relative difference of the coef with the default
 //                        value in the database as function of the calibration group number
 //              fError , dirstribution of this relative difference
-// _fDebug = 2: only the fit of the choosen calibration group fFitVoir (SetFitVoir)
 // _fDebug = 3: The coefficients in the choosen detector fDet (SetDet) as function of the
 //              pad row and col number
 // _fDebug = 4; The coeffcicients in the choosen detector fDet (SetDet) like in the 3 but with
@@ -104,7 +104,6 @@ AliTRDCalibraFit *AliTRDCalibraFit::Instance()
   return fgInstance;
 
 }
-
 //______________________________________________________________________________________
 void AliTRDCalibraFit::Terminate()
 {
@@ -121,7 +120,6 @@ void AliTRDCalibraFit::Terminate()
   }
 
 }
-
 //______________________________________________________________________________________
 AliTRDCalibraFit::AliTRDCalibraFit()
   :TObject()
@@ -154,6 +152,7 @@ AliTRDCalibraFit::AliTRDCalibraFit()
   ,fEntriesCurrent(0)
   ,fCountDet(0)
   ,fCount(0)
+  ,fNbDet(0)
   ,fCalDet(0x0)
   ,fCalROC(0x0)
   ,fCalDet2(0x0)
@@ -212,6 +211,7 @@ AliTRDCalibraFit::AliTRDCalibraFit(const AliTRDCalibraFit &c)
 ,fEntriesCurrent(c.fEntriesCurrent)
 ,fCountDet(c.fCountDet)
 ,fCount(c.fCount)
+,fNbDet(c.fNbDet)
 ,fCalDet(0x0)
 ,fCalROC(0x0)
 ,fCalDet2(0x0)
@@ -238,7 +238,7 @@ AliTRDCalibraFit::AliTRDCalibraFit(const AliTRDCalibraFit &c)
   }
   if(c.fCalDet) fCalDet   = new AliTRDCalDet(*c.fCalDet);
   if(c.fCalDet2) fCalDet2 = new AliTRDCalDet(*c.fCalDet2);
-
+  
   if(c.fCalROC) fCalROC   = new AliTRDCalROC(*c.fCalROC);
   if(c.fCalROC2) fCalROC  = new AliTRDCalROC(*c.fCalROC2);
 
@@ -319,6 +319,17 @@ void AliTRDCalibraFit::Destroy()
   }
 
 }
+//_____________________________________________________________________________
+void AliTRDCalibraFit::DestroyDebugStreamer() 
+{
+  //
+  // Delete DebugStreamer
+  //
+
+  if ( fDebugStreamer ) delete fDebugStreamer;
+  fDebugStreamer = 0x0;
+}
 //__________________________________________________________________________________
 void AliTRDCalibraFit::RangeChargeIntegration(Float_t vdrift, Float_t t0, Int_t &begin, Int_t &peak, Int_t &end)
 {
@@ -351,7 +362,7 @@ Bool_t AliTRDCalibraFit::AnalyseCH(TH2I *ch)
 
   // Set the calibration mode
   const char *name = ch->GetTitle();
-  SetModeCalibration(name,0);
+  if(!SetModeCalibration(name,0)) return kFALSE;
 
   // Number of Ybins (detectors or groups of pads)
   Int_t    nbins   = ch->GetNbinsX();// charge
@@ -449,7 +460,7 @@ Bool_t AliTRDCalibraFit::AnalyseCH(AliTRDCalibraVector *calvect)
 
   // Set the calibraMode
   const char *name = calvect->GetNameCH();
-  SetModeCalibration(name,0);  
+  if(!SetModeCalibration(name,0)) return kFALSE;  
 
   // Number of Xbins (detectors or groups of pads)
   if (!InitFit((432*calvect->GetDetCha0(0)+108*calvect->GetDetCha2(0)),0)) {
@@ -549,7 +560,7 @@ Bool_t AliTRDCalibraFit::AnalysePH(TProfile2D *ph)
 
   // Set the calibration mode
   const char *name = ph->GetTitle();
-  SetModeCalibration(name,1);
+  if(!SetModeCalibration(name,1)) return kFALSE;
   
   // Number of Xbins (detectors or groups of pads)
   Int_t    nbins   = ph->GetNbinsX();// time
@@ -587,7 +598,7 @@ Bool_t AliTRDCalibraFit::AnalysePH(TProfile2D *ph)
     // This detector has not enough statistics or was off
     if (nentries  <= fMinEntries) {
       //printf("Not enough statistic!\n");
-      NotEnoughStatisticPH(idect);     
+      NotEnoughStatisticPH(idect,nentries);     
       if (fDebugLevel != 1) {
        delete projph;
       }
@@ -608,7 +619,7 @@ Bool_t AliTRDCalibraFit::AnalysePH(TProfile2D *ph)
       default: return kFALSE;
       }
     // Fill the tree if end of a detector or only the pointer to the branch!!!
-    FillInfosFitPH(idect);
+    FillInfosFitPH(idect,nentries);
     // Memory!!!
     if (fDebugLevel != 1) {
       delete projph;
@@ -638,7 +649,7 @@ Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
 
   // Set the calibration mode
   const char *name = calvect->GetNamePH();
-  SetModeCalibration(name,1);
+  if(!SetModeCalibration(name,1)) return kFALSE;
 
   // Number of Xbins (detectors or groups of pads)
   if (!InitFit((432*calvect->GetDetCha0(1)+108*calvect->GetDetCha2(1)),1)) {
@@ -673,7 +684,7 @@ Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
     // This detector has not enough statistics or was off
     if (fEntriesCurrent <=  fMinEntries) {
       //printf("Not enough stat!\n");
-      NotEnoughStatisticPH(idect);
+      NotEnoughStatisticPH(idect,fEntriesCurrent);
       if (fDebugLevel != 1) {
        if(projph) delete projph;
       }
@@ -694,7 +705,7 @@ Bool_t AliTRDCalibraFit::AnalysePH(AliTRDCalibraVector *calvect)
       default: return kFALSE;
       }
     // Fill the tree if end of a detector or only the pointer to the branch!!!
-    FillInfosFitPH(idect);
+    FillInfosFitPH(idect,fEntriesCurrent);
     // Memory!!!
     if (fDebugLevel != 1) {
       delete projph;
@@ -724,7 +735,7 @@ Bool_t AliTRDCalibraFit::AnalysePRF(TProfile2D *prf)
 
   // Set the calibration mode
   const char *name = prf->GetTitle();
-  SetModeCalibration(name,2);
+  if(!SetModeCalibration(name,2)) return kFALSE;
 
   // Number of Ybins (detectors or groups of pads)
   Int_t    nybins  = prf->GetNbinsY();// calibration groups
@@ -811,7 +822,7 @@ Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(TProfile2D *prf)
 
   // Set the calibration mode
   const char *name = prf->GetTitle();
-  SetModeCalibration(name,2);
+  if(!SetModeCalibration(name,2)) return kFALSE;
 
   // Number of Ybins (detectors or groups of pads)
   TAxis   *xprf    = prf->GetXaxis();
@@ -906,7 +917,7 @@ Bool_t AliTRDCalibraFit::AnalysePRF(AliTRDCalibraVector *calvect)
 
   // Set the calibra mode
   const char *name = calvect->GetNamePRF();
-  SetModeCalibration(name,2);
+  if(!SetModeCalibration(name,2)) return kFALSE;
   //printf("test0 %s\n",name);
 
   // Number of Xbins (detectors or groups of pads)
@@ -989,10 +1000,10 @@ Bool_t AliTRDCalibraFit::AnalysePRFMarianFit(AliTRDCalibraVector *calvect)
 
   // Set the calibra mode
   const char *name = calvect->GetNamePRF();
-  SetModeCalibration(name,2);
+  if(!SetModeCalibration(name,2)) return kFALSE;
   //printf("test0 %s\n",name);
   Int_t    nbg     = GetNumberOfGroupsPRF((const char *)name);
-  printf("test1 %d\n",nbg);
+  //printf("test1 %d\n",nbg);
   if(nbg == -1) return kFALSE;
   if(nbg > 0) fMethod = 1;
   else fMethod = 0;
@@ -1242,39 +1253,86 @@ Bool_t AliTRDCalibraFit::SetNrphiFromTObject(const char *name, Int_t i)
   const Char_t *patternrphi5 = "Nrphi5";
   const Char_t *patternrphi6 = "Nrphi6";
 
+  
+  const Char_t *patternrphi10 = "Nrphi10";
+  const Char_t *patternrphi100 = "Nrphi100";
+  const Char_t *patternz10 = "Nz10";
+  const Char_t *patternz100 = "Nz100";
+
   // Nrphi mode
+  if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
+    fCalibraMode->SetAllTogether(i);
+    fNbDet = 540;
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 100",fNbDet));
+    }
+    return kTRUE;
+  }
+  if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
+    fCalibraMode->SetPerSuperModule(i);
+    fNbDet = 30;
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNDet %d and 100",fNbDet));
+    }
+    return kTRUE;
+  }
+  
   if (strstr(name,patternrphi0)) {
     fCalibraMode->SetNrphi(i ,0);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 0",fNbDet));
+    }
     return kTRUE;
   }
   if (strstr(name,patternrphi1)) {
     fCalibraMode->SetNrphi(i, 1);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 1",fNbDet));
+    }
     return kTRUE;
   }
   if (strstr(name,patternrphi2)) {
     fCalibraMode->SetNrphi(i, 2);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 2",fNbDet));
+    }    
     return kTRUE;
   }
   if (strstr(name,patternrphi3)) {
     fCalibraMode->SetNrphi(i, 3);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 3",fNbDet));
+    }   
     return kTRUE;
   }
   if (strstr(name,patternrphi4)) {
     fCalibraMode->SetNrphi(i, 4);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 4",fNbDet));
+    }   
     return kTRUE;
   }
   if (strstr(name,patternrphi5)) {
     fCalibraMode->SetNrphi(i, 5);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 5",fNbDet));
+    }
     return kTRUE;
   }
   if (strstr(name,patternrphi6)) {
     fCalibraMode->SetNrphi(i, 6);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 6",fNbDet));
+    }
     return kTRUE;
   }
   
+  if (fDebugLevel > 1) {
+    AliInfo(Form("fNbDet %d and rest",fNbDet));
+  }
   fCalibraMode->SetNrphi(i ,0);
   return kFALSE;
-    
+  
 }
 //_____________________________________________________________________________
 Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
@@ -1290,31 +1348,316 @@ Bool_t AliTRDCalibraFit::SetNzFromTObject(const char *name, Int_t i)
   const Char_t *patternz2    = "Nz2";
   const Char_t *patternz3    = "Nz3";
   const Char_t *patternz4    = "Nz4";
-  
+
+  const Char_t *patternrphi10 = "Nrphi10";
+  const Char_t *patternrphi100 = "Nrphi100";
+  const Char_t *patternz10 = "Nz10";
+  const Char_t *patternz100 = "Nz100";
+
+  if ((strstr(name,patternrphi100)) && (strstr(name,patternz100))) {
+    fCalibraMode->SetAllTogether(i);
+    fNbDet = 540;
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 100",fNbDet));
+    }
+    return kTRUE;
+  }
+  if ((strstr(name,patternrphi10)) && (strstr(name,patternz10))) {
+    fCalibraMode->SetPerSuperModule(i);
+    fNbDet = 30;
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 10",fNbDet));
+    }
+    return kTRUE;
+  }
   if (strstr(name,patternz0)) {
     fCalibraMode->SetNz(i, 0);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 0",fNbDet));
+    }
     return kTRUE;
   }
   if (strstr(name,patternz1)) {
     fCalibraMode->SetNz(i ,1);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 1",fNbDet));
+    }
     return kTRUE;
   }
   if (strstr(name,patternz2)) {
     fCalibraMode->SetNz(i ,2);
+    if (fDebugLevel > 1) {    
+      AliInfo(Form("fNbDet %d and 2",fNbDet));
+    }
     return kTRUE;
   }
   if (strstr(name,patternz3)) {
     fCalibraMode->SetNz(i ,3);
+    if (fDebugLevel > 1) {
+      AliInfo(Form("fNbDet %d and 3",fNbDet));
+    }
     return kTRUE;  
   }
   if (strstr(name,patternz4)) {
     fCalibraMode->SetNz(i ,4);
+    if (fDebugLevel > 1) {    
+      AliInfo(Form("fNbDet %d and 4",fNbDet));
+    }
     return kTRUE;
   }
-
+  if (fDebugLevel > 1) {
+    AliInfo(Form("fNbDet %d and rest",fNbDet));
+  }
   fCalibraMode->SetNz(i ,0);
   return kFALSE;
 }
+//______________________________________________________________________
+void AliTRDCalibraFit::PutMeanValueOtherVectorFit(Int_t ofwhat, Bool_t perdetector){
+  //
+  // ofwhat is equaled to 0: mean value of all passing detectors
+  // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
+  //
+
+  Int_t loop = (Int_t) fVectorFit.GetEntriesFast();
+  if(loop != 540) {
+    AliInfo("The Vector Fit is not complete!");
+    return;
+  }
+  Int_t detector = -1;
+  Int_t sector = -1;
+  Float_t value  = 0.0;
+
+  /////////////////////////////////
+  // Calculate the mean values
+  ////////////////////////////////
+  // Initialisation
+  ////////////////////////
+  Double_t meanAll = 0.0;
+  Double_t meanSupermodule[18];
+  Double_t meanDetector[540];
+  Int_t countAll = 0;
+  Int_t countSupermodule[18];
+  Int_t countDetector[540];
+  for(Int_t sm = 0; sm < 18; sm++){
+    meanSupermodule[sm] = 0.0;
+    countSupermodule[sm] = 0;
+  }
+  for(Int_t det = 0; det < 540; det++){
+    meanDetector[det] = 0.0;
+    countDetector[det] = 0;
+  }
+  // compute
+  ////////////
+  for (Int_t k = 0; k < loop; k++) {
+    detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
+    sector = GetSector(detector);
+    if(perdetector){
+      value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[0];
+      if(value > 0.0) {
+       meanDetector[detector] += value;
+       countDetector[detector]++;
+       meanSupermodule[sector] += value;
+       countSupermodule[sector]++;
+       meanAll += value;
+       countAll++;
+      }
+    }
+    else {
+      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
+      for (Int_t row = 0; row < rowMax; row++) {
+       for (Int_t col = 0; col < colMax; col++) {
+         value = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+         if(value > 0.0) {
+           meanDetector[detector] += value;
+           countDetector[detector]++;
+           meanSupermodule[sector] += value;
+           countSupermodule[sector]++;
+           meanAll += value;
+           countAll++;
+         }
+         
+       } // Col
+      } // Row
+    }
+  }  
+  if(countAll > 0) meanAll = meanAll/countAll;
+  for(Int_t sm = 0; sm < 18; sm++){
+    if(countSupermodule[sm] > 0) meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
+  }
+  for(Int_t det = 0; det < 540; det++){
+    if(countDetector[det] > 0) meanDetector[det] = meanDetector[det]/countDetector[det];
+  }
+  // Put the mean value for the no-fitted
+  /////////////////////////////////////////////  
+  for (Int_t k = 0; k < loop; k++) {
+    detector  = ((AliTRDFitInfo *) fVectorFit.At(k))->GetDetector();
+    sector = GetSector(detector);
+    Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+    Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
+    Float_t *coef = ((AliTRDFitInfo *) fVectorFit.At(k))->GetCoef();
+
+    for (Int_t row = 0; row < rowMax; row++) {
+      for (Int_t col = 0; col < colMax; col++) {
+       value = coef[(Int_t)(col*rowMax+row)];
+       if(value < 0.0) {
+         if((ofwhat == 0) && (meanAll > 0.0)) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
+         if(ofwhat == 1){
+           if(meanDetector[detector] > 0.0) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanDetector[detector]);
+           else if(meanSupermodule[sector] > 0.0) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanSupermodule[sector]);
+           else if(meanAll > 0.0) coef[(Int_t)(col*rowMax+row)] = -TMath::Abs(meanAll);
+         }  
+       }
+       // Debug
+       if(fDebugLevel > 1){
+         
+         if ( !fDebugStreamer ) {
+           //debug stream
+           TDirectory *backup = gDirectory;
+           fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+         } 
+         
+         Float_t coefnow      = coef[(Int_t)(col*rowMax+row)]; 
+         
+         (* fDebugStreamer) << "PutMeanValueOtherVectorFit"<<
+           "detector="<<detector<<
+           "sector="<<sector<<
+           "row="<<row<<
+           "col="<<col<<
+           "before="<<value<<
+           "after="<<coefnow<<
+           "\n";  
+       }
+      } // Col
+    } // Row
+  }
+  
+}
+//______________________________________________________________________
+void AliTRDCalibraFit::PutMeanValueOtherVectorFit2(Int_t ofwhat, Bool_t perdetector){
+  //
+  // ofwhat is equaled to 0: mean value of all passing detectors
+  // ofwhat is equaled to 1: mean value of the detector, otherwise supermodule, otherwise all
+  //
+
+  Int_t loop = (Int_t) fVectorFit2.GetEntriesFast();
+  if(loop != 540) {
+    AliInfo("The Vector Fit is not complete!");
+    return;
+  }
+  Int_t detector = -1;
+  Int_t sector = -1;
+  Float_t value  = 0.0;
+
+  /////////////////////////////////
+  // Calculate the mean values
+  ////////////////////////////////
+  // Initialisation
+  ////////////////////////
+  Double_t meanAll = 0.0;
+  Double_t meanSupermodule[18];
+  Double_t meanDetector[540];
+  Int_t countAll = 0;
+  Int_t countSupermodule[18];
+  Int_t countDetector[540];
+  for(Int_t sm = 0; sm < 18; sm++){
+    meanSupermodule[sm] = 0.0;
+    countSupermodule[sm] = 0;
+  }
+  for(Int_t det = 0; det < 540; det++){
+    meanDetector[det] = 0.0;
+    countDetector[det] = 0;
+  }
+  // compute
+  ////////////
+  for (Int_t k = 0; k < loop; k++) {
+    detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
+    sector = GetSector(detector);
+    if(perdetector){
+      value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[0];
+      if(value < 70.0) {
+       meanDetector[detector] += value;
+       countDetector[detector]++;
+       meanSupermodule[sector] += value;
+       countSupermodule[sector]++;
+       meanAll += value;
+       countAll++;
+      }
+    }
+    else {
+      Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+      Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
+      for (Int_t row = 0; row < rowMax; row++) {
+       for (Int_t col = 0; col < colMax; col++) {
+         value = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+         if(value < 70.0) {
+           meanDetector[detector] += value;
+           countDetector[detector]++;
+           meanSupermodule[sector] += value;
+           countSupermodule[sector]++;
+           meanAll += value;
+           countAll++;
+         }
+         
+       } // Col
+      } // Row
+    }
+  }  
+  if(countAll > 0) meanAll = meanAll/countAll;
+  for(Int_t sm = 0; sm < 18; sm++){
+    if(countSupermodule[sm] > 0) meanSupermodule[sm] = meanSupermodule[sm]/countSupermodule[sm];
+  }
+  for(Int_t det = 0; det < 540; det++){
+    if(countDetector[det] > 0) meanDetector[det] = meanDetector[det]/countDetector[det];
+  }
+  // Put the mean value for the no-fitted
+  /////////////////////////////////////////////  
+  for (Int_t k = 0; k < loop; k++) {
+    detector  = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetDetector();
+    sector = GetSector(detector);
+    Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
+    Int_t colMax    = fGeo->GetColMax(GetLayer(detector));
+    Float_t *coef = ((AliTRDFitInfo *) fVectorFit2.At(k))->GetCoef();
+
+    for (Int_t row = 0; row < rowMax; row++) {
+      for (Int_t col = 0; col < colMax; col++) {
+       value = coef[(Int_t)(col*rowMax+row)];
+       if(value > 70.0) {
+         if((ofwhat == 0) && (meanAll > 0.0)) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
+         if(ofwhat == 1){
+           if(meanDetector[detector] > 0.0) coef[(Int_t)(col*rowMax+row)] = meanDetector[detector]+100.0;
+           else if(meanSupermodule[sector] > 0.0) coef[(Int_t)(col*rowMax+row)] = meanSupermodule[sector]+100.0;
+           else if(meanAll > 0.0) coef[(Int_t)(col*rowMax+row)] = meanAll+100.0;
+         }  
+       }
+       // Debug
+       if(fDebugLevel > 1){
+         
+         if ( !fDebugStreamer ) {
+           //debug stream
+           TDirectory *backup = gDirectory;
+           fDebugStreamer = new TTreeSRedirector("TRDDebugFit.root");
+           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+         } 
+         
+         Float_t coefnow      = coef[(Int_t)(col*rowMax+row)]; 
+         
+         (* fDebugStreamer) << "PutMeanValueOtherVectorFit2"<<
+           "detector="<<detector<<
+           "sector="<<sector<<
+           "row="<<row<<
+           "col="<<col<<
+           "before="<<value<<
+           "after="<<coefnow<<
+           "\n";  
+       }
+      } // Col
+    } // Row
+  }
+  
+}
 //_____________________________________________________________________________
 AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(TObjArray *vectorFit, Bool_t perdetector)
 {
@@ -1331,7 +1674,8 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(TObjArray *vectorFit, Bool
   if(loop != 540) AliInfo("The Vector Fit is not complete!");
   Int_t detector = -1;
   Float_t value  = 0.0;
-
+  
+  //
   for (Int_t k = 0; k < loop; k++) {
     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();
     Float_t mean  = 0.0;
@@ -1357,7 +1701,7 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectVdrift(TObjArray *vectorFit, Bool
   return object;
 }
 //_____________________________________________________________________________
-AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(TObjArray *vectorFit, Double_t scaleFitFactor, Bool_t perdetector)
+AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(TObjArray *vectorFit, Bool_t meanOtherBefore, Double_t scaleFitFactor, Bool_t perdetector)
 {
   //
   // It creates the AliTRDCalDet object from the AliTRDFitInfo
@@ -1379,7 +1723,10 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(TObjArray *vectorFit, Double
     Float_t mean  = 0.0;
     if(perdetector){
       value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
-      if(value > 0) value = value*scaleFitFactor;
+      if(!meanOtherBefore){
+       if(value > 0) value = value*scaleFitFactor;
+      }
+      else value = value*scaleFitFactor;
       mean = TMath::Abs(value);
     }
     else{
@@ -1389,7 +1736,10 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectGain(TObjArray *vectorFit, Double
       for (Int_t row = 0; row < rowMax; row++) {
        for (Int_t col = 0; col < colMax; col++) {
          value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
-         if(value > 0) value = value*scaleFitFactor;
+         if(!meanOtherBefore) {
+           if(value > 0) value = value*scaleFitFactor;
+         }
+         else value = value*scaleFitFactor;
          mean += TMath::Abs(value);
          count++;       
        } // Col
@@ -1422,7 +1772,11 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(TObjArray *vectorFit, Bool_t p
     detector  = ((AliTRDFitInfo *) vectorFit->At(k))->GetDetector();   
     Float_t min  = 100.0;
     if(perdetector){
-      min = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
+      value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[0];
+      // check successful
+      if(value > 70.0) value = value-100.0;
+      //
+      min = value;
     }
     else{
       Int_t rowMax    = fGeo->GetRowMax(GetLayer(detector),GetStack(detector),GetSector(detector));
@@ -1430,6 +1784,9 @@ AliTRDCalDet *AliTRDCalibraFit::CreateDetObjectT0(TObjArray *vectorFit, Bool_t p
       for (Int_t row = 0; row < rowMax; row++) {
        for (Int_t col = 0; col < colMax; col++) {
          value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+         // check successful
+         if(value > 70.0) value = value-100.0;
+         //
          if(min > value) min = value;
        } // Col
       } // Row
@@ -1613,6 +1970,9 @@ TObject *AliTRDCalibraFit::CreatePadObjectT0(TObjArray *vectorFit, AliTRDCalDet
       for (Int_t row = 0; row < rowMax; row++) {
        for (Int_t col = 0; col < colMax; col++) {
          value = ((AliTRDFitInfo *) vectorFit->At(k))->GetCoef()[(Int_t)(col*rowMax+row)];
+         // check successful
+         if(value > 70.0) value = value - 100.0;
+         //
          calROC->SetValue(col,row,value-min);
        } // Col
       } // Row
@@ -1937,7 +2297,7 @@ Bool_t AliTRDCalibraFit::InitFit(Int_t nbins, Int_t i)
   
   // Quick verification that we have the good pad calibration mode!
   if (fNumberOfBinsExpected != nbins) {
-    AliInfo("It doesn't correspond to the mode of pad group calibration!");
+    AliInfo(Form("It doesn't correspond to the mode of pad group calibration: expected %d and seen %d!",fNumberOfBinsExpected,nbins));
     return kFALSE;
   }
   
@@ -2175,6 +2535,17 @@ void AliTRDCalibraFit::CalculNumberOfBinsExpected(Int_t i)
   //
   
   fNumberOfBinsExpected = 0;
+  // All
+  if((fCalibraMode->GetNz(i) == 100) && (fCalibraMode->GetNrphi(i) == 100)){
+    fNumberOfBinsExpected = 1;
+    return;
+  }
+  // Per supermodule
+  if((fCalibraMode->GetNz(i) == 10) && (fCalibraMode->GetNrphi(i) == 10)){
+    fNumberOfBinsExpected = 18;
+    return;
+  }
+  // More
   fCalibraMode->ModePadCalibration(2,i);
   fCalibraMode->ModePadFragmentation(0,2,0,i);
   fCalibraMode->SetDetChamb2(i);
@@ -2247,18 +2618,19 @@ void AliTRDCalibraFit::UpdatefCountDetAndfCount(Int_t idect, Int_t i)
   // Doesn't matter for 2
   //
   if (fCount == idect) {
-     // On en est au detector
-     fCountDet += 1;
-     // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
-     fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
-     fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+    // On en est au detector (or first detector in the group)
+    fCountDet += 1;
+    AliDebug(2,Form("We are at the detector %d\n",fCountDet));
+    // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+    fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),i);
+    fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
                                       ,(Int_t) GetStack(fCountDet)
                                        ,(Int_t) GetSector(fCountDet),i);
-     // Set for the next detector
-     fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
-     // calib objects
-     SetCalROC(i);
-    }
+    // Set for the next detector
+    fCount += fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i);
+    // calib objects
+    SetCalROC(i);
+  }
 }
 //____________Functions for initialising the AliTRDCalibraFit in the code_________
 void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
@@ -2266,10 +2638,13 @@ void AliTRDCalibraFit::ReconstructFitRowMinRowMax(Int_t idect, Int_t i)
   //
   // Reconstruct the min pad row, max pad row, min pad col and
   // max pad col of the calibration group for the Fit functions
+  // idect is the calibration group inside the detector
   //
   if (fDebugLevel !=  1) {
     fCalibraMode->ReconstructionRowPadGroup((Int_t) (idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))),i);
   }
+  AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the local calibration group is %d",idect-(fCount-(fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)))));
+  AliDebug(2,Form("AliTRDCalibraFit::ReconstructFitRowMinRowMax: the number of group per detector is %d",fCalibraMode->GetNfragZ(i)*fCalibraMode->GetNfragRphi(i)));
 }
 //____________Functions for initialising the AliTRDCalibraFit in the code_________
 Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
@@ -2283,7 +2658,89 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
   if (fDebugLevel == 1) {
     AliInfo("The element has not enough statistic to be fitted");
   }
-  
+  else if (fNbDet > 0){
+    Int_t firstdetector = fCountDet;
+    Int_t lastdetector  = fCountDet+fNbDet;
+    AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
+                ,idect,firstdetector,lastdetector));
+    // loop over detectors
+    for(Int_t det = firstdetector; det < lastdetector; det++){
+
+      //Set the calibration object again
+      fCountDet = det;
+      SetCalROC(0);   
+
+      // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+      // Put them at 1
+      fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
+      fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+                                        ,(Int_t) GetStack(fCountDet)
+                                        ,(Int_t) GetSector(fCountDet),0);
+      // Reconstruct row min row max
+      ReconstructFitRowMinRowMax(idect,0);      
+
+      // Calcul the coef from the database choosen for the detector
+      CalculChargeCoefMean(kFALSE);
+      
+      //stack 2, not stack 2
+      Int_t factor = 0;
+      if(GetStack(fCountDet) == 2) factor = 12;
+      else factor = 16;
+      
+      // Fill the fCurrentCoefDetector with negative value to say: not fitted
+      for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
+       for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
+         fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
+       }
+      }
+      
+      //Put default value negative
+      fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+      fCurrentCoefE   = 0.0;
+      
+      // Fill the stuff
+      FillVectorFit();
+      // Debug
+      if(fDebugLevel > 1){ 
+       
+       if ( !fDebugStreamer ) {
+         //debug stream
+         TDirectory *backup = gDirectory;
+         fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
+         if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+       } 
+       
+       Int_t   detector   = fCountDet;
+       Int_t   caligroup  = idect;
+       Short_t rowmin     = fCalibraMode->GetRowMin(0);
+       Short_t rowmax     = fCalibraMode->GetRowMax(0);
+       Short_t colmin     = fCalibraMode->GetColMin(0);
+       Short_t colmax     = fCalibraMode->GetColMax(0);
+       Float_t gf         = fCurrentCoef[0]; 
+       Float_t gfs        = fCurrentCoef[1]; 
+       Float_t gfE        = fCurrentCoefE;
+       
+       (*fDebugStreamer) << "FillFillCH" <<
+         "detector=" << detector <<
+         "caligroup=" << caligroup <<
+         "rowmin=" << rowmin <<
+         "rowmax=" << rowmax <<
+         "colmin=" << colmin <<
+         "colmax=" << colmax <<
+         "gf=" << gf <<
+         "gfs=" << gfs <<
+         "gfE=" << gfE <<
+         "\n"; 
+       
+      }
+      // Reset
+      for (Int_t k = 0; k < 2304; k++) {
+       fCurrentCoefDetector[k] = 0.0;
+      }
+      
+    }// loop detector
+    AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
+  }
   else {
 
     AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
@@ -2316,7 +2773,7 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticCH(Int_t idect)
 
 
 //____________Functions for initialising the AliTRDCalibraFit in the code_________
-Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect)
+Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect,Double_t nentries)
 {
   //
   // For the case where there are not enough entries in the histograms
@@ -2326,6 +2783,105 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect)
   if (fDebugLevel == 1) {
     AliInfo("The element has not enough statistic to be fitted");
   }
+  else if (fNbDet > 0) {
+
+    Int_t firstdetector = fCountDet;
+    Int_t lastdetector  = fCountDet+fNbDet;
+    AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
+                ,idect,firstdetector,lastdetector));
+    // loop over detectors
+    for(Int_t det = firstdetector; det < lastdetector; det++){
+
+      //Set the calibration object again
+      fCountDet = det;
+      SetCalROC(1);   
+
+      // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+      // Put them at 1
+      fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
+      fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+                                        ,(Int_t) GetStack(fCountDet)
+                                        ,(Int_t) GetSector(fCountDet),1);
+      // Reconstruct row min row max
+      ReconstructFitRowMinRowMax(idect,1);      
+
+      // Calcul the coef from the database choosen for the detector
+      CalculVdriftCoefMean();
+      CalculT0CoefMean();
+      
+      //stack 2, not stack 2
+      Int_t factor = 0;
+      if(GetStack(fCountDet) == 2) factor = 12;
+      else factor = 16;
+      
+      // Fill the fCurrentCoefDetector with negative value to say: not fitted
+      for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
+       for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
+         fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
+         fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
+       }
+      }
+      
+      //Put default value negative
+      fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
+      fCurrentCoefE    = 0.0;
+      fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+      fCurrentCoefE2   = 0.0;
+            
+      // Fill the stuff
+      FillVectorFit();
+      FillVectorFit2();
+      // Debug
+      if(fDebugLevel > 1){ 
+
+       if ( !fDebugStreamer ) {
+         //debug stream
+         TDirectory *backup = gDirectory;
+         fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
+         if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+       } 
+       
+       
+       Int_t   detector     = fCountDet;
+       Int_t   caligroup    = idect;
+       Short_t rowmin       = fCalibraMode->GetRowMin(1);
+       Short_t rowmax       = fCalibraMode->GetRowMax(1);
+       Short_t colmin       = fCalibraMode->GetColMin(1);
+       Short_t colmax       = fCalibraMode->GetColMax(1);
+       Float_t vf           = fCurrentCoef[0]; 
+       Float_t vs           = fCurrentCoef[1]; 
+       Float_t vfE          = fCurrentCoefE;
+       Float_t t0f          = fCurrentCoef2[0]; 
+       Float_t t0s          = fCurrentCoef2[1]; 
+       Float_t t0E          = fCurrentCoefE2;
+       
+       
+       
+       (* fDebugStreamer) << "FillFillPH"<<
+       "detector="<<detector<<
+         "nentries="<<nentries<<
+         "caligroup="<<caligroup<<
+         "rowmin="<<rowmin<<
+         "rowmax="<<rowmax<<
+         "colmin="<<colmin<<
+         "colmax="<<colmax<<
+         "vf="<<vf<<
+         "vs="<<vs<<
+         "vfE="<<vfE<<
+         "t0f="<<t0f<<
+         "t0s="<<t0s<<
+         "t0E="<<t0E<<
+         "\n";  
+      }
+      // Reset
+      for (Int_t k = 0; k < 2304; k++) {
+       fCurrentCoefDetector[k] = 0.0;
+       fCurrentCoefDetector2[k] = 0.0;
+      }
+      
+    }// loop detector
+    AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
+  }    
   else {
 
     AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
@@ -2344,22 +2900,22 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticPH(Int_t idect)
     for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
       for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
        fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
-       fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1];
+       fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[1] + 100.0;
       }
     }
 
     // Put the default value
     fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
     fCurrentCoefE    = 0.0;
-    fCurrentCoef2[0] = fCurrentCoef2[1];
+    fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
     fCurrentCoefE2   = 0.0;
      
-    FillFillPH(idect);
+    FillFillPH(idect,nentries);
     
   }
   
   return kTRUE;
-
+  
 }
 
 
@@ -2375,6 +2931,92 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticPRF(Int_t idect)
   if (fDebugLevel == 1) {
     AliInfo("The element has not enough statistic to be fitted");
   }
+  else if (fNbDet > 0){
+  
+    Int_t firstdetector = fCountDet;
+    Int_t lastdetector  = fCountDet+fNbDet;
+    AliInfo(Form("The element %d containing the detectors %d to %d has not enough statistic to be fitted"
+                ,idect,firstdetector,lastdetector));
+    
+    // loop over detectors
+    for(Int_t det = firstdetector; det < lastdetector; det++){
+
+      //Set the calibration object again
+      fCountDet = det;
+      SetCalROC(2);   
+
+      // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+      // Put them at 1
+      fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
+      fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+                                        ,(Int_t) GetStack(fCountDet)
+                                        ,(Int_t) GetSector(fCountDet),2);
+      // Reconstruct row min row max
+      ReconstructFitRowMinRowMax(idect,2);      
+
+      // Calcul the coef from the database choosen for the detector
+      CalculPRFCoefMean();
+      
+      //stack 2, not stack 2
+      Int_t factor = 0;
+      if(GetStack(fCountDet) == 2) factor = 12;
+      else factor = 16;
+      
+      // Fill the fCurrentCoefDetector with negative value to say: not fitted
+      for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
+       for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
+         fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
+       }
+      }
+      
+      //Put default value negative
+      fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+      fCurrentCoefE   = 0.0;
+      
+      // Fill the stuff
+      FillVectorFit();
+      // Debug
+      if(fDebugLevel > 1){
+       
+       if ( !fDebugStreamer ) {
+         //debug stream
+         TDirectory *backup = gDirectory;
+         fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
+         if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+       } 
+       
+       Int_t   detector     = fCountDet;
+       Int_t   layer        = GetLayer(fCountDet);
+       Int_t   caligroup    = idect;
+       Short_t rowmin       = fCalibraMode->GetRowMin(2);
+       Short_t rowmax       = fCalibraMode->GetRowMax(2);
+       Short_t colmin       = fCalibraMode->GetColMin(2);
+       Short_t colmax       = fCalibraMode->GetColMax(2);
+       Float_t widf         = fCurrentCoef[0]; 
+       Float_t wids         = fCurrentCoef[1]; 
+       Float_t widfE        = fCurrentCoefE;
+       
+       (* fDebugStreamer) << "FillFillPRF"<<
+         "detector="<<detector<<
+         "layer="<<layer<<
+         "caligroup="<<caligroup<<
+         "rowmin="<<rowmin<<
+         "rowmax="<<rowmax<<
+         "colmin="<<colmin<<
+         "colmax="<<colmax<<
+         "widf="<<widf<<
+         "wids="<<wids<<
+         "widfE="<<widfE<<
+         "\n";  
+      }
+      // Reset
+      for (Int_t k = 0; k < 2304; k++) {
+       fCurrentCoefDetector[k] = 0.0;
+      }
+      
+    }// loop detector
+    AliDebug(2,Form("Check the count now: fCountDet %d",fCountDet));
+  }
   else {
     
     AliInfo(Form("The element %d in this detector %d has not enough statistic to be fitted"
@@ -2391,12 +3033,12 @@ Bool_t AliTRDCalibraFit::NotEnoughStatisticPRF(Int_t idect)
     // Fill the fCurrentCoefDetector
     for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
       for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
-       fCurrentCoefDetector[(Int_t)(j*factor+k)] = -fCurrentCoef[1];
+       fCurrentCoefDetector[(Int_t)(j*factor+k)] = -TMath::Abs(fCurrentCoef[1]);
       }
     }
 
     // Put the default value
-    fCurrentCoef[0] = -fCurrentCoef[1];
+    fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
     fCurrentCoefE   = 0.0;
     
     FillFillPRF(idect);
@@ -2450,26 +3092,110 @@ Bool_t AliTRDCalibraFit::FillInfosFitCH(Int_t idect)
   //
 
   if (fDebugLevel != 1) {
-    
-    Int_t factor = 0;
-    if(GetStack(fCountDet) == 2) factor = 12;
-    else factor = 16; 
-    
-    for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
-      for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
-       fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+    if (fNbDet > 0){
+      Int_t firstdetector = fCountDet;
+      Int_t lastdetector  = fCountDet+fNbDet;
+      AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
+                  ,idect,firstdetector,lastdetector));
+      // loop over detectors
+      for(Int_t det = firstdetector; det < lastdetector; det++){
+       
+       //Set the calibration object again
+       fCountDet = det;
+       SetCalROC(0);   
+       
+       // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+       // Put them at 1
+       fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),0);
+       fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+                                          ,(Int_t) GetStack(fCountDet)
+                                          ,(Int_t) GetSector(fCountDet),0);
+       // Reconstruct row min row max
+       ReconstructFitRowMinRowMax(idect,0);      
+       
+       // Calcul the coef from the database choosen for the detector
+       if(fCurrentCoef[0] < 0.0) CalculChargeCoefMean(kFALSE);
+       else CalculChargeCoefMean(kTRUE);
+       
+       //stack 2, not stack 2
+       Int_t factor = 0;
+       if(GetStack(fCountDet) == 2) factor = 12;
+       else factor = 16;
+       
+       // Fill the fCurrentCoefDetector with negative value to say: not fitted
+       Double_t coeftoput = 1.0;
+       if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
+       else coeftoput = fCurrentCoef[0];
+       for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
+         for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
+           fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
+         }
+       }
+       
+       // Fill the stuff
+       FillVectorFit();
+       // Debug
+       if(fDebugLevel > 1){ 
+         
+         if ( !fDebugStreamer ) {
+           //debug stream
+           TDirectory *backup = gDirectory;
+           fDebugStreamer = new TTreeSRedirector("TRDDebugFitCH.root");
+           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+         } 
+         
+         Int_t   detector   = fCountDet;
+         Int_t   caligroup  = idect;
+         Short_t rowmin     = fCalibraMode->GetRowMin(0);
+         Short_t rowmax     = fCalibraMode->GetRowMax(0);
+         Short_t colmin     = fCalibraMode->GetColMin(0);
+         Short_t colmax     = fCalibraMode->GetColMax(0);
+         Float_t gf         = fCurrentCoef[0]; 
+         Float_t gfs        = fCurrentCoef[1]; 
+         Float_t gfE        = fCurrentCoefE;
+         
+         (*fDebugStreamer) << "FillFillCH" <<
+           "detector=" << detector <<
+           "caligroup=" << caligroup <<
+           "rowmin=" << rowmin <<
+           "rowmax=" << rowmax <<
+           "colmin=" << colmin <<
+           "colmax=" << colmax <<
+           "gf=" << gf <<
+           "gfs=" << gfs <<
+           "gfE=" << gfE <<
+           "\n"; 
+         
+       }
+       // Reset
+       for (Int_t k = 0; k < 2304; k++) {
+         fCurrentCoefDetector[k] = 0.0;
+       }
+       
+      }// loop detector
+      //printf("Check the count now: fCountDet %d\n",fCountDet);
+    }
+    else{
+      
+      Int_t factor = 0;
+      if(GetStack(fCountDet) == 2) factor = 12;
+      else factor = 16; 
+      
+      for (Int_t k = fCalibraMode->GetRowMin(0); k < fCalibraMode->GetRowMax(0); k++) {
+       for (Int_t j = fCalibraMode->GetColMin(0); j < fCalibraMode->GetColMax(0); j++) {
+         fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+       }
       }
+      
+      FillFillCH(idect);
     }
-    
-    FillFillCH(idect);
-    
   }
 
   return kTRUE;
 
 }
 //____________Functions for initialising the AliTRDCalibraFit in the code_________
-Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect)
+Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect,Double_t nentries)
 {
   //
   // Fill the coefficients found with the fits or other
@@ -2477,18 +3203,124 @@ Bool_t AliTRDCalibraFit::FillInfosFitPH(Int_t idect)
   //
 
   if (fDebugLevel != 1) {
-
-    Int_t factor = 0;
-    if(GetStack(fCountDet) == 2) factor = 12;
-    else factor = 16; 
-    
-    for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
-      for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
-       fCurrentCoefDetector[(Int_t)(j*factor+k)]  = fCurrentCoef[0];
-       fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
-      }
-    }                
-    FillFillPH(idect);
+    if (fNbDet > 0){
+      
+      Int_t firstdetector = fCountDet;
+      Int_t lastdetector  = fCountDet+fNbDet;
+      AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
+                  ,idect,firstdetector,lastdetector));
+      
+      // loop over detectors
+      for(Int_t det = firstdetector; det < lastdetector; det++){
+       
+       //Set the calibration object again
+       fCountDet = det;
+       SetCalROC(1);   
+       
+       // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+       // Put them at 1
+       fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),1);
+       fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+                                          ,(Int_t) GetStack(fCountDet)
+                                          ,(Int_t) GetSector(fCountDet),1);
+       // Reconstruct row min row max
+       ReconstructFitRowMinRowMax(idect,1);      
+       
+       // Calcul the coef from the database choosen for the detector
+       CalculVdriftCoefMean();
+       CalculT0CoefMean();
+               
+       //stack 2, not stack 2
+       Int_t factor = 0;
+       if(GetStack(fCountDet) == 2) factor = 12;
+       else factor = 16;
+       
+       // Fill the fCurrentCoefDetector with negative value to say: not fitted
+       Double_t coeftoput  = 1.5;
+       Double_t coeftoput2 = 0.0; 
+
+       if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
+       else coeftoput = fCurrentCoef[0];
+
+       if(fCurrentCoef2[0] > 70.0) coeftoput2 = fCurrentCoef2[1] + 100.0;
+       else coeftoput2 = fCurrentCoef2[0];
+
+       for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
+         for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
+           fCurrentCoefDetector[(Int_t)(j*factor+k)]  = coeftoput;
+           fCurrentCoefDetector2[(Int_t)(j*factor+k)] = coeftoput2;
+         }
+       }
+       
+       // Fill the stuff
+       FillVectorFit();
+       FillVectorFit2();
+       // Debug
+       if(fDebugLevel > 1){ 
+         
+         if ( !fDebugStreamer ) {
+           //debug stream
+           TDirectory *backup = gDirectory;
+           fDebugStreamer = new TTreeSRedirector("TRDDebugFitPH.root");
+           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+         } 
+         
+         
+         Int_t   detector     = fCountDet;
+         Int_t   caligroup    = idect;
+         Short_t rowmin       = fCalibraMode->GetRowMin(1);
+         Short_t rowmax       = fCalibraMode->GetRowMax(1);
+         Short_t colmin       = fCalibraMode->GetColMin(1);
+         Short_t colmax       = fCalibraMode->GetColMax(1);
+         Float_t vf           = fCurrentCoef[0]; 
+         Float_t vs           = fCurrentCoef[1]; 
+         Float_t vfE          = fCurrentCoefE;
+         Float_t t0f          = fCurrentCoef2[0]; 
+         Float_t t0s          = fCurrentCoef2[1]; 
+         Float_t t0E          = fCurrentCoefE2;
+         
+         
+         
+         (* fDebugStreamer) << "FillFillPH"<<
+           "detector="<<detector<<
+           "nentries="<<nentries<<
+           "caligroup="<<caligroup<<
+           "rowmin="<<rowmin<<
+           "rowmax="<<rowmax<<
+           "colmin="<<colmin<<
+           "colmax="<<colmax<<
+           "vf="<<vf<<
+           "vs="<<vs<<
+           "vfE="<<vfE<<
+           "t0f="<<t0f<<
+           "t0s="<<t0s<<
+           "t0E="<<t0E<<
+           "\n";  
+       }
+       // Reset
+       for (Int_t k = 0; k < 2304; k++) {
+         fCurrentCoefDetector[k] = 0.0;
+         fCurrentCoefDetector2[k] = 0.0;
+       }
+       
+      }// loop detector
+      //printf("Check the count now: fCountDet %d\n",fCountDet);
+    }
+    else {
+      
+      Int_t factor = 0;
+      if(GetStack(fCountDet) == 2) factor = 12;
+      else factor = 16; 
+      
+      for (Int_t k = fCalibraMode->GetRowMin(1); k < fCalibraMode->GetRowMax(1); k++) {
+       for (Int_t j = fCalibraMode->GetColMin(1); j < fCalibraMode->GetColMax(1); j++) {
+         fCurrentCoefDetector[(Int_t)(j*factor+k)]  = fCurrentCoef[0];
+         fCurrentCoefDetector2[(Int_t)(j*factor+k)] = fCurrentCoef2[0];
+       }
+      }  
+      
+      FillFillPH(idect,nentries);
+    }
   }
   return kTRUE;
 }
@@ -2501,20 +3333,107 @@ Bool_t AliTRDCalibraFit::FillInfosFitPRF(Int_t idect)
   //
   
   if (fDebugLevel != 1) {
-
-    Int_t factor = 0;
-    if(GetStack(fCountDet) == 2) factor = 12;
-    else factor = 16; 
+    if (fNbDet > 0){
     
-    // Pointer to the branch
-    for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
-      for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
-       fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+      Int_t firstdetector = fCountDet;
+      Int_t lastdetector  = fCountDet+fNbDet;
+      AliInfo(Form("The element %d containing the detectors %d to %d has been fitted"
+                  ,idect,firstdetector,lastdetector));
+      
+      // loop over detectors
+      for(Int_t det = firstdetector; det < lastdetector; det++){
+       
+       //Set the calibration object again
+       fCountDet = det;
+       SetCalROC(2);   
+       
+       // Determination of fNnZ, fNnRphi, fNfragZ and fNfragRphi
+       // Put them at 1
+       fCalibraMode->ModePadCalibration((Int_t) GetStack(fCountDet),2);
+       fCalibraMode->ModePadFragmentation((Int_t) GetLayer(fCountDet)
+                                          ,(Int_t) GetStack(fCountDet)
+                                          ,(Int_t) GetSector(fCountDet),2);
+       // Reconstruct row min row max
+       ReconstructFitRowMinRowMax(idect,2);      
+       
+       // Calcul the coef from the database choosen for the detector
+       CalculPRFCoefMean();
+       
+       //stack 2, not stack 2
+       Int_t factor = 0;
+       if(GetStack(fCountDet) == 2) factor = 12;
+       else factor = 16;
+       
+       // Fill the fCurrentCoefDetector with negative value to say: not fitted
+       Double_t coeftoput = 1.0;
+       if(fCurrentCoef[0] < 0.0) coeftoput = - TMath::Abs(fCurrentCoef[1]);
+       else coeftoput = fCurrentCoef[0];
+       for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
+         for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
+           fCurrentCoefDetector[(Int_t)(j*factor+k)] = coeftoput;
+         }
+       }
+       
+       // Fill the stuff
+       FillVectorFit();
+       // Debug
+       if(fDebugLevel > 1){
+         
+         if ( !fDebugStreamer ) {
+           //debug stream
+           TDirectory *backup = gDirectory;
+           fDebugStreamer = new TTreeSRedirector("TRDDebugFitPRF.root");
+           if ( backup ) backup->cd();  //we don't want to be cd'd to the debug streamer
+         } 
+         
+         Int_t   detector     = fCountDet;
+         Int_t   layer        = GetLayer(fCountDet);
+         Int_t   caligroup    = idect;
+         Short_t rowmin       = fCalibraMode->GetRowMin(2);
+         Short_t rowmax       = fCalibraMode->GetRowMax(2);
+         Short_t colmin       = fCalibraMode->GetColMin(2);
+         Short_t colmax       = fCalibraMode->GetColMax(2);
+         Float_t widf         = fCurrentCoef[0]; 
+         Float_t wids         = fCurrentCoef[1]; 
+         Float_t widfE        = fCurrentCoefE;
+         
+         (* fDebugStreamer) << "FillFillPRF"<<
+           "detector="<<detector<<
+           "layer="<<layer<<
+           "caligroup="<<caligroup<<
+           "rowmin="<<rowmin<<
+           "rowmax="<<rowmax<<
+           "colmin="<<colmin<<
+           "colmax="<<colmax<<
+           "widf="<<widf<<
+           "wids="<<wids<<
+           "widfE="<<widfE<<
+           "\n";  
+       }
+       // Reset
+       for (Int_t k = 0; k < 2304; k++) {
+         fCurrentCoefDetector[k] = 0.0;
+       }
+       
+      }// loop detector
+      //printf("Check the count now: fCountDet %d\n",fCountDet);
+    }
+    else {
+      
+      Int_t factor = 0;
+      if(GetStack(fCountDet) == 2) factor = 12;
+      else factor = 16; 
+      
+      // Pointer to the branch
+      for (Int_t k = fCalibraMode->GetRowMin(2); k < fCalibraMode->GetRowMax(2); k++) {
+       for (Int_t j = fCalibraMode->GetColMin(2); j < fCalibraMode->GetColMax(2); j++) {
+         fCurrentCoefDetector[(Int_t)(j*factor+k)] = fCurrentCoef[0];
+       }
       }
+      FillFillPRF(idect);   
     }
-    FillFillPRF(idect);   
   }
-
+  
   return kTRUE;
 
 }
@@ -2591,7 +3510,7 @@ void AliTRDCalibraFit::FillFillCH(Int_t idect)
   }
 }
 //________________________________________________________________________________
-void AliTRDCalibraFit::FillFillPH(Int_t idect)
+void AliTRDCalibraFit::FillFillPH(Int_t idect,Double_t nentries)
 {
   //
   // DebugStream and fVectorFit and fVectorFit2
@@ -2635,6 +3554,7 @@ void AliTRDCalibraFit::FillFillPH(Int_t idect)
 
       (* fDebugStreamer) << "FillFillPH"<<
        "detector="<<detector<<
+       "nentries="<<nentries<<
        "caligroup="<<caligroup<<
        "rowmin="<<rowmin<<
        "rowmax="<<rowmax<<
@@ -2775,26 +3695,32 @@ Bool_t AliTRDCalibraFit::CalculT0CoefMean()
 
   fCurrentCoef2[1] = 0.0;
   if(fDebugLevel != 1){
-    if((fCalibraMode->GetNz(1) > 0) ||
-       (fCalibraMode->GetNrphi(1) > 0)) {
+    if(((fCalibraMode->GetNz(1) > 0) ||
+       (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1)    != 10) && (fCalibraMode->GetNz(1)    != 100))) {
+
       for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
        for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
          fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
        }
       }
+      
       fCurrentCoef2[1] = fCurrentCoef2[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
+    
     }
     else {
+     
       if(!fAccCDB){
        fCurrentCoef2[1] = fCalDet2->GetValue(fCountDet);
       }
       else{
+       
        for(Int_t row = 0; row < fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)); row++){
          for(Int_t col = 0; col < fGeo->GetColMax(GetLayer(fCountDet)); col++){
            fCurrentCoef2[1] += (Float_t) (fCalROC2->GetValue(col,row)+fCalDet2->GetValue(fCountDet));
          }
        }
        fCurrentCoef2[1] = fCurrentCoef2[1] / ((fGeo->GetRowMax(GetLayer(fCountDet),GetStack(fCountDet),GetSector(fCountDet)))*(fGeo->GetColMax(GetLayer(fCountDet))));
+      
       }
     }
   }
@@ -2811,8 +3737,8 @@ Bool_t AliTRDCalibraFit::CalculChargeCoefMean(Bool_t vrai)
 
   fCurrentCoef[1] = 0.0;
   if(fDebugLevel != 1){
-    if ((fCalibraMode->GetNz(0)    > 0) || 
-       (fCalibraMode->GetNrphi(0) > 0)) {
+    if (((fCalibraMode->GetNz(0)    > 0) || 
+       (fCalibraMode->GetNrphi(0) > 0)) && ((fCalibraMode->GetNz(0)    != 10) && (fCalibraMode->GetNz(0)    != 100))) {
       for (Int_t row = fCalibraMode->GetRowMin(0); row < fCalibraMode->GetRowMax(0); row++) {
        for (Int_t col = fCalibraMode->GetColMin(0); col < fCalibraMode->GetColMax(0); col++) {
          fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
@@ -2858,14 +3784,17 @@ Bool_t AliTRDCalibraFit::CalculVdriftCoefMean()
 
   fCurrentCoef[1] = 0.0;
   if(fDebugLevel != 1){
-    if ((fCalibraMode->GetNz(1)    > 0) || 
-       (fCalibraMode->GetNrphi(1) > 0)) {
+    if (((fCalibraMode->GetNz(1)    > 0) || 
+       (fCalibraMode->GetNrphi(1) > 0)) && ((fCalibraMode->GetNz(1)    != 10) && (fCalibraMode->GetNz(1)    != 100))) {
+      
       for (Int_t row = fCalibraMode->GetRowMin(1); row < fCalibraMode->GetRowMax(1); row++) {
        for (Int_t col = fCalibraMode->GetColMin(1); col < fCalibraMode->GetColMax(1); col++) {
          fCurrentCoef[1] += (Float_t) (fCalROC->GetValue(col,row)*fCalDet->GetValue(fCountDet));
        }
       }
+      
       fCurrentCoef[1] = fCurrentCoef[1] / ((fCalibraMode->GetColMax(1)-fCalibraMode->GetColMin(1))*(fCalibraMode->GetRowMax(1)-fCalibraMode->GetRowMin(1)));
+    
     }
     else {
       //per detectors
@@ -2932,18 +3861,27 @@ void AliTRDCalibraFit::SetCalROC(Int_t i)
     switch (i)
       {
       case 0: 
-       if(fCalROC) delete fCalROC;
-       fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet))); 
+       if( fCalROC ){ 
+         fCalROC->~AliTRDCalROC();
+         new(fCalROC) AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
+       }else fCalROC = new AliTRDCalROC(*(cal->GetGainFactorROC(fCountDet)));
        break;
       case 1:
-       if(fCalROC)  delete fCalROC;
-       if(fCalROC2) delete fCalROC2;
-       fCalROC  = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet))); 
-       fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet))); 
+       if( fCalROC ){ 
+         fCalROC->~AliTRDCalROC();
+         new(fCalROC) AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
+       }else fCalROC = new AliTRDCalROC(*(cal->GetVdriftROC(fCountDet)));
+       if( fCalROC2 ){ 
+         fCalROC2->~AliTRDCalROC();
+         new(fCalROC2) AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
+       }else fCalROC2 = new AliTRDCalROC(*(cal->GetT0ROC(fCountDet)));
        break;
       case 2:
-       if(fCalROC) delete fCalROC; 
-       fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet))); break; 
+       if( fCalROC ){ 
+         fCalROC->~AliTRDCalROC();
+         new(fCalROC) AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
+       }else fCalROC = new AliTRDCalROC(*(cal->GetPRFROC(fCountDet)));
+       break; 
       default: return;
       }
   }
@@ -3124,17 +4062,17 @@ void AliTRDCalibraFit::FitPente(TH1* projPH)
     if (fPhdt0 >= 0.0) {
       fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
       if (fCurrentCoef2[0] < -1.0) {
-        fCurrentCoef2[0] = fCurrentCoef2[1];
+        fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
       }
     }
     else {
-      fCurrentCoef2[0] = fCurrentCoef2[1];
+      fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
     }
 
   }
   else {
     fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
-    fCurrentCoef2[0] = fCurrentCoef2[1];
+    fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
   }
 
   if (fDebugLevel == 1) {
@@ -3459,8 +4397,20 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   }
   
   //check
-  if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) put = kFALSE;
-  if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) put = kFALSE;
+  if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) {
+    AliInfo("Too many fluctuations at the end!");
+    put = kFALSE;
+  }
+  if((projPH->GetBinContent(binmin)+projPH->GetBinError(binmin)) > (projPH->GetBinContent(binmin-1))) {
+    AliInfo("Too many fluctuations at the end!");
+    put = kFALSE;
+  }
+  if(pente->GetBinContent(binmin+1)==0){
+    AliInfo("No entries for the next bin!");
+    pente->SetBinContent(binmin,0);
+    if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
+  }
+
   
   x[0] = 0.0;
   x[1] = 0.0;
@@ -3498,15 +4448,29 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     c = CalculPolynomeLagrange4(x,y);
     //richtung +/-
     if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
-       (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) put = kFALSE;
+       (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+      //AliInfo("polynome 4 false 1");
+      put = kFALSE;
+    }
     if(((binmin+3) <= (nbins-1)) &&
        (pente->GetBinContent(binmin+3) <= pente->GetBinContent(binmin+2)) &&
        ((binmin-3) >= TMath::Min(binmax+4, projPH->GetNbinsX())) &&
-       (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) put = kFALSE;
+       (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) {
+      AliInfo("polynome 4 false 2");
+      put = kFALSE;
+    }
+    // poly 3
     if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1)) &&
-       (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) case1 = kTRUE;
+       (pente->GetBinContent(binmin-2) > pente->GetBinContent(binmin-1))) {
+      //AliInfo("polynome 4 case 1");
+      case1 = kTRUE;
+    }
     if((pente->GetBinContent(binmin+2) > pente->GetBinContent(binmin+1)) &&
-       (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) case4 = kTRUE;
+       (pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+      //AliInfo("polynome 4 case 4");
+      case4 = kTRUE;
+    }
+    
   }
   //case binmin = nbins-2
   //pol3 case 1
@@ -3526,7 +4490,10 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     c = CalculPolynomeLagrange3(x,y);
     //richtung +: nothing
     //richtung -
-    if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) case2 = kTRUE;
+    if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+      //AliInfo("polynome 3- case 2");
+      case2 = kTRUE;
+    }
   }
   //pol3 case 4
   if(((binmin <= (nbins-3)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
@@ -3544,7 +4511,10 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     //Calcul the polynome de Lagrange
     c = CalculPolynomeLagrange3(x,y);
     //richtung +
-    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) case2 = kTRUE;
+    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
+      //AliInfo("polynome 3+ case 2");      
+      case2 = kTRUE;
+    }
   }
   //pol2 case 5
   if((binmin <= (nbins-3)) && (binmin == TMath::Min(binmax+4, projPH->GetNbinsX()))){
@@ -3559,7 +4529,10 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     //Calcul the polynome de Lagrange
     c = CalculPolynomeLagrange2(x,y);
     //richtung +
-    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) put = kFALSE;
+    if((pente->GetBinContent(binmin+2) <= pente->GetBinContent(binmin+1))) {
+      //AliInfo("polynome 2+ false");
+      put = kFALSE;
+    }
   }
   //pol2 case 2
   if(((binmin == (nbins-2)) && ((binmin-1) == TMath::Min(binmax+4, projPH->GetNbinsX()))) ||
@@ -3594,7 +4567,10 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     //fluctuation too big!
     //richtung +: nothing
     //richtung -
-    if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) put = kFALSE;
+    if((pente->GetBinContent(binmin-2) <= pente->GetBinContent(binmin-1))) {
+      //AliInfo("polynome 2- false ");
+      put = kFALSE;
+    }
   }
   if((binmin == (nbins-1)) && ((binmin-2) < TMath::Min(binmax+4, projPH->GetNbinsX()))) {
     put = kFALSE;
@@ -3607,7 +4583,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     AliInfo("For the drift...problem!");
   }
   //pass but should not happen
-  if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+4, projPH->GetNbinsX()))){
+  if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+6, projPH->GetNbinsX()))){
     put = kFALSE;
     AliInfo("For the drift...problem!");
   }
@@ -3630,6 +4606,9 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     }
     fPhd[2] = placeminimum;
   }
+  //printf("La fin %d\n",((Int_t)(fPhd[2]*10.0))+2);
+  if((((Int_t)(fPhd[2]*10.0))+2) >= projPH->GetNbinsX()) fPhd[2] = 0.0;
+  if(((((Int_t)(fPhd[2]*10.0))+2) < projPH->GetNbinsX()) && (projPH->GetBinContent(((Int_t)(fPhd[2]*10.0))+2)==0)) fPhd[2] = 0.0;
   
   Float_t fPhdt0  = 0.0;
   Float_t t0Shift = 0.0;
@@ -3651,17 +4630,31 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     if (fPhdt0 >= 0.0) {
       fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
       if (fCurrentCoef2[0] < -1.0) {
-        fCurrentCoef2[0] = fCurrentCoef2[1];
+        fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
       }
     }
     else {
-      fCurrentCoef2[0] = fCurrentCoef2[1];
+      fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
     }
   }
   else {
-    fCurrentCoef[0]      = -TMath::Abs(fCurrentCoef[1]);
-    fCurrentCoef2[0]     = fCurrentCoef2[1];
-    //printf("Fit failed!\n");
+    if((fPhd[1] > fPhd[0]) &&
+       (put)) {
+      if (fPhdt0 >= 0.0) {
+       fCurrentCoef2[0] = (fPhdt0 - t0Shift) / widbins;
+       if (fCurrentCoef2[0] < -1.0) {
+         fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+       }
+      }
+      else {
+       fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
+      }
+    }
+    else{
+      fCurrentCoef[0]      = -TMath::Abs(fCurrentCoef[1]);
+      fCurrentCoef2[0]     = fCurrentCoef2[1] + 100.0;
+      //printf("Fit failed!\n");
+    }
   }
   
   if (fDebugLevel == 1) {
@@ -3695,6 +4688,10 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
     if(line) delete line;
 
   }
+
+  //Provisoire
+  //if(fCurrentCoef[0] > 1.7) fCurrentCoef[0] = -TMath::Abs(fCurrentCoef[1]);
+  //if((fCurrentCoef2[0] > 2.6) || (fCurrentCoef2[0] < 2.1)) fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
   
   projPH->SetDirectory(0);
 
@@ -3771,7 +4768,7 @@ void AliTRDCalibraFit::FitPH(TH1* projPH, Int_t idect)
     } 
     else {
       fCurrentCoef[0]     = -TMath::Abs(fCurrentCoef[1]);
-      fCurrentCoef2[0]    = fCurrentCoef2[1];
+      fCurrentCoef2[0]    = fCurrentCoef2[1] + 100.0;
     }
  
   }
@@ -3779,7 +4776,7 @@ void AliTRDCalibraFit::FitPH(TH1* projPH, Int_t idect)
 
     // Put the default value
     fCurrentCoef[0]  = -TMath::Abs(fCurrentCoef[1]);
-    fCurrentCoef2[0] = fCurrentCoef2[1];
+    fCurrentCoef2[0] = fCurrentCoef2[1] + 100.0;
   }
 
   if (fDebugLevel != 1) {
index 31cb3e8..93db143 100644 (file)
@@ -44,6 +44,7 @@ class AliTRDCalibraFit : public TObject {
   static AliTRDCalibraFit *Instance();
   static void Terminate();
   static void Destroy();
+  void DestroyDebugStreamer();
 
   AliTRDCalibraFit(const AliTRDCalibraFit &c);
   AliTRDCalibraFit &operator=(const AliTRDCalibraFit &) { return *this; }
@@ -81,8 +82,10 @@ class AliTRDCalibraFit : public TObject {
        Double_t *CalculPolynomeLagrange4(Double_t *x, Double_t *y) const;
        
        // Fill the database
+       void         PutMeanValueOtherVectorFit(Int_t ofwhat = 1, Bool_t perdetector = kFALSE);
+       void         PutMeanValueOtherVectorFit2(Int_t ofwhat = 1, Bool_t perdetector = kFALSE);
        AliTRDCalDet *CreateDetObjectVdrift(TObjArray *vectorFit, Bool_t perdetector = kFALSE);
-       AliTRDCalDet *CreateDetObjectGain(TObjArray *vectorFit, Double_t scaleFitFactor = 0.02431, Bool_t perdetector = kTRUE);
+       AliTRDCalDet *CreateDetObjectGain(TObjArray *vectorFit, Bool_t meanOtherBefore=kTRUE, Double_t scaleFitFactor = 0.02431, Bool_t perdetector = kTRUE);
        AliTRDCalDet *CreateDetObjectT0(TObjArray *vectorFit, Bool_t perdetector = kFALSE);
        AliTRDCalDet *CreateDetObjectLorentzAngle(TObjArray *vectorFit);
        
@@ -153,7 +156,7 @@ class AliTRDCalibraFit : public TObject {
  protected:
        
        // Geometry
-       AliTRDgeometry  *fGeo;                    //! The TRD geometry
+       AliTRDgeometry  *fGeo;               //! The TRD geometry
        
        
        Int_t        fNumberOfBinsExpected;  // Number of bins expected  
@@ -200,8 +203,9 @@ class AliTRDCalibraFit : public TObject {
        Int_t    fDect2;                  // Last calibration group that will be called to be maybe fitted
        Double_t fScaleFitFactor;         // Scale factor of the fit results for the gain
        Int_t    fEntriesCurrent;         // Entries in the current histo
-       Int_t    fCountDet;               // Current detector
+       Int_t    fCountDet;               // Current detector (or first in the group)
        Int_t    fCount;                  // When the next detector comes
+       Int_t    fNbDet;                  // Number of detector in the group
        
        // Current calib object
        AliTRDCalDet *fCalDet;            // Current calib object
@@ -232,7 +236,7 @@ class AliTRDCalibraFit : public TObject {
         void      SetCoef(Float_t *coef)                   { fCoef = coef;            }
         void      SetDetector(Int_t detector)              { fDetector = detector;    }
         
-        Float_t  *GetCoef() const                          { return fCoef;            }
+        Float_t  *GetCoef()                                { return fCoef;            }
         Int_t     GetDetector() const                      { return fDetector;        }
         
        protected:
@@ -258,18 +262,18 @@ class AliTRDCalibraFit : public TObject {
        
        // Not enough Statistics
        Bool_t   NotEnoughStatisticCH(Int_t idect);
-       Bool_t   NotEnoughStatisticPH(Int_t idect);
+       Bool_t   NotEnoughStatisticPH(Int_t idect,Double_t nentries);
        Bool_t   NotEnoughStatisticPRF(Int_t idect);
        Bool_t   NotEnoughStatisticLinearFitter();
        
        // Fill Infos Fit
        Bool_t   FillInfosFitCH(Int_t idect);
-       Bool_t   FillInfosFitPH(Int_t idect);
+       Bool_t   FillInfosFitPH(Int_t idect,Double_t nentries);
        Bool_t   FillInfosFitPRF(Int_t idect);
        Bool_t   FillInfosFitLinearFitter();
        
        void     FillFillCH(Int_t idect);
-       void     FillFillPH(Int_t idect);
+       void     FillFillPH(Int_t idect,Double_t nentries);
        void     FillFillPRF(Int_t idect);
        void     FillFillLinearFitter();
        
index ec48e53..21c73ff 100644 (file)
 */
 //End_Html 
 //
+//
+// Moreover two other more general granularities:
+// It can not work with AliTRDCalibraVector
+// 10 corresponds to per supermodule
+// 100 all together
 //                            
 //////////////////////////////////////////////////////////////////////////////////////
 
@@ -142,6 +147,28 @@ AliTRDCalibraMode::~AliTRDCalibraMode()
 }
 
 //_____________________________________________________________________________
+void AliTRDCalibraMode::SetPerSuperModule(Int_t i)
+{
+  //
+  // Set the mode of calibration group per supermodule
+  // 
+
+  fNz[i] = 10;
+  fNrphi[i] = 10; 
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraMode::SetAllTogether(Int_t i)
+{
+  //
+  // Set the mode of calibration group all together
+  // 
+
+  fNz[i] = 100;
+  fNrphi[i] = 100; 
+}
+
+//_____________________________________________________________________________
 void AliTRDCalibraMode::SetNz(Int_t i, Short_t Nz)
 {
   //
@@ -152,8 +179,8 @@ void AliTRDCalibraMode::SetNz(Int_t i, Short_t Nz)
       (Nz <  5)) {
     fNz[i] = Nz; 
   }
-  else { 
-    AliInfo("You have to choose between 0 and 4");
+  else {
+    AliInfo("You have to choose between 0 and 4.");
   }
 
 }
@@ -170,7 +197,7 @@ void AliTRDCalibraMode::SetNrphi(Int_t i, Short_t Nrphi)
     fNrphi[i] = Nrphi; 
   }
   else {
-    AliInfo("You have to choose between 0 and 6");
+    AliInfo("You have to choose between 0 and 6 or 10/100.");
   }
 
 }
@@ -187,10 +214,10 @@ void AliTRDCalibraMode::ModePadCalibration(Int_t iChamb, Int_t i)
   fNnZ[i]    = 0;
   fNnRphi[i] = 0;
   
-  if ((fNz[i] == 0) && (iChamb == 2)) {
+  if (((fNz[i] == 0) || (fNz[i] == 10) || (fNz[i] == 100)) && (iChamb == 2)) {
     fNnZ[i] = 12;
   }
-  if ((fNz[i] == 0) && (iChamb != 2)) {
+  if (((fNz[i] == 0) || (fNz[i] == 10) || (fNz[i] == 100)) && (iChamb != 2)) {
     fNnZ[i] = 16;
   }  
   if ((fNz[i] == 1) && (iChamb == 2)) {
@@ -212,7 +239,7 @@ void AliTRDCalibraMode::ModePadCalibration(Int_t iChamb, Int_t i)
     fNnZ[i] = 1;
   }
    
-  if (fNrphi[i] == 0) {
+  if ((fNrphi[i] == 0) || (fNrphi[i] == 10) || (fNrphi[i] == 100)) {
     fNnRphi[i] = 144;
   }
   if (fNrphi[i] == 1) {
@@ -304,10 +331,24 @@ void AliTRDCalibraMode::CalculXBins(Int_t idect, Int_t i)
   fXbins[i] = 0;
   AliDebug(2, Form("detector: %d", idect));
 
+  // Total
+  if((fNz[i] == 100) && (fNrphi[i] == 100)) {
+    fXbins[i] = 0;
+    return; 
+  }
+
   // In which sector?
   Int_t sector = GetSector(idect);
-  fXbins[i] += sector*(6*fDetChamb2[i]+6*4*fDetChamb0[i]);
  
+  // First per supermodule
+  if((fNz[i] == 10) && (fNrphi[i] == 10)) {
+    fXbins[i] = sector;
+    return;
+  }
+  
+  fXbins[i] += sector*(6*fDetChamb2[i]+6*4*fDetChamb0[i]);
+
   // In which stack?
   Int_t stack = GetStack(idect);
   Int_t kc      = 0;
index 7e387f9..b7a46f1 100644 (file)
@@ -47,6 +47,10 @@ class AliTRDCalibraMode : public TObject {
          void     SetColMax(Int_t i, Short_t colmax)                        { fColMax[i] = colmax;            } 
          void     SetDetChamb0(Int_t i);
          void     SetDetChamb2(Int_t i);
+         
+         void     SetPerSuperModule(Int_t i);
+         void     SetAllTogether(Int_t i);
+
 
   //Get
          Short_t  GetNz(Int_t i) const                                      { return fNz[i];                  }
index 569e7db..f5d7395 100644 (file)
@@ -121,6 +121,64 @@ AliTRDCalibraVdriftLinearFit::~AliTRDCalibraVdriftLinearFit() /*FOLD00*/
   fLinearFitterEArray.Delete();
 
 }
+//_____________________________________________________________________________
+void AliTRDCalibraVdriftLinearFit::Copy(TObject &c) const
+{
+  //
+  // Copy function
+  //
+
+  AliTRDCalibraVdriftLinearFit& target = (AliTRDCalibraVdriftLinearFit &) c;
+
+  // Copy only the histos
+  for (Int_t idet = 0; idet < 540; idet++){
+    if(fLinearFitterHistoArray.UncheckedAt(idet)){
+      TH2F *hped1 = target.GetLinearFitterHisto(idet,kTRUE);
+      hped1->SetDirectory(0);
+      hped1->Add((const TH1F *)fLinearFitterHistoArray.UncheckedAt(idet));
+    }
+  
+  }
+
+  TObject::Copy(c);
+
+}
+//_____________________________________________________________________________
+Long64_t AliTRDCalibraVdriftLinearFit::Merge(TCollection* list) 
+{
+  // Merge list of objects (needed by PROOF)
+
+  if (!list)
+    return 0;
+  
+  if (list->IsEmpty())
+    return 1;
+  
+  TIterator* iter = list->MakeIterator();
+  TObject* obj = 0;
+  
+  // collection of generated histograms
+  Int_t count=0;
+  while((obj = iter->Next()) != 0) 
+  {
+    AliTRDCalibraVdriftLinearFit* entry = dynamic_cast<AliTRDCalibraVdriftLinearFit*>(obj);
+    if (entry == 0) continue; 
+
+    // Copy only the histos
+    for (Int_t idet = 0; idet < 540; idet++){
+      if(entry->GetLinearFitterHisto(idet)){
+       TH2F *hped1 = GetLinearFitterHisto(idet,kTRUE);
+       hped1->SetDirectory(0);
+       hped1->Add(entry->GetLinearFitterHisto(idet));
+      }
+      
+    }
+    
+    count++;
+  }
+  
+  return count;
+}
 //_____________________________________________________________________
 void AliTRDCalibraVdriftLinearFit::Add(AliTRDCalibraVdriftLinearFit *ped)
 {
index 4045fe2..de9267e 100644 (file)
@@ -26,6 +26,8 @@ class AliTRDCalibraVdriftLinearFit : public TObject {
   AliTRDCalibraVdriftLinearFit(const AliTRDCalibraVdriftLinearFit &ped);
   AliTRDCalibraVdriftLinearFit(const TObjArray &obja);
   virtual ~AliTRDCalibraVdriftLinearFit();
+  virtual Long64_t Merge(TCollection* list);
+  virtual void Copy(TObject &c) const;
 
   AliTRDCalibraVdriftLinearFit& operator = (const  AliTRDCalibraVdriftLinearFit &source);
 
index b1a6c1c..0d88a0c 100644 (file)
@@ -668,8 +668,10 @@ Bool_t AliTRDPreprocessor::ExtractDriftVelocityDAQ()
       
       // if enough statistics store the results
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.5*nbE)) {
        // create the cal objects
+       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
+       calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
        TObjArray object      = calibra->GetVectorFit();
        AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
        TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
@@ -771,7 +773,7 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       }
       // analyse
       Log("Take the CH reference data. Now we will try to fit\n");
-      calibra->SetMinEntries(1000); // If there is less than 1000 entries in the histo: no fit
+      calibra->SetMinEntries(800); // If there is less than 1000 entries in the histo: no fit
       calibra->AnalyseCH(histogain);
       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
        + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
@@ -779,8 +781,9 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       Int_t nbE         = calibra->GetNumberEnt();
       // enough statistics
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.5*nbE)) {
        // create the cal objects
+       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
        TObjArray object           = calibra->GetVectorFit();
        AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object);
        TObject *objgainpad        = calibra->CreatePadObjectGain();
@@ -809,7 +812,7 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       }
       // analyse
       Log("Take the PH reference data. Now we will try to fit\n");
-      calibra->SetMinEntries(1000*20); // If there is less than 20000
+      calibra->SetMinEntries(800*20); // If there is less than 20000
       calibra->AnalysePH(histodriftvelocity);
       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
        + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
@@ -817,8 +820,10 @@ Bool_t AliTRDPreprocessor::ExtractHLT()
       Int_t nbE          = calibra->GetNumberEnt();
       // enough statistics
       if ((nbtg >                  0) && 
-         (nbfit        >= 0.95*nbE)) {
+         (nbfit        >= 0.5*nbE)) {
        // create the cal objects
+       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
+       calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
        TObjArray object  = calibra->GetVectorFit();
        AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
        TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();