AliTRDdigitizer.cxx -> For the new name of the Nodata status in AliTRDCalChamberStatus

AliTRDcalibDB.cxx .h -> For the function related to the new status in AliTRDCalChamberStatus + the exb object with a protection against 100. I plan namely to put a default object with 100, which will indicate that the look up table as to be used. In AliTRDcalibDB, it takes the loop up take when the mean value is above 70...

AliTRDCalibChamberStatus.cxx .h -> calibration with tracks for chamber status of half chamber also

Cal/AliTRDCalChamberStatus.h .cxx -> change of definition of status, keeping the back compatibility.

AliTRDCalibTask.cxx .h -> Run the chamber status calibration + propagate the version and subersion number of the exb object used in the reconstruction

AliTRDCalibraFillHisto.cxx .h -> due to the new name of the status

AliTRDCaibraFit.cxx  -> some printf less

diff --git a/TRD/AliTRDCalibChamberStatus.cxx b/TRD/AliTRDCalibChamberStatus.cxx
index 08ccbf581cb7eddae21426a79153b15c9c8f01b5..6a43d41ed0db5af69046d29d1cf5d5816d6b1e66 100644 (file)
--- a/TRD/AliTRDCalibChamberStatus.cxx
+++ b/TRD/AliTRDCalibChamberStatus.cxx
@@ -53,6 +53,8 @@
 #include "./Cal/AliTRDCalDCSFEEv2.h"
 
 #include "AliTRDrawStream.h"
+#include "AliTRDseedV1.h"
+#include "AliTRDcluster.h"
 
 #ifdef ALI_DATE
 #include "event.h"
@@ -262,6 +264,49 @@ void AliTRDCalibChamberStatus::Init()
   //  Debug  //
   //---------//
 
+}
+//_____________________________________________________________________
+void AliTRDCalibChamberStatus::ProcessTrack(AliTRDtrackV1 * trdTrack)
+{
+  //
+  // Track Processing to get half chamber status
+  //
+  //
+  
+  
+  const AliTRDseedV1 *tracklet = 0x0;
+  AliTRDcluster *cluster;
+  //////////////////////////////////////
+  // Loop tracklets
+  ///////////////////////////////////// 
+  for(Int_t itr = 0; itr < 6; ++itr){
+       
+    if(!(tracklet = trdTrack->GetTracklet(itr))) continue;
+    if(!tracklet->IsOK()) continue;
+  
+    // Loop on clusters
+    for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
+      if((cluster = tracklet->GetClusters(ic))) {
+       //printf("ic %d\n",ic);
+       break;
+      }
+    }
+    if(!cluster) continue;
+    
+    Int_t det     = cluster->GetDetector();      
+    Int_t layer   = AliTRDgeometry::GetLayer(det);
+    Int_t sm      = AliTRDgeometry::GetSector(det);
+    Int_t stac    = AliTRDgeometry::GetStack(det);
+    
+    Int_t col     = cluster->GetPadCol();
+    Int_t iMcm    = (Int_t)(col/18);   // current group of 18 col pads
+    Double_t rphi = 0.5;
+    if(iMcm > 3) rphi = 1.5;
+         
+    Double_t val[4] = {sm,layer,stac,rphi}; 
+    if(fHnSparseI->GetBinContent((const Int_t*)val)<2147483646) fHnSparseI->Fill(&val[0]); 
+  }
+  
 }
 //_____________________________________________________________________
 void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics)
@@ -365,7 +410,7 @@ Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /*FOLD00*/
 
 }
 //_____________________________________________________________________
-void AliTRDCalibChamberStatus::AnalyseHisto() /*FOLD00*/
+void AliTRDCalibChamberStatus::AnalyseHisto(Int_t limit) /*FOLD00*/
 {
   //
   //  Create the AliTRDCalChamberStatus according to the fHnSparseI
@@ -374,60 +419,58 @@ void AliTRDCalibChamberStatus::AnalyseHisto() /*FOLD00*/
   if(fCalChamberStatus) delete fCalChamberStatus;
   fCalChamberStatus = new AliTRDCalChamberStatus();
 
-  // Check if enough events to say something
-  if(fCounterEventNotEmpty < 200) {
-    // Say all installed
-    for (Int_t ism=0; ism<18; ism++) {
-      for (Int_t ipl=0; ipl<6; ipl++) {
-       for (Int_t istack=0; istack<5; istack++) {
-         // layer, stack, sector
-         Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
-         fCalChamberStatus->SetStatus(det,1);
-       }
-      }
+  // Check if enough events/tracklets per halfchamber to say something
+  Double_t mean=0.0; //number of tracklets per HCS
+  Int_t coord2[4];
+  for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
+    //if(fHnSparseI->GetBinContent(bin,coord2)==0.0) printf(" bin shouldnt be empty!!\n");
+    mean+=fHnSparseI->GetBinContent(bin,coord2);
+  }
+  mean/=fHnSparseI->GetNbins();
+  //printf(" mean tracklets per halfchamber %f \n",mean);
+  if((fCounterEventNotEmpty < limit) && (mean < limit)) {
+    // Say all good
+    for (Int_t idet=0; idet<540; idet++) {
+      fCalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kGood);
     }
     return;
   }
 
-  // Mask out all chambers
-  for (Int_t ism=0; ism<18; ism++) {
-    for (Int_t ipl=0; ipl<6; ipl++) {
-      for (Int_t istack=0; istack<5; istack++) {
-       // layer, stack, sector
-       Int_t det = AliTRDgeometry::GetDetector(ipl,istack,ism);
-       fCalChamberStatus->SetStatus(det,2);
-      }
-    }
+  // set all chambers to NoData
+  for (Int_t idet=0; idet<540; idet++) {
+    fCalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kNoData);
   }
 
-  // Unmask good chambers 
+  // set status according to fHnSparseI 
   Int_t coord[4];
   for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) {
     
-    fHnSparseI->GetBinContent(bin,coord);
+    Double_t content = fHnSparseI->GetBinContent(bin,coord);
     // layer, stack, sector
     Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1);
-
+    //
+    //printf("Number of entries for detector %d: %f\n",detector,content);
     //
     // Check which halfchamber side corresponds to the bin number (0=A, 1=B)
     // Change the status accordingly
     //
-
-    switch(fCalChamberStatus->GetStatus(detector)) 
-      {    
-      case 1: break;  // no changes
-      case 2: 
-       if(coord[3]-1==0) {
-         fCalChamberStatus->SetStatus(detector,4); break;      // only SideB is masked
-       }
-       else {
-         fCalChamberStatus->SetStatus(detector,3); break;      // only SideA is masked
-       }
-      case 3:  fCalChamberStatus->SetStatus(detector,1); break;  // unmask SideA
-      case 4:  fCalChamberStatus->SetStatus(detector,1); break;  // unmask SideB
-      }
+    if(coord[3]-1==0) { // HCS-A
+      fCalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
+      fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoDataHalfChamberSideA); // A has data
+      //fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoData); 
+    }
+    else { //HCS-B
+      fCalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
+      fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoDataHalfChamberSideB); // B has data
+      //fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoData); 
+    }
   }
 
+  // printf
+  //for (Int_t idet=0; idet<540; idet++) {
+  //  if(fCalChamberStatus->IsNoData(idet)) printf("No Data: chamber %d\n",idet);
+  //}
+
 
 }
 //_____________________________________________________________________

diff --git a/TRD/AliTRDCalibChamberStatus.h b/TRD/AliTRDCalibChamberStatus.h
index da8632a08bcd712fa140932d04fb98e33917fe5f..663363a00cac98d144f65bf92d0c586534028c66 100644 (file)
--- a/TRD/AliTRDCalibChamberStatus.h
+++ b/TRD/AliTRDCalibChamberStatus.h
@@ -17,6 +17,8 @@
 #include <TH2.h>
 #endif
 
+#include <AliTRDtrackV1.h>
+
 class AliRawReader;
 
 class AliTRDCalChamberStatus;
@@ -36,10 +38,11 @@ public:
 
   AliTRDCalibChamberStatus& operator = (const  AliTRDCalibChamberStatus &source);
 
+  void ProcessTrack(AliTRDtrackV1 * trdTrack);
   void ProcessEvent(AliRawReader    *rawReader, Int_t nevents_physics);
     
   void Init();
-  void AnalyseHisto();
+  void AnalyseHisto(Int_t limit=200);
   void CheckEORStatus(AliTRDCalDCSv2 *calDCS);
 
   void Add(AliTRDCalibChamberStatus *calibChamberStatus);
@@ -53,6 +56,7 @@ public:
   THnSparseI *GetSparseDebug()   const {return fHnSparseDebug;};
   THnSparseI *GetSparseMCM()     const {return fHnSparseMCM;};
   
+  void SetSparseI(THnSparseI *sparse)       { fHnSparseI=sparse; }
 
   AliTRDCalChamberStatus *GetCalChamberStatus() const {return fCalChamberStatus;};
 

diff --git a/TRD/AliTRDCalibTask.cxx b/TRD/AliTRDCalibTask.cxx
index 0aac7e6fbf6f00dd864b8471d3baba75177415db..c3db4b404fd3576cc1a41c5f41acf699c01d7482 100644 (file)
--- a/TRD/AliTRDCalibTask.cxx
+++ b/TRD/AliTRDCalibTask.cxx
@@ -76,6 +76,7 @@ using namespace std;
 #include "AliCDBId.h"
 #include "AliLog.h"
 
+#include "AliTRDCalibChamberStatus.h"
 
 #include "AliTRDCalibTask.h"
 
@@ -93,6 +94,7 @@ ClassImp(AliTRDCalibTask)
       fCl(0),
       fListHist(0),
       fTRDCalibraFillHisto(0),
+      fTRDChamberStatus(0),
       fNEvents(0),
       fNEventsInput(0),
       fNbTRDTrack(0),
@@ -150,6 +152,9 @@ ClassImp(AliTRDCalibTask)
       fFirstRunVdrift(-1),
       fVersionVdriftUsed(-1), 
       fSubVersionVdriftUsed(-1),
+      fFirstRunExB(-1),
+      fVersionExBUsed(-1), 
+      fSubVersionExBUsed(-1),
       fCalDetGain(0x0),
       fMaxEvent(0),
       fCounter(0),
@@ -218,6 +223,8 @@ AliTRDCalibTask::~AliTRDCalibTask()
     delete fEsdTrackCuts;
   }
   
+  if(fTRDChamberStatus) delete fTRDChamberStatus;
+  
 }
 
 //________________________________________________________________________
@@ -241,7 +248,12 @@ void AliTRDCalibTask::UserCreateOutputObjects()
   // output list
   fListHist = new TList();
   fListHist->SetOwner();
-
+  
+  // init chamber status
+  fTRDChamberStatus = new AliTRDCalibChamberStatus();
+  fTRDChamberStatus->Init();
+  fListHist->Add(fTRDChamberStatus->GetSparseI());
+  
   // instance calibration 
   fTRDCalibraFillHisto = AliTRDCalibraFillHisto::Instance();
   if(fOnInstance) {
@@ -480,6 +492,11 @@ void AliTRDCalibTask::UserExec(Option_t *)
       fTRDCalibraFillHisto->SetFirstRunVdrift(fFirstRunVdrift); // Vdrift Used
       fTRDCalibraFillHisto->SetVersionVdriftUsed(fVersionVdriftUsed); // Vdrift Used
       fTRDCalibraFillHisto->SetSubVersionVdriftUsed(fSubVersionVdriftUsed); // Vdrift Used
+      if((fFirstRunExB != -1) && (fVersionExBUsed != -1) && (fSubVersionExBUsed != -1)){
+       fTRDCalibraFillHisto->SetFirstRunExB(fFirstRunExB); // ExB Used
+       fTRDCalibraFillHisto->SetVersionExBUsed(fVersionExBUsed); // ExB Used
+       fTRDCalibraFillHisto->SetSubVersionExBUsed(fSubVersionExBUsed); // ExB Used
+      }
       fTRDCalibraFillHisto->InitCalDet();
     }
     if(fDebug > 1){
@@ -676,39 +693,19 @@ void AliTRDCalibTask::UserExec(Option_t *)
     ULong_t status = fkEsdTrack->GetStatus(); 
     if(status&(AliESDtrack::kTPCout)) ++nbtrackTPC;
     
-    // Quality cuts on the AliESDtrack
-    if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
-      //printf("Not a good track\n");
+    fFriendTrack = fESDfriend->GetTrack(itrk);
+    if(!fFriendTrack)  {
+      //printf("No friend track %d\n",itrk);
       continue;
     }
-    
-    // First Absolute gain calibration
-    Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
-    Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID(); 
-    //printf("Number of trd tracklets %d and PID trd tracklets %d\n",trdNTracklets,trdNTrackletsPID);
-    if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
-      for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
-       //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
-       //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
-       //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
-       //printf("momentum %f, slide %f\n",momentum,slide);
-       if(fkEsdTrack->GetTRDslice(iPlane) > 0.0) 
-         fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
-                             fkEsdTrack->GetTRDmomentum(iPlane)); 
-      }
-    }     
-    
+
     // Other cuts
+    fTrdTrack = 0x0;
     Bool_t good = kTRUE;
     Bool_t standalonetrack = kFALSE;
     Bool_t offlinetrack = kFALSE;
     //ULong_t status = fkEsdTrack->GetStatus();
     
-    fFriendTrack = fESDfriend->GetTrack(itrk);
-    if(!fFriendTrack)  {
-      //printf("No friend track %d\n",itrk);
-      continue;
-    }
     //////////////////////////////////////
     // Loop on calibration objects
     //////////////////////////////////////
@@ -738,135 +735,165 @@ void AliTRDCalibTask::UserExec(Option_t *)
       }
       
       fTrdTrack = (AliTRDtrackV1 *)fCalibObject;
-      if(good && fOnInstance) {
-       //cout << "good" << endl;
-       fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
-       //printf("Fill fTRDCalibraFillHisto\n");
+      // process chamberstatus
+      fTRDChamberStatus->ProcessTrack(fTrdTrack);
+    }
+
+    // Quality cuts on the AliESDtrack
+    if((fEsdTrackCuts) && (!fEsdTrackCuts->IsSelected((AliVParticle *)fkEsdTrack))) {
+      //printf("Not a good track\n");
+      continue;
+    }
+    
+    // First Absolute gain calibration
+    Int_t trdNTracklets = (Int_t) fkEsdTrack->GetTRDntracklets();
+    Int_t trdNTrackletsPID = (Int_t) fkEsdTrack->GetTRDntrackletsPID(); 
+    //printf("Number of trd tracklets %d and PID trd tracklets %d\n",trdNTracklets,trdNTrackletsPID);
+    if((trdNTracklets > 0) && (trdNTrackletsPID > 0)) {
+      for(Int_t iPlane = 0; iPlane < 6; ++iPlane){
+       //Double_t slide = fkEsdTrack->GetTRDslice(iPlane);
+       //printf("Number of slide %d\n",fkEsdTrack->GetNumberOfTRDslices());
+       //Double_t momentum = fkEsdTrack->GetTRDmomentum(iPlane);
+       //printf("momentum %f, slide %f\n",momentum,slide);
+       if(fkEsdTrack->GetTRDslice(iPlane) > 0.0) 
+         fAbsoluteGain->Fill(fkEsdTrack->GetTRDslice(iPlane)*8.0/100.0,
+                             fkEsdTrack->GetTRDmomentum(iPlane)); 
       }
+    }     
+    
+    
+    if(!fTrdTrack) continue; 
+
+    if(good && fOnInstance) {
+      //cout << "good" << endl;
+      fTRDCalibraFillHisto->UpdateHistogramsV1(fTrdTrack);
+      //printf("Fill fTRDCalibraFillHisto\n");
+    }
+      
       
-      //////////////////////////////////
-      // Debug 
-      ////////////////////////////////
+         
+    //////////////////////////////////
+    // Debug 
+    ////////////////////////////////
+    
+    if(fDebug > 0) {
       
-      if(fDebug > 0) {
+      //printf("Enter debug\n");
+      
+      Int_t nbtracklets = 0;
+      
+      // Check some stuff
+      Bool_t standalonetracklet = kFALSE;  
+      const AliTRDseedV1 *tracklet = 0x0;
+      //////////////////////////////////////
+      // Loop tracklets
+      ///////////////////////////////////// 
+      Int_t nbclusters=0;
+      Double_t phtb[AliTRDseedV1::kNtb];
+      memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
+      Double_t sum = 0.0;
+      Float_t normalisation = 6.67;
+      Int_t detector = 0;
+      Int_t sector = 0;
+      for(Int_t itr = 0; itr < 6; ++itr){
        
-       //printf("Enter debug\n");
+       if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
+       if(!tracklet->IsOK()) continue;
+       ++nbtracklets;
+       standalonetracklet = kFALSE; 
+       if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
        
-       Int_t nbtracklets = 0;
+       nbclusters = 0;
+       memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
+       sum = 0.0;
+       detector = 0;
+       sector = 0;
+       //Int_t crossrow = 0;
        
-       // Check some stuff
-       Bool_t standalonetracklet = kFALSE;  
-       const AliTRDseedV1 *tracklet = 0x0;
-       //////////////////////////////////////
-       // Loop tracklets
-       ///////////////////////////////////// 
-       Int_t nbclusters=0;
-       Double_t phtb[AliTRDseedV1::kNtb];
-        memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
-       Double_t sum = 0.0;
-       Float_t normalisation = 6.67;
-       Int_t detector = 0;
-       Int_t sector = 0;
-       for(Int_t itr = 0; itr < 6; ++itr){
-         
-         if(!(tracklet = fTrdTrack->GetTracklet(itr))) continue;
-         if(!tracklet->IsOK()) continue;
-         ++nbtracklets;
-         standalonetracklet = kFALSE; 
-         if(tracklet->IsStandAlone()) standalonetracklet = kTRUE;
-         
-         nbclusters = 0;
-         memset(phtb, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
-         sum = 0.0;
-         detector = 0;
-         sector = 0;
-         //Int_t crossrow = 0;
-         
          // Check no shared clusters
          //for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
          //  if((fcl = tracklet->GetClusters(icc)))  crossrow = 1;
          // }
-         
+       
          // Loop on clusters
-         Int_t time = 0;
-         Float_t ch = 0;
-         Float_t qcl = 0;
-         for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
-           
-           if(!(fCl = tracklet->GetClusters(ic))) continue;
-           ++nbclusters;
-           time = fCl->GetPadTime();
-           ch =  tracklet->GetdQdl(ic);
-           qcl = TMath::Abs(fCl->GetQ());
-           detector = fCl->GetDetector();        
-           // Add the charge if shared cluster
-           if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
-             if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
-               qcl += TMath::Abs(fCl->GetQ());
-               //printf("Add the cluster charge\n");
-             }
-           }
-           if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
-           if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation;       
-           else sum += ch/normalisation;
-           
-           if(fDebug > 1) {
-             fNbTimeBin->Fill(time);
-             if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
-             else fNbTimeBinOffline->Fill(time);
+       Int_t time = 0;
+       Float_t ch = 0;
+       Float_t qcl = 0;
+       for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){
+         
+         if(!(fCl = tracklet->GetClusters(ic))) continue;
+         ++nbclusters;
+         time = fCl->GetPadTime();
+         ch =  tracklet->GetdQdl(ic);
+         qcl = TMath::Abs(fCl->GetQ());
+         detector = fCl->GetDetector();          
+         // Add the charge if shared cluster
+         if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
+           if((fCl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb))) {
+             qcl += TMath::Abs(fCl->GetQ());
+             //printf("Add the cluster charge\n");
            }
          }
-         sector = AliTRDgeometry::GetSector(detector);
+         if((time>-1) && (time<fNbTimeBins)) phtb[time]=qcl;
+         if((fCalDetGain) && (fCalDetGain->GetValue(detector) > 0.0)) sum += ch*fCalDetGain->GetValue(detector)/normalisation; 
+         else sum += ch/normalisation;
          
          if(fDebug > 1) {
-           fNbTracklets->Fill(detector);
-           if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
-           else fNbTrackletsOffline->Fill(detector);
-           
-           fNbClusters->Fill(nbclusters);
-           if(tracklet->IsStandAlone())  fNbClustersStandalone->Fill(nbclusters);
-           else  fNbClustersOffline->Fill(nbclusters);
-         }        
+           fNbTimeBin->Fill(time);
+           if(tracklet->IsStandAlone()) fNbTimeBinStandalone->Fill(time);
+           else fNbTimeBinOffline->Fill(time);
+         }
+       }
+       sector = AliTRDgeometry::GetSector(detector);
+       
+       if(fDebug > 1) {
+         fNbTracklets->Fill(detector);
+         if(tracklet->IsStandAlone()) fNbTrackletsStandalone->Fill(detector);
+         else fNbTrackletsOffline->Fill(detector);
          
-         if((nbclusters > fLow) && (nbclusters < fHigh)){
-           if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
-           fCH2dTest->Fill(sum,detector+0.5);         
-           fCH2dSM->Fill(sum,sector+0.5);
-           fCH2dSum->Fill(sum,0.5);
-           Bool_t checknoise = kTRUE;
-           if(fMaxCluster > 0) {
-             if(phtb[0] > fMaxCluster) checknoise = kFALSE;
-             if(fNbTimeBins > fNbMaxCluster) {
-               for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
-                 if(phtb[k] > fMaxCluster) checknoise = kFALSE;
-               }
+         fNbClusters->Fill(nbclusters);
+         if(tracklet->IsStandAlone())  fNbClustersStandalone->Fill(nbclusters);
+         else  fNbClustersOffline->Fill(nbclusters);
+       }          
+       
+       if((nbclusters > fLow) && (nbclusters < fHigh)){
+         if(fRelativeScale > 0.0) sum = sum/fRelativeScale;
+         fCH2dTest->Fill(sum,detector+0.5);           
+         fCH2dSM->Fill(sum,sector+0.5);
+         fCH2dSum->Fill(sum,0.5);
+         Bool_t checknoise = kTRUE;
+         if(fMaxCluster > 0) {
+           if(phtb[0] > fMaxCluster) checknoise = kFALSE;
+           if(fNbTimeBins > fNbMaxCluster) {
+             for(Int_t k = (fNbTimeBins-fNbMaxCluster); k < fNbTimeBins; k++){
+               if(phtb[k] > fMaxCluster) checknoise = kFALSE;
              }
            }
-           if(checknoise) {           
-             for(int ic=0; ic<fNbTimeBins; ic++){
-               if(fFillZero) {
+         }
+         if(checknoise) {             
+           for(int ic=0; ic<fNbTimeBins; ic++){
+             if(fFillZero) {
+               fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
+               fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
+               fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
+             }
+             else {
+               if(phtb[ic] > 0.0) {
                  fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
-                 fPH2dSum->Fill((Double_t)(ic/10.0),0.5,(Double_t)phtb[ic]);
+                 fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
                  fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
                }
-               else {
-                 if(phtb[ic] > 0.0) {
-                   fPH2dTest->Fill((Double_t)(ic/10.0),detector+0.5,(Double_t)phtb[ic]);
-                   fPH2dSum->Fill((Double_t)(ic/10.0),0.0,(Double_t)phtb[ic]);
-                   fPH2dSM->Fill((Double_t)(ic/10.0),sector+0.5,(Double_t)phtb[ic]);
-                 }
-               }
              }
            }
          }
-         if(detector == 0) FindP1TrackPHtrackletV1Test(tracklet,nbclusters);
-
-       } // loop on tracklets
-
+       }
+       if(detector == 0) FindP1TrackPHtrackletV1Test(tracklet,nbclusters);
        
-      } // debug
+      } // loop on tracklets
+      
       
-    }// while calibration objects
+    } // debug
+    
     if(nTRDtrackV1 > 0) {
       ++nbTrdTracks;      
       if((status&(AliESDtrack::kTRDout)) && (!(status&(AliESDtrack::kTRDin)))) {
@@ -932,201 +959,6 @@ Bool_t AliTRDCalibTask::Load(TList *lister)
   fListHist = (TList*)lister->Clone(GetName());
   return kTRUE;
 }
-//________________________________________________________________________
-void AliTRDCalibTask::Plot() 
-{
-  //
-  // Plot the histos stored in the TList
-  //
- 
-  if(!fListHist) return;
-
-  /////////////////////////////////////
-  // Take the debug stuff
-  /////////////////////////////////////
-
-  TH1I *nEvents  = (TH1I *) fListHist->FindObject("NEvents");
-
-  TH2F *absoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
-
-  TH1F *trdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
-  TH1F *trdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
-  TH1F *trdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
-
-  TH2F *tpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
-
-  TH1F *nbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
-  TH1F *nbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
-  TH1F *nbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
-
-  TH1F *nbClusters = (TH1F *) fListHist->FindObject("NbClusters");
-  TH1F *nbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
-  TH1F *nbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
-
-  TH1F *nbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
-  TH1F *nbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
-  TH1F *nbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
-  
-  /////////////////////////////////////
-  // Take the calibration objects
-  /////////////////////////////////////
-
-  TH2I *ch2d = (TH2I *) fListHist->FindObject("CH2d");
-  TProfile2D *ph2d = (TProfile2D *) fListHist->FindObject("PH2d");
-
-  TH2I *ch2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
-  TProfile2D *ph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
-
-  TH2I *ch2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
-  TProfile2D *ph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
-  
-  AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");
-  
-  ////////////////////////////////////////////////
-  // Add the AliTRDCalibraVdriftLinearFit
-  ///////////////////////////////////////////////
-  
-  Int_t first = 0;
-  TH2S *histolinearfitsum = 0x0;
-  
-  if(linearfit) {
-    for(Int_t det = 0; det < 540; det++) {
-      if(linearfit->GetLinearFitterHisto(det)){
-       if(TMath::Abs(first)<0.0001){
-         histolinearfitsum = linearfit->GetLinearFitterHisto(det);
-         first += 1;
-       }
-       else {
-          if (histolinearfitsum) {
-           histolinearfitsum->Add(linearfit->GetLinearFitterHisto(det));
-         }
-       }
-      }
-    }
-  }
-
-  ///////////////////////////
-  // Style
-  //////////////////////////
-
-  gStyle->SetPalette(1);
-  gStyle->SetOptStat(1111);
-  gStyle->SetOptFit(1111);
-  gStyle->SetPadBorderMode(0);
-  gStyle->SetCanvasColor(10);
-  gStyle->SetPadLeftMargin(0.13);
-  gStyle->SetPadRightMargin(0.13);
-
-  /////////////////////////
-  // Plot
-  ////////////////////////
-
- if(nEvents) {
-   
-    TCanvas *debugEvents = new TCanvas("cNEvents","cNEvents",10,10,510,510);
-    debugEvents->cd(1);
-    if(nEvents) nEvents->Draw();
-      
-  }
-
- if(absoluteGain) {
-   
-    TCanvas *debugAbsoluteGain = new TCanvas("cAbsoluteGain","cAbsoluteGain",10,10,510,510);
-    debugAbsoluteGain->cd(1);
-    if(absoluteGain) absoluteGain->Draw();
-      
-  }
-
-  if(trdTrack || tpctrdTrack) {
-    
-    TCanvas *debugtrdtpcTrack = new TCanvas("TRDtracktpctrdtrack","TRDtracktpctrdtrack",10,10,510,510);
-    debugtrdtpcTrack->Divide(2,1);
-    debugtrdtpcTrack->cd(1);
-    if(trdTrack) trdTrack->Draw();
-    if(trdTrackOffline) trdTrackOffline->Draw("same");
-    if(trdTrackStandalone) trdTrackStandalone->Draw("same");
-    TLegend *leg = new TLegend(0.4,0.6,0.89,0.89);
-    if(trdTrack) leg->AddEntry(trdTrack,"All","p");
-    if(trdTrackOffline) leg->AddEntry(trdTrackOffline,"Offline","p");
-    if(trdTrackStandalone) leg->AddEntry(trdTrackStandalone,"Standalone","p");
-    leg->Draw("same");
-    debugtrdtpcTrack->cd(2);
-    if(tpctrdTrack) tpctrdTrack->Draw();
-    TLine *line = new TLine(0.0,0.0,100.0,100.0);
-    line->Draw("same");
-    
-  }
- 
-  if(nbTimeBin || nbTracklets || nbClusters) {
-    
-    TCanvas *debugTracklets = new TCanvas("TRDtimebintrackletcluster","TRDtimebintrackletcluster",10,10,510,510);
-    debugTracklets->Divide(3,1);
-    debugTracklets->cd(1);
-    if(nbTimeBin) nbTimeBin->Draw();
-    if(nbTimeBinOffline) nbTimeBinOffline->Draw("same");
-    if(nbTimeBinStandalone) nbTimeBinStandalone->Draw("same");
-    TLegend *lega = new TLegend(0.4,0.6,0.89,0.89);
-    if(nbTimeBin) lega->AddEntry(nbTimeBin,"All","p");
-    if(nbTimeBinOffline) lega->AddEntry(nbTimeBinOffline,"Offline","p");
-    if(nbTimeBinStandalone) lega->AddEntry(nbTimeBinStandalone,"Standalone","p");
-    lega->Draw("same");
-    debugTracklets->cd(2);
-    if(nbTracklets) nbTracklets->Draw();
-    if(nbTrackletsOffline) nbTrackletsOffline->Draw("same");
-    if(nbTrackletsStandalone) nbTrackletsStandalone->Draw("same");
-    TLegend *legb = new TLegend(0.4,0.6,0.89,0.89);
-    if(nbTracklets) legb->AddEntry(nbTracklets,"All","p");
-    if(nbTrackletsOffline) legb->AddEntry(nbTrackletsOffline,"Offline","p");
-    if(nbTrackletsStandalone) legb->AddEntry(nbTrackletsStandalone,"Standalone","p");
-    legb->Draw("same");
-    debugTracklets->cd(3);
-    if(nbClusters) nbClusters->Draw();
-    if(nbClustersOffline) nbClustersOffline->Draw("same");
-    if(nbClustersStandalone) nbClustersStandalone->Draw("same");
-    TLegend *legc = new TLegend(0.4,0.6,0.89,0.89);
-    if(nbClusters) legc->AddEntry(nbClusters,"All","p");
-    if(nbClustersOffline) legc->AddEntry(nbClustersOffline,"Offline","p");
-    if(nbClustersStandalone) legc->AddEntry(nbClustersStandalone,"Standalone","p");
-    legc->Draw("same");
-  
-  }
-
-  if(ch2dSum || ph2dSum || histolinearfitsum) {
-    
-    TCanvas *debugSum = new TCanvas("SumCalibrationObjects","SumCalibrationObjects",10,10,510,510);
-    debugSum->Divide(3,1);
-    debugSum->cd(1);
-    if(ch2dSum) ch2dSum->Draw("lego");
-    debugSum->cd(2);
-    if(ph2dSum) ph2dSum->Draw("lego");
-    debugSum->cd(3);
-    if(histolinearfitsum) histolinearfitsum->Draw();
-  
-  }
-
-  if(ch2dSM || ph2dSM) {
-    
-    TCanvas *debugSM = new TCanvas("SMCalibrationObjects","SMCalibrationObjects",10,10,510,510);
-    debugSM->Divide(2,1);
-    debugSM->cd(1);
-    if(ch2dSM) ch2dSM->Draw("lego");
-    debugSM->cd(2);
-    if(ph2dSM) ph2dSM->Draw("lego");
-     
-  }
-
-  if(ch2d || ph2d) {
-    
-    TCanvas *debug = new TCanvas("CalibrationObjects","CalibrationObjects",10,10,510,510);
-    debug->Divide(2,1);
-    debug->cd(1);
-    if(ch2d) ch2d->Draw("lego");
-    debug->cd(2);
-    if(ph2d) ph2d->Draw("lego");
-     
-  }
- 
-}
 //_______________________________________________________________________________________
 void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
 
@@ -1137,74 +969,78 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
   TList *listcalibTask = calibTask->GetList();
   if(!listcalibTask) return;
 
-  TH1I *nEvents  = (TH1I *) listcalibTask->FindObject("NEvents");
-  TH1I *nEventsInput  = (TH1I *) listcalibTask->FindObject("NEventsInput");
-  TH2F *absoluteGain  = (TH2F *) listcalibTask->FindObject("AbsoluteGain");
+  THnSparseI *histoEntries = (THnSparseI *) listcalibTask->FindObject("NumberOfEntries");
+
+  TH1I *nEvents  = (TH1I *) listcalibTask->FindObject(Form("NEvents_%s",(const char*)calibTask->GetName()));
+  TH1I *nEventsInput  = (TH1I *) listcalibTask->FindObject(Form("NEventsInput_%s",(const char*)calibTask->GetName()));
+  TH2F *absoluteGain  = (TH2F *) listcalibTask->FindObject(Form("AbsoluteGain_%s",(const char*)calibTask->GetName()));
 
-  TH1F *trdTrack = (TH1F *) listcalibTask->FindObject("TRDTrack");
-  TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject("TRDTrackOffline");
-  TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject("TRDTrackStandalone");
+  TH1F *trdTrack = (TH1F *) listcalibTask->FindObject(Form("TRDTrack_%s",(const char*)calibTask->GetName()));
+  TH1F *trdTrackOffline = (TH1F *) listcalibTask->FindObject(Form("TRDTrackOffline_%s",(const char*)calibTask->GetName()));
+  TH1F *trdTrackStandalone = (TH1F *) listcalibTask->FindObject(Form("TRDTrackStandalone_%s",(const char*)calibTask->GetName()));
 
-  TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject("NbTPCTRDtrack");
+  TH2F *tpctrdTrack = (TH2F *) listcalibTask->FindObject(Form("NbTPCTRDtrack_%s",(const char*)calibTask->GetName()));
 
-  TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject("NbTimeBin");
-  TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject("NbTimeBinOffline");
-  TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject("NbTimeBinStandalone");
+  TH1F *nbTimeBin = (TH1F *) listcalibTask->FindObject(Form("NbTimeBin_%s",(const char*)calibTask->GetName()));
+  TH1F *nbTimeBinOffline = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinOffline_%s",(const char*)calibTask->GetName()));
+  TH1F *nbTimeBinStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTimeBinStandalone_%s",(const char*)calibTask->GetName()));
 
-  TH1F *nbClusters = (TH1F *) listcalibTask->FindObject("NbClusters");
-  TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject("NbClustersOffline");
-  TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject("NbClustersStandalone");
+  TH1F *nbClusters = (TH1F *) listcalibTask->FindObject(Form("NbClusters_%s",(const char*)calibTask->GetName()));
+  TH1F *nbClustersOffline = (TH1F *) listcalibTask->FindObject(Form("NbClustersOffline_%s",(const char*)calibTask->GetName()));
+  TH1F *nbClustersStandalone = (TH1F *) listcalibTask->FindObject(Form("NbClustersStandalone_%s",(const char*)calibTask->GetName()));
 
-  TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject("NbTracklets");
-  TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject("NbTrackletsOffline");
-  TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject("NbTrackletsStandalone");
+  TH1F *nbTracklets = (TH1F *) listcalibTask->FindObject(Form("NbTracklets_%s",(const char*)calibTask->GetName()));
+  TH1F *nbTrackletsOffline = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsOffline_%s",(const char*)calibTask->GetName()));
+  TH1F *nbTrackletsStandalone = (TH1F *) listcalibTask->FindObject(Form("NbTrackletsStandalone_%s",(const char*)calibTask->GetName()));
   
   TH2I *ch2d = (TH2I *) listcalibTask->FindObject("CH2d");
   TProfile2D *ph2d = (TProfile2D *) listcalibTask->FindObject("PH2d");
   TProfile2D *prf2d = (TProfile2D *) listcalibTask->FindObject("PRF2d");
 
-  TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject("CH2dSum");
-  TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject("PH2dSum");
+  TH2I *ch2dSum = (TH2I *) listcalibTask->FindObject(Form("CH2dSum_%s",(const char*)calibTask->GetName()));
+  TProfile2D *ph2dSum = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSum_%s",(const char*)calibTask->GetName()));
 
-  TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject("CH2dSM");
-  TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject("PH2dSM");
+  TH2I *ch2dSM = (TH2I *) listcalibTask->FindObject(Form("CH2dSM_%s",(const char*)calibTask->GetName()));
+  TProfile2D *ph2dSM = (TProfile2D *) listcalibTask->FindObject(Form("PH2dSM_%s",(const char*)calibTask->GetName()));
   
   AliTRDCalibraVdriftLinearFit *linearfit = (AliTRDCalibraVdriftLinearFit *) listcalibTask->FindObject("AliTRDCalibraVdriftLinearFit");  
   AliTRDCalibraVector *calibraVector = (AliTRDCalibraVector *) listcalibTask->FindObject("AliTRDCalibraVector");  
 
   //
 
-  TH1I *inEventsInput  = (TH1I *) fListHist->FindObject("NEventsInput");
-  TH1I *inEvents  = (TH1I *) fListHist->FindObject("NEvents");
-  TH2F *iabsoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
+  THnSparseI *inhistoEntries = (THnSparseI *) fListHist->FindObject("NumberOfEntries");
 
-  TH1F *itrdTrack = (TH1F *) fListHist->FindObject("TRDTrack");
-  TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject("TRDTrackOffline");
-  TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject("TRDTrackStandalone");
+  TH1I *inEventsInput  = (TH1I *) fListHist->FindObject(Form("NEventsInput_%s",(const char*)fName));
+  TH1I *inEvents  = (TH1I *) fListHist->FindObject(Form("NEvents_%s",(const char*)fName));
+  TH2F *iabsoluteGain  = (TH2F *) fListHist->FindObject(Form("AbsoluteGain_%s",(const char*)fName));
 
-  TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject("NbTPCTRDtrack");
+  TH1F *itrdTrack = (TH1F *) fListHist->FindObject(Form("TRDTrack_%s",(const char*)fName));
+  TH1F *itrdTrackOffline = (TH1F *) fListHist->FindObject(Form("TRDTrackOffline_%s",(const char*)fName));
+  TH1F *itrdTrackStandalone = (TH1F *) fListHist->FindObject(Form("TRDTrackStandalone_%s",(const char*)fName));
 
-  TH1F *inbTimeBin = (TH1F *) fListHist->FindObject("NbTimeBin");
-  TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject("NbTimeBinOffline");
-  TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject("NbTimeBinStandalone");
+  TH2F *itpctrdTrack = (TH2F *) fListHist->FindObject(Form("NbTPCTRDtrack_%s",(const char*)fName));
 
-  TH1F *inbClusters = (TH1F *) fListHist->FindObject("NbClusters");
-  TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject("NbClustersOffline");
-  TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject("NbClustersStandalone");
+  TH1F *inbTimeBin = (TH1F *) fListHist->FindObject(Form("NbTimeBin_%s",(const char*)fName));
+  TH1F *inbTimeBinOffline = (TH1F *) fListHist->FindObject(Form("NbTimeBinOffline_%s",(const char*)fName));
+  TH1F *inbTimeBinStandalone = (TH1F *) fListHist->FindObject(Form("NbTimeBinStandalone_%s",(const char*)fName));
 
-  TH1F *inbTracklets = (TH1F *) fListHist->FindObject("NbTracklets");
-  TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject("NbTrackletsOffline");
-  TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject("NbTrackletsStandalone");
+  TH1F *inbClusters = (TH1F *) fListHist->FindObject(Form("NbClusters_%s",(const char*)fName));
+  TH1F *inbClustersOffline = (TH1F *) fListHist->FindObject(Form("NbClustersOffline_%s",(const char*)fName));
+  TH1F *inbClustersStandalone = (TH1F *) fListHist->FindObject(Form("NbClustersStandalone_%s",(const char*)fName));
+
+  TH1F *inbTracklets = (TH1F *) fListHist->FindObject(Form("NbTracklets_%s",(const char*)fName));
+  TH1F *inbTrackletsOffline = (TH1F *) fListHist->FindObject(Form("NbTrackletsOffline_%s",(const char*)fName));
+  TH1F *inbTrackletsStandalone = (TH1F *) fListHist->FindObject(Form("NbTrackletsStandalone_%s",(const char*)fName));
   
   TH2I *ich2d = (TH2I *) fListHist->FindObject("CH2d");
   TProfile2D *iph2d = (TProfile2D *) fListHist->FindObject("PH2d");
   TProfile2D *iprf2d = (TProfile2D *) fListHist->FindObject("PRF2d");
 
-  TH2I *ich2dSum = (TH2I *) fListHist->FindObject("CH2dSum");
-  TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject("PH2dSum");
+  TH2I *ich2dSum = (TH2I *) fListHist->FindObject(Form("CH2dSum_%s",(const char*)fName));
+  TProfile2D *iph2dSum = (TProfile2D *) fListHist->FindObject(Form("PH2dSum_%s",(const char*)fName));
 
-  TH2I *ich2dSM = (TH2I *) fListHist->FindObject("CH2dSM");
-  TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject("PH2dSM");
+  TH2I *ich2dSM = (TH2I *) fListHist->FindObject(Form("CH2dSM_%s",(const char*)fName));
+  TProfile2D *iph2dSM = (TProfile2D *) fListHist->FindObject(Form("PH2dSM_%s",(const char*)fName));
   
   AliTRDCalibraVdriftLinearFit *ilinearfit = (AliTRDCalibraVdriftLinearFit *) fListHist->FindObject("AliTRDCalibraVdriftLinearFit");  
   AliTRDCalibraVector *icalibraVector = (AliTRDCalibraVector *) fListHist->FindObject("AliTRDCalibraVector");  
@@ -1212,6 +1048,18 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
 
   // Add
 
+  if(histoEntries) {
+    if(inhistoEntries) {
+      inhistoEntries->Add(histoEntries);
+      //printf("Add Events\n");
+    }
+    else {
+      //printf("Create new Events\n");
+      inhistoEntries = (THnSparseI *) histoEntries->Clone();
+      fListHist->Add(inhistoEntries);
+    }
+  }
+
   if(nEventsInput) {
     if(inEventsInput) {
       inEventsInput->Add(nEventsInput);
@@ -1494,6 +1342,12 @@ Bool_t AliTRDCalibTask::SetVersionSubversion(){
       fFirstRunGainLocal = id->GetFirstRun();
       fVersionGainLocalUsed = id->GetVersion();
       fSubVersionGainLocalUsed = id->GetSubVersion();
+    } else if(os->GetString().Contains("TRD/Calib/ChamberExB")){
+      // Get Old drift velocity calibration
+      AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
+      fFirstRunExB = id->GetFirstRun();
+      fVersionExBUsed = id->GetVersion();
+      fSubVersionExBUsed = id->GetSubVersion();
     }
   }
 

diff --git a/TRD/AliTRDCalibTask.h b/TRD/AliTRDCalibTask.h
index 9cbb28f6909fec7eef844d66f6dd75fdd5ee586e..0d691bd7dcb84fef170621bf3f0de7e0cd79909b 100644 (file)
--- a/TRD/AliTRDCalibTask.h
+++ b/TRD/AliTRDCalibTask.h
@@ -28,6 +28,7 @@ class AliTRDCalibraFillHisto;
 class AliTRDcluster;
 class AliESDtrackCuts;
 class AliTRDCalDet;
+class AliTRDCalibChamberStatus;
 
 #include "TObjString.h"
 #include "AliAnalysisTaskSE.h" 
@@ -44,7 +45,6 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   virtual void   Terminate(Option_t *);
   virtual Bool_t Load(const Char_t *filename);
   virtual Bool_t Load(TList *lister);
-  void           Plot();
   virtual Long64_t  Merge(TCollection *li);
   void           AddTask(const AliTRDCalibTask * calibTask);
   Bool_t         FindP1TrackPHtrackletV1Test(const AliTRDseedV1 *tracklet, Int_t nbclusters);
@@ -107,6 +107,7 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   TList       *fListHist;                        //! list of histograms
 
   AliTRDCalibraFillHisto *fTRDCalibraFillHisto;  //! calibration analyse object
+  AliTRDCalibChamberStatus *fTRDChamberStatus;   //! calibration chamber status
 
   TH1I        *fNEvents;                         //! counter  
   TH1I        *fNEventsInput;                    //! counter  
@@ -177,6 +178,9 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   Int_t       fFirstRunVdrift;                   // FirstRunVdriftUsed 
   Int_t       fVersionVdriftUsed;                // VersionVdriftUsed 
   Int_t       fSubVersionVdriftUsed;             // SubVersionVdriftUsed
+  Int_t       fFirstRunExB;                      // FirstRunExBUsed 
+  Int_t       fVersionExBUsed;                   // VersionExBUsed 
+  Int_t       fSubVersionExBUsed;                // SubVersionExBUsed
 
   AliTRDCalDet *fCalDetGain;                     // Calib object gain
 

diff --git a/TRD/AliTRDCalibraFillHisto.cxx b/TRD/AliTRDCalibraFillHisto.cxx
index dfb11e75589729a53fabcc4a0845b7a0c63e45a4..b869adfbbd8af30ab356b45df3904dd0f6fb4350 100644 (file)
--- a/TRD/AliTRDCalibraFillHisto.cxx
+++ b/TRD/AliTRDCalibraFillHisto.cxx
@@ -154,6 +154,9 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
   ,fFirstRunVdrift(0)
   ,fVersionVdriftUsed(0) 
   ,fSubVersionVdriftUsed(0)
+  ,fFirstRunExB(0)
+  ,fVersionExBUsed(0) 
+  ,fSubVersionExBUsed(0)
   ,fCalibraMode(new AliTRDCalibraMode())
   ,fDebugStreamer(0)
   ,fDebugLevel(0)
@@ -236,6 +239,9 @@ AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
   ,fFirstRunVdrift(c.fFirstRunVdrift)
   ,fVersionVdriftUsed(c.fVersionVdriftUsed) 
   ,fSubVersionVdriftUsed(c.fSubVersionVdriftUsed)
+  ,fFirstRunExB(c.fFirstRunExB)
+  ,fVersionExBUsed(c.fVersionExBUsed) 
+  ,fSubVersionExBUsed(c.fSubVersionExBUsed)
   ,fCalibraMode(0x0)
   ,fDebugStreamer(0)
   ,fDebugLevel(c.fDebugLevel)
@@ -506,6 +512,14 @@ Bool_t AliTRDCalibraFillHisto::Init2Dhistos(Int_t nboftimebin)
       }
     }
     fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit();
+    TString nameee("Ver");
+    nameee += fVersionExBUsed;
+    nameee += "Subver";
+    nameee += fSubVersionExBUsed;
+    nameee += "FirstRun";
+    nameee += fFirstRunExB;
+    nameee += "Nz";
+    fLinearVdriftFit->SetNameCalibUsed(nameee); 
   }
 
   if (fPRF2dOn) {
@@ -577,6 +591,19 @@ Bool_t AliTRDCalibraFillHisto::InitCalDet()
   
   fPH2d->SetTitle(namee);  
 
+  // title AliTRDCalibraVdriftLinearFit
+  TString nameee("Ver");
+  nameee += fVersionExBUsed;
+  nameee += "Subver";
+  nameee += fSubVersionExBUsed;
+  nameee += "FirstRun";
+  nameee += fFirstRunExB;
+  nameee += "Nz";
+
+  
+  fLinearVdriftFit->SetNameCalibUsed(nameee);  
+
+
 
   return kTRUE;
 
@@ -1286,8 +1313,8 @@ Bool_t AliTRDCalibraFillHisto::IsPadOn(Int_t detector, Int_t row, Int_t col) con
     return kFALSE;
   }
   
-  if (!cal->IsChamberInstalled(detector)     || 
-       cal->IsChamberMasked(detector)        ||
+  if (!cal->IsChamberGood(detector)     || 
+       cal->IsChamberNoData(detector)        ||
        cal->IsPadMasked(detector,col,row)) {
     return kFALSE;
   }

diff --git a/TRD/AliTRDCalibraFillHisto.h b/TRD/AliTRDCalibraFillHisto.h
index f8ea7bd3631082f1336b56af190b631532606022..9a4453836ebd26850a56cd312527fae695e1d4f2 100644 (file)
--- a/TRD/AliTRDCalibraFillHisto.h
+++ b/TRD/AliTRDCalibraFillHisto.h
@@ -107,7 +107,10 @@ class AliTRDCalibraFillHisto : public TObject {
          void     SetFirstRunVdrift(Int_t firstRunVdrift)                   { fFirstRunVdrift = firstRunVdrift;   }
          void     SetVersionVdriftUsed(Int_t versionVdriftUsed)             { fVersionVdriftUsed = versionVdriftUsed;   }
          void     SetSubVersionVdriftUsed(Int_t subVersionVdriftUsed)       { fSubVersionVdriftUsed = subVersionVdriftUsed;   }
-       
+         void     SetFirstRunExB(Int_t firstRunExB)                         { fFirstRunExB = firstRunExB;   }
+         void     SetVersionExBUsed(Int_t versionExBUsed)                   { fVersionExBUsed = versionExBUsed;   }
+         void     SetSubVersionExBUsed(Int_t subVersionExBUsed)             { fSubVersionExBUsed = subVersionExBUsed;   }
+         
   
          Bool_t   GetPH2dOn() const                                         { return fPH2dOn;                 }
           Bool_t   GetCH2dOn() const                                         { return fCH2dOn;                 }
@@ -214,6 +217,9 @@ AliTRDCalibraVector *GetCalibraVector() const                                { r
          Int_t    fFirstRunVdrift;         // FirstRunVdrift 
          Int_t    fVersionVdriftUsed;      // VersionVdriftUsed 
          Int_t    fSubVersionVdriftUsed;   // SubVersionVdriftUsed
+         Int_t    fFirstRunExB;            // FirstRunExB 
+         Int_t    fVersionExBUsed;         // VersionExBUsed 
+         Int_t    fSubVersionExBUsed;      // SubVersionExBUsed
   // Calibration mode
          AliTRDCalibraMode *fCalibraMode;  // Calibration mode
 

diff --git a/TRD/AliTRDCalibraFit.cxx b/TRD/AliTRDCalibraFit.cxx
index 873a76fec554fff4a9050d94c1aa0f1e83237c3d..65037cc6087a5302deb3fa3a287ef24cdd4dd2f3 100644 (file)
--- a/TRD/AliTRDCalibraFit.cxx
+++ b/TRD/AliTRDCalibraFit.cxx
@@ -4592,7 +4592,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
       y[1] = pentea->GetBinContent(binmax-1);
       y[2] = pentea->GetBinContent(binmax);
       CalculPolynomeLagrange2(x,y,c0,c1,c2,c3,c4);
-      AliInfo("At the limit for beginning!");
+      //AliInfo("At the limit for beginning!");
       break;  
     case 2:
       minnn = pentea->GetBinCenter(binmax-2);
@@ -4810,20 +4810,20 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   if (binmin <= 1) {
     binmin = 2;
     put = 1;
-    AliInfo("Put the binmax from 1 to 2 to enable the fit");
+    //AliInfo("Put the binmax from 1 to 2 to enable the fit");
   }
   
   //check
   if((projPH->GetBinContent(binmin)-projPH->GetBinError(binmin)) < (projPH->GetBinContent(binmin+1))) {
-    AliInfo("Too many fluctuations at the end!");
+    //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!");
+    //AliInfo("Too many fluctuations at the end!");
     put = kFALSE;
   }
   if(TMath::Abs(pente->GetBinContent(binmin+1)) <= 0.0000000000001){
-    AliInfo("No entries for the next bin!");
+    //AliInfo("No entries for the next bin!");
     pente->SetBinContent(binmin,0);
     if(pente->GetEntries() > 0) binmin = (Int_t) pente->GetMinimumBin();
   }
@@ -4873,7 +4873,7 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
        (pente->GetBinContent(binmin+3) <= pente->GetBinContent(binmin+2)) &&
        ((binmin-3) >= TMath::Min(binmax+4, projPH->GetNbinsX())) &&
        (pente->GetBinContent(binmin-3) <= pente->GetBinContent(binmin-2))) {
-      AliInfo("polynome 4 false 2");
+      //AliInfo("polynome 4 false 2");
       put = kFALSE;
     }
     // poly 3
@@ -4991,18 +4991,18 @@ void AliTRDCalibraFit::FitLagrangePoly(TH1* projPH)
   }
   if((binmin == (nbins-1)) && ((binmin-2) < TMath::Min(binmax+4, projPH->GetNbinsX()))) {
     put = kFALSE;
-    AliInfo("At the limit for the drift and not usable!");
+    //AliInfo("At the limit for the drift and not usable!");
   }
 
   //pass
   if((binmin == (nbins-2)) && ((binmin-1) < TMath::Min(binmax+4, projPH->GetNbinsX()))){
     put = kFALSE;
-    AliInfo("For the drift...problem!");
+    //AliInfo("For the drift...problem!");
   }
   //pass but should not happen
   if((binmin <= (nbins-3)) && (binmin < TMath::Min(binmax+6, projPH->GetNbinsX()))){
     put = kFALSE;
-    AliInfo("For the drift...problem!");
+    //AliInfo("For the drift...problem!");
   }
   
   if(put) {

diff --git a/TRD/AliTRDCalibraVdriftLinearFit.cxx b/TRD/AliTRDCalibraVdriftLinearFit.cxx
index a2a25815f016c881de5716d6d82000016848e510..98b719180dccb6cd90887548bc9e776db1189ffe 100644 (file)
--- a/TRD/AliTRDCalibraVdriftLinearFit.cxx
+++ b/TRD/AliTRDCalibraVdriftLinearFit.cxx
@@ -46,6 +46,7 @@ ClassImp(AliTRDCalibraVdriftLinearFit) /*FOLD00*/
 AliTRDCalibraVdriftLinearFit::AliTRDCalibraVdriftLinearFit() : /*FOLD00*/
   TObject(),
   fVersion(0),
+  fNameCalibUsed(""),
   fLinearFitterHistoArray(540),
   fLinearFitterPArray(540),
   fLinearFitterEArray(540)
@@ -58,6 +59,7 @@ AliTRDCalibraVdriftLinearFit::AliTRDCalibraVdriftLinearFit() : /*FOLD00*/
 AliTRDCalibraVdriftLinearFit::AliTRDCalibraVdriftLinearFit(const AliTRDCalibraVdriftLinearFit &ped) : /*FOLD00*/
   TObject(ped),
   fVersion(ped.fVersion),
+  fNameCalibUsed(ped.fNameCalibUsed),
   fLinearFitterHistoArray(540),
   fLinearFitterPArray(540),
   fLinearFitterEArray(540)
@@ -84,6 +86,7 @@ AliTRDCalibraVdriftLinearFit::AliTRDCalibraVdriftLinearFit(const AliTRDCalibraVd
 AliTRDCalibraVdriftLinearFit::AliTRDCalibraVdriftLinearFit(const TObjArray &obja) : /*FOLD00*/
   TObject(),
   fVersion(0),
+  fNameCalibUsed(""),
   fLinearFitterHistoArray(540),
   fLinearFitterPArray(540),
   fLinearFitterEArray(540)

diff --git a/TRD/AliTRDCalibraVdriftLinearFit.h b/TRD/AliTRDCalibraVdriftLinearFit.h
index 95d1f7c9d4521e7e8431ce207d73d5d46cafd42f..44f236d5f19d9a016ba396797b8e387e33c6f279 100644 (file)
--- a/TRD/AliTRDCalibraVdriftLinearFit.h
+++ b/TRD/AliTRDCalibraVdriftLinearFit.h
@@ -19,6 +19,7 @@
 class TObjArray;
 class TH2S;
 class TTreeSRedirector;
+class TString;
 
 class AliTRDCalibraVdriftLinearFit : public TObject {
 
@@ -35,6 +36,8 @@ class AliTRDCalibraVdriftLinearFit : public TObject {
 
   void            Update(Int_t detector, Float_t tnp, Float_t pars1);
   void            FillPEArray();
+  void            SetNameCalibUsed(const char*name)          { fNameCalibUsed = name;};
+  const char*     GetNameCalibUsed() const                   { return fNameCalibUsed;};
   void            Add(const AliTRDCalibraVdriftLinearFit *ped);
   TH2S           *GetLinearFitterHisto(Int_t detector, Bool_t force=kFALSE);
   TH2S           *GetLinearFitterHistoForce(Int_t detector);
@@ -49,13 +52,14 @@ class AliTRDCalibraVdriftLinearFit : public TObject {
  private:
    
   Int_t           fVersion;                 // Version of the object
+  TString         fNameCalibUsed;           // Info of the version, subversion, firstrun of the calib used
 
   TObjArray       fLinearFitterHistoArray;  // TObjArray of histo2D for debugging Linear Fitters
   TObjArray       fLinearFitterPArray;      // Array of result parameters from linear fitters for the detectors
   TObjArray       fLinearFitterEArray;      // Array of result errors from linear fitters for the detectors
 
   
-  ClassDef(AliTRDCalibraVdriftLinearFit,1)  // Online Vdrift calibration
+  ClassDef(AliTRDCalibraVdriftLinearFit,2)  // Online Vdrift calibration
 
 };
 

diff --git a/TRD/Cal/AliTRDCalChamberStatus.cxx b/TRD/Cal/AliTRDCalChamberStatus.cxx
index 5b1664175996c40a9721eb83a0c411acce184ee6..23804d394ef4ce502b744af9f6add2ddd476719e 100644 (file)
--- a/TRD/Cal/AliTRDCalChamberStatus.cxx
+++ b/TRD/Cal/AliTRDCalChamberStatus.cxx
@@ -52,6 +52,91 @@ AliTRDCalChamberStatus::AliTRDCalChamberStatus(const Text_t *name, const Text_t
     fStatus[idet] = 0;
   }
 
+}
+//_____________________________________________________________________________
+void AliTRDCalChamberStatus::SetStatus(Int_t det, Char_t status) 
+{
+
+  //
+  // set the chamber status
+  //
+  //
+
+  switch(status)
+    {
+    case AliTRDCalChamberStatus::kGood:
+      SETBIT(fStatus[det], kGood);
+      CLRBIT(fStatus[det], kNoData);
+      CLRBIT(fStatus[det], kBadCalibrated);
+      break;
+    case AliTRDCalChamberStatus::kNoData:
+      CLRBIT(fStatus[det], kGood);
+      SETBIT(fStatus[det], kNoData);
+      SETBIT(fStatus[det], kNoDataHalfChamberSideA);
+      SETBIT(fStatus[det], kNoDataHalfChamberSideB);
+      //      SETBIT(fStatus[det], kBadCalibrated);
+      break;
+    case AliTRDCalChamberStatus::kNoDataHalfChamberSideA:
+      SETBIT(fStatus[det], kNoDataHalfChamberSideA);
+      if(TESTBIT(fStatus[det], kNoDataHalfChamberSideB)){
+       SETBIT(fStatus[det], kNoData);
+       CLRBIT(fStatus[det], kGood);
+      }
+      break;
+    case AliTRDCalChamberStatus::kNoDataHalfChamberSideB:
+      SETBIT(fStatus[det], kNoDataHalfChamberSideB);
+      if(TESTBIT(fStatus[det], kNoDataHalfChamberSideA)) {
+       CLRBIT(fStatus[det], kGood);
+       SETBIT(fStatus[det], kNoData);
+      }
+      break;
+    case AliTRDCalChamberStatus::kBadCalibrated:
+      CLRBIT(fStatus[det], kGood);
+      SETBIT(fStatus[det], kBadCalibrated);
+      break;
+    default:
+      CLRBIT(fStatus[det], kGood);
+      CLRBIT(fStatus[det], kNoData);
+      CLRBIT(fStatus[det], kNoDataHalfChamberSideA);
+      CLRBIT(fStatus[det], kNoDataHalfChamberSideB);
+      CLRBIT(fStatus[det], kBadCalibrated);
+    }
+
+}
+//_____________________________________________________________________________
+void AliTRDCalChamberStatus::UnsetStatusBit(Int_t det, Char_t status) 
+{
+
+  //
+  // unset the chamber status bit
+  //
+  //
+
+  switch(status)
+    {
+    case AliTRDCalChamberStatus::kGood:
+      CLRBIT(fStatus[det], kGood);
+      break;
+    case AliTRDCalChamberStatus::kNoData:
+      CLRBIT(fStatus[det], kNoData);
+      break;
+    case AliTRDCalChamberStatus::kNoDataHalfChamberSideA:
+      CLRBIT(fStatus[det], kNoDataHalfChamberSideA);
+      break;
+    case AliTRDCalChamberStatus::kNoDataHalfChamberSideB:
+      CLRBIT(fStatus[det], kNoDataHalfChamberSideB);
+      break;
+    case AliTRDCalChamberStatus::kBadCalibrated:
+      CLRBIT(fStatus[det], kBadCalibrated);
+      break;
+    default:
+      CLRBIT(fStatus[det], kGood);
+      CLRBIT(fStatus[det], kNoData);
+      CLRBIT(fStatus[det], kNoDataHalfChamberSideA);
+      CLRBIT(fStatus[det], kNoDataHalfChamberSideB);
+      CLRBIT(fStatus[det], kBadCalibrated);
+    }
+
 }
 //_____________________________________________________________________________
 TH2D* AliTRDCalChamberStatus::Plot(Int_t sm, Int_t rphi) 
@@ -71,15 +156,77 @@ TH2D* AliTRDCalChamberStatus::Plot(Int_t sm, Int_t rphi)
   
   for(Int_t i=start; i<end; i++) {
     Int_t layer  = i%6;
-    Int_t stack  = static_cast<int>((i-start)/6.);
+    Int_t stackn  = static_cast<int>((i-start)/6.);
     Int_t status = GetStatus(i);
+    h2->Fill(stackn,layer,status);
+    if(rphi == 0) {    
+      if(!TESTBIT(fStatus[i], kNoDataHalfChamberSideB)) h2->Fill(stackn,layer,status);
+    }
+    else if(rphi == 1) {
+      if(!TESTBIT(fStatus[i], kNoDataHalfChamberSideA)) h2->Fill(stackn,layer,status);
+    }
+  }
+
+  return h2;
+
+}
+//_____________________________________________________________________________
+TH2D* AliTRDCalChamberStatus::PlotNoData(Int_t sm, Int_t rphi) 
+{
+  //
+  // Plot chamber data status for supermodule and halfchamberside 
+  // as a function of layer and stack
+  //
+
+  TH2D *h2 = new TH2D(Form("sm_%d_rphi_%d_data",sm,rphi),Form("sm_%d_rphi_%d_data",sm,rphi),5,0.0,5.0,6,0.0,6.0);
+  
+  h2->SetXTitle("stack");
+  h2->SetYTitle("layer");
+
+  Int_t start = sm*30;
+  Int_t end = (sm+1)*30;
+  
+  for(Int_t i=start; i<end; i++) {
+    Int_t layer  = i%6;
+    Int_t stackn  = static_cast<int>((i-start)/6.);
+    if(rphi == 0) {    
+      if(TESTBIT(fStatus[i], kNoDataHalfChamberSideB)) h2->Fill(stackn,layer,1);
+      if(TESTBIT(fStatus[i], kNoData)) h2->Fill(stackn,layer,1);
+    }
+    else if(rphi == 1) {
+      if(!TESTBIT(fStatus[i], kNoDataHalfChamberSideA)) h2->Fill(stackn,layer,1);
+      if(!TESTBIT(fStatus[i], kNoData)) h2->Fill(stackn,layer,1);
+    }
+  }
+
+  return h2;
+
+}
+//_____________________________________________________________________________
+TH2D* AliTRDCalChamberStatus::PlotBadCalibrated(Int_t sm, Int_t rphi) 
+{
+  //
+  // Plot chamber calibration status for supermodule and halfchamberside 
+  // as a function of layer and stack
+  //
+
+  TH2D *h2 = new TH2D(Form("sm_%d_rphi_%d_calib",sm,rphi),Form("sm_%d_rphi_%d_calib",sm,rphi),5,0.0,5.0,6,0.0,6.0);
+  
+  h2->SetXTitle("stack");
+  h2->SetYTitle("layer");
+
+  Int_t start = sm*30;
+  Int_t end = (sm+1)*30;
+  
+  for(Int_t i=start; i<end; i++) {
+    Int_t layer  = i%6;
+    Int_t stackn  = static_cast<int>((i-start)/6.);
     if(rphi == 0) {    
-      if(status!=4) h2->Fill(stack,layer,status);
+      if(TESTBIT(fStatus[i], kBadCalibrated)) h2->Fill(stackn,layer,1);
     }
     else if(rphi == 1) {
-      if(status!=3) h2->Fill(stack,layer,status);
+      if(TESTBIT(fStatus[i], kBadCalibrated)) h2->Fill(stackn,layer,1);
     }
-    
   }
 
   return h2;
@@ -103,9 +250,9 @@ TH2D* AliTRDCalChamberStatus::Plot(Int_t sm)
   
   for(Int_t i=start; i<end; i++) {
     Int_t layer  = i%6;
-    Int_t stack  = static_cast<int>((i-start)/6.);
+    Int_t stackn  = static_cast<int>((i-start)/6.);
     Int_t status = GetStatus(i);
-    h2->Fill(stack,layer,status);
+    h2->Fill(stackn,layer,status);
   }
 
   return h2;

diff --git a/TRD/Cal/AliTRDCalChamberStatus.h b/TRD/Cal/AliTRDCalChamberStatus.h
index 413808e4337f7bad8406d7c53438924e27b89077..643acac461a04035a19c745603a3416e7d759886 100644 (file)
--- a/TRD/Cal/AliTRDCalChamberStatus.h
+++ b/TRD/Cal/AliTRDCalChamberStatus.h
@@ -11,6 +11,7 @@
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
+#include <Rtypes.h>
 #include "TNamed.h"
 
 class TH2D;
@@ -19,21 +20,25 @@ class AliTRDCalChamberStatus : public TNamed {
  public:
 
   enum { kNdet = 540, kNstacks = 90, kNcham = 5, kNsect = 18 };
-  enum { kInstalled = 1, kMasked = 2, kHalfChamberSideAMasked = 3, kHalfChamberSideBMasked = 4};
+  enum { kGood = 0, kNoData = 1, kNoDataHalfChamberSideA = 2, kNoDataHalfChamberSideB = 3, kBadCalibrated = 4};
   
   AliTRDCalChamberStatus();
   AliTRDCalChamberStatus(const Text_t* name, const Text_t* title);
 
   Char_t GetStatus(Int_t det) const          { return fStatus[det];   };
-  void   SetStatus(Int_t det, Char_t status) { fStatus[det] = status; };
-
-  Bool_t IsInstalled(Int_t det) const         { return (GetStatus(det) == kInstalled) ? kTRUE : kFALSE; }
-  Bool_t IsMasked(Int_t det) const            { return (GetStatus(det) == kMasked)    ? kTRUE : kFALSE; }
-  Bool_t IsHalfChamberSideAMasked(Int_t det) const     { return (GetStatus(det) == kHalfChamberSideAMasked)    ? kTRUE : kFALSE; }
-  Bool_t IsHalfChamberSideBMasked(Int_t det) const     { return (GetStatus(det) == kHalfChamberSideBMasked)    ? kTRUE : kFALSE; }
-
- TH2D *Plot(Int_t sm, Int_t rphi);          // Plot fStatus for sm and halfchamberside  
- TH2D *Plot(Int_t sm);                     // Plot fStatus for sm 
+  void   SetStatus(Int_t det, Char_t status);
+  void   UnsetStatusBit(Int_t det, Char_t status);
+
+  Bool_t IsGood(Int_t det) const             { return TESTBIT(fStatus[det], kGood);                   }
+  Bool_t IsNoData(Int_t det) const           { return TESTBIT(fStatus[det], kNoData);                 }
+  Bool_t IsNoDataSideA(Int_t det) const      { return TESTBIT(fStatus[det], kNoDataHalfChamberSideA); }
+  Bool_t IsNoDataSideB(Int_t det) const      { return TESTBIT(fStatus[det], kNoDataHalfChamberSideB); }
+  Bool_t IsBadCalibrated(Int_t det) const    { return TESTBIT(fStatus[det], kBadCalibrated);          }
+
+ TH2D *Plot(Int_t sm, Int_t rphi);           // Plot fStatus for sm and halfchamberside  
+ TH2D *PlotNoData(Int_t sm, Int_t rphi);     // Plot data status for sm and halfchamberside  
+ TH2D *PlotBadCalibrated(Int_t sm, Int_t rphi); // Plot calibration status for sm and halfchamberside  
+ TH2D *Plot(Int_t sm);                       // Plot fStatus for sm 
 
 
  protected: