Added QA for digits during reconstruction (Yves)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 24 May 2009 14:25:47 +0000 (14:25 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 24 May 2009 14:25:47 +0000 (14:25 +0000)
46 files changed:
ACORDE/AliACORDEQADataMakerRec.cxx
ACORDE/AliACORDEQADataMakerRec.h
EMCAL/AliEMCALQADataMakerRec.cxx
EMCAL/AliEMCALQADataMakerRec.h
FMD/AliFMDQADataMakerRec.cxx
FMD/AliFMDQADataMakerRec.h
HMPID/AliHMPIDQADataMakerRec.cxx
HMPID/AliHMPIDQADataMakerRec.h
ITS/AliITSQADataMakerRec.cxx
ITS/AliITSQADataMakerRec.h
ITS/AliITSQASDDDataMakerRec.cxx
ITS/AliITSQASDDDataMakerRec.h
ITS/AliITSQASPDDataMakerRec.cxx
ITS/AliITSQASPDDataMakerRec.h
ITS/AliITSQASSDDataMakerRec.cxx
ITS/AliITSQASSDDataMakerRec.h
MUON/AliMUONQADataMakerRec.cxx
MUON/AliMUONQADataMakerRec.h
PHOS/AliPHOSQADataMakerRec.cxx
PHOS/AliPHOSQADataMakerRec.h
PMD/AliPMDQADataMakerRec.cxx
PMD/AliPMDQADataMakerRec.h
STEER/AliDetectorRecoParam.h
STEER/AliQAChecker.cxx
STEER/AliQADataMakerRec.cxx
STEER/AliQADataMakerRec.h
STEER/AliQADataMakerSim.cxx
STEER/AliQADataMakerSim.h
STEER/AliQAManager.cxx
STEER/AliQAv1.cxx
STEER/AliQAv1.h
STEER/AliReconstruction.cxx
T0/AliT0QADataMakerRec.cxx
T0/AliT0QADataMakerRec.h
TOF/AliTOFQADataMakerRec.cxx
TOF/AliTOFQADataMakerRec.h
TPC/AliTPCQADataMakerRec.cxx
TPC/AliTPCQADataMakerRec.h
TRD/AliTRDQADataMakerRec.cxx
TRD/AliTRDQADataMakerRec.h
VZERO/AliVZEROQADataMakerRec.cxx
VZERO/AliVZEROQADataMakerRec.h
ZDC/AliZDCQADataMakerRec.cxx
ZDC/AliZDCQADataMakerRec.h
prod/LHC08d6/JDL
test/ppbench/runtest.sh

index 9203890..a6d2fe6 100755 (executable)
@@ -40,6 +40,7 @@
 #include "AliLog.h"
 #include "AliACORDEdigit.h" 
 #include "AliACORDEhit.h"
+#include "AliACORDEDigit.h"
 #include "AliACORDEQADataMakerRec.h"
 #include "AliQAChecker.h"
 #include "AliACORDERawReader.h"
@@ -98,6 +99,22 @@ void AliACORDEQADataMakerRec::InitRaws()
     Add2RawsList(fhACORDEBitPattern[i],i,!expert, image, !saveCorr);
 }
 //____________________________________________________________________________ 
+void AliACORDEQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *    fhDigitsModule;
+  TString   modulename;
+  modulename = "hDigitsModule";
+  fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle",60,0,60);
+  Add2DigitsList(fhDigitsModule,0,!expert,image);
+  
+}
+
+//____________________________________________________________________________ 
 
 void AliACORDEQADataMakerRec::InitRecPoints()
 {
@@ -189,6 +206,30 @@ if(rawStream.Next())
 }
 }
 //____________________________________________________________________________
+void AliACORDEQADataMakerRec::MakeDigits( TTree *digitsTree)
+{
+  //fills QA histos for Digits
+  TClonesArray * digits = new TClonesArray("AliACORDEdigit",1000);
+  TBranch * branch = digitsTree->GetBranch("ACORDEdigit");
+  if (!branch) {
+    AliWarning("ACORDE branch in Digits Tree not found");
+  } else {
+    branch->SetAddress(&digits);
+    for(Int_t track = 0 ; track < branch->GetEntries() ; track++) {
+      branch->GetEntry(track);
+      for(Int_t idigit = 0 ; idigit < digits->GetEntriesFast() ; idigit++) {
+        AliACORDEdigit *AcoDigit = (AliACORDEdigit*) digits->UncheckedAt(idigit);
+        if (!AcoDigit) {
+          AliError("The unchecked digit doesn't exist");
+          continue ;
+        }
+        GetDigitsData(0)->Fill(AcoDigit->GetModule()-1);
+      }
+    }
+  }
+}
+
+//____________________________________________________________________________
 void AliACORDEQADataMakerRec::MakeESDs(AliESDEvent * esd)
 {
   //fills QA histos for ESD
index 606527a..91826db 100755 (executable)
@@ -38,6 +38,9 @@ public:
 
 private:
   virtual void   InitRaws() ;    //book Digit QA histo
+  virtual void   InitDigits() ;    //book Digit QA histo
+  virtual void   MakeDigits(TTree* digitsTree) ;   //Fill Digit QA histo
+  virtual void   MakeDigits(TClonesArray *) {}       //Dummy for the moment
   virtual void   InitRecPoints();  //book cluster QA histo
   virtual void   InitESDs() ;      //book ESD QA histo 
   virtual void   MakeRaws(AliRawReader* rawReader) ;
index dfa8f09..68d5ab9 100644 (file)
@@ -38,6 +38,7 @@ Authors:  J.Klay (Cal Poly) May 2008
 #include "AliLog.h"
 #include "AliEMCALQADataMakerRec.h"
 #include "AliQAChecker.h"
+#include "AliEMCALDigit.h" 
 #include "AliEMCALRecPoint.h" 
 #include "AliEMCALRawUtils.h"
 #include "AliEMCALReconstructor.h"
@@ -108,6 +109,21 @@ void AliEMCALQADataMakerRec::InitESDs()
 }
 
 //____________________________________________________________________________ 
+void AliEMCALQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1I * h0 = new TH1I("hEmcalDigits",    "Digits amplitude distribution in EMCAL",    500, 0, 500) ; 
+  h0->Sumw2() ;
+  Add2DigitsList(h0, 0, !expert, image) ;
+  TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL", 200, 0, 2000) ; 
+  h1->Sumw2() ;
+  Add2DigitsList(h1, 1, !expert, image) ;
+}
+
+//____________________________________________________________________________ 
 void AliEMCALQADataMakerRec::InitRecPoints()
 {
   // create Reconstructed Points histograms in RecPoints subdir
@@ -367,6 +383,37 @@ void AliEMCALQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________
+void AliEMCALQADataMakerRec::MakeDigits(TClonesArray * digits)
+{
+  // makes data from Digits
+  
+  GetDigitsData(1)->Fill(digits->GetEntriesFast()) ; 
+  TIter next(digits) ; 
+  AliEMCALDigit * digit ; 
+  while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) {
+    GetDigitsData(0)->Fill( digit->GetAmp()) ;
+  }  
+  
+}
+
+//____________________________________________________________________________
+void AliEMCALQADataMakerRec::MakeDigits(TTree * digitTree)
+{
+  // makes data from Digit Tree
+  TClonesArray * digits = new TClonesArray("AliEMCALDigit", 1000) ; 
+  
+  TBranch * branch = digitTree->GetBranch("EMCAL") ;
+  if ( ! branch ) {
+    AliWarning("EMCAL branch in Digit Tree not found") ; 
+  } else {
+    branch->SetAddress(&digits) ;
+    branch->GetEntry(0) ; 
+    MakeDigits(digits) ; 
+  }
+  
+}
+
+//____________________________________________________________________________
 void AliEMCALQADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
   // makes data from RecPoints
index 0c0f6da..b0c7e4e 100644 (file)
@@ -50,9 +50,12 @@ public:
 private:
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
+  virtual void   InitDigits() ; 
   virtual void   InitRecPoints() ; 
   virtual void   InitRaws() ; 
   virtual void   MakeESDs(AliESDEvent * esd) ;
+  virtual void   MakeDigits(TClonesArray * digits) ;
+  virtual void   MakeDigits(TTree * digTree) ; 
   virtual void   MakeRecPoints(TTree * recpoTree) ; 
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   StartOfDetectorCycle() ; 
index f95d040..7f8da63 100644 (file)
@@ -115,6 +115,19 @@ void AliFMDQADataMakerRec::InitESDs()
     
 }
 
+//_____________________________________________________________________
+void AliFMDQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1I* hADCCounts = new TH1I("hADCCounts","Dist of ADC counts",1024,0,1024);
+  hADCCounts->SetXTitle("ADC counts");
+  Add2DigitsList(hADCCounts, 0, !expert, image);
+}
+
+
 //_____________________________________________________________________ 
 void AliFMDQADataMakerRec::InitRecPoints()
 {
@@ -196,7 +209,7 @@ void AliFMDQADataMakerRec::MakeESDs(AliESDEvent * esd)
   }
 }
 
-/*
+
 //_____________________________________________________________________
 void AliFMDQADataMakerRec::MakeDigits(TClonesArray * digits)
 {
@@ -227,7 +240,7 @@ void AliFMDQADataMakerRec::MakeDigits(TTree * digitTree)
   branch->GetEntry(0); 
   MakeDigits(digitsAddress);
 }
-*/
+
 //_____________________________________________________________________
 void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 {
index 58898d4..7dbef41 100644 (file)
@@ -28,12 +28,12 @@ public:
 private:
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
   virtual void   InitESDs(); 
-  //  virtual void   InitDigits(); 
+  virtual void   InitDigits(); 
   virtual void   InitRecPoints(); 
   virtual void   InitRaws(); 
   virtual void   MakeESDs(AliESDEvent * esd);
-  // virtual void   MakeDigits(TClonesArray * digits); 
-  // virtual void   MakeDigits(TTree * digitTree); 
+  virtual void   MakeDigits(TClonesArray * digits); 
+  virtual void   MakeDigits(TTree * digitTree); 
   virtual void   MakeRecPoints(TTree * recpoTree); 
   virtual void   MakeRaws(AliRawReader* rawReader); 
   virtual void   StartOfDetectorCycle(); 
index b085dbf..25e6607 100644 (file)
@@ -32,6 +32,7 @@
 #include "AliLog.h"
 #include "AliHMPIDDigit.h"
 #include "AliHMPIDHit.h"
+#include "AliHMPIDDigit.h"
 #include "AliHMPIDCluster.h"
 #include "AliHMPIDQADataMakerRec.h"
 #include "AliHMPIDQAChecker.h"
@@ -73,6 +74,30 @@ AliHMPIDQADataMakerRec& AliHMPIDQADataMakerRec::operator = (const AliHMPIDQAData
 }
  
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void AliHMPIDQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
+  TH1F *hDigPcEvt = new TH1F("hDigPcEvt","PC occupancy",156,-1,77);
+  TH2F *hDigMap[7];
+  TH1F *hDigQ[42];
+  for(Int_t iCh =0; iCh < 7; iCh++){
+    hDigMap[iCh] = new TH2F(Form("MapCh%i",iCh),Form("Digit Map in Chamber %i",iCh),159,0,159,143,0,143);
+    for(Int_t iPc =0; iPc < 6; iPc++ ){
+      hDigQ[iCh*6+iPc] = new TH1F(Form("QCh%iPc%i        ",iCh,iPc),Form("Charge of digits (ADC) in Chamber %i and PC %i   ",iCh,iPc),4100,0,4100);
+    }
+  }
+  
+  Add2DigitsList(hDigChEvt,0, !expert, image);
+  Add2DigitsList(hDigPcEvt,1,expert, !image);
+  for(Int_t iMap=0; iMap < 7; iMap++) Add2DigitsList(hDigMap[iMap],2+iMap,expert, !image);
+  for(Int_t iH =0; iH < 42 ; iH++) Add2DigitsList(hDigQ[iH]    ,9+iH,expert,!image);
+}
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDQADataMakerRec::InitRecPoints()
 {
   // create cluster histograms in RecPoint subdir
@@ -207,6 +232,55 @@ void AliHMPIDQADataMakerRec::MakeRaws(AliRawReader *rawReader)
    stream.Delete();
    
 }
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void AliHMPIDQADataMakerRec::MakeDigits(TClonesArray * data)
+{
+  //
+  //filling QA histos for Digits
+  //
+  
+  TObjArray *chamber = dynamic_cast<TObjArray*>(data);
+  if ( !chamber) {
+    AliError("Wrong type of digits container") ; 
+  } else {
+    for(Int_t i =0; i< chamber->GetEntries(); i++)
+      {
+      TClonesArray * digits = dynamic_cast<TClonesArray*>(chamber->At(i)); 
+      GetDigitsData(0)->Fill(i,digits->GetEntriesFast()/(48.*80.*6.));
+      TIter next(digits); 
+      AliHMPIDDigit * digit; 
+      while ( (digit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
+        GetDigitsData(1)->Fill(10.*i+digit->Pc(),1./(48.*80.));
+        GetDigitsData(2+i)->Fill(digit->PadChX(),digit->PadChY());
+        GetDigitsData(9+i*6+digit->Pc())->Fill(digit->Q());
+      }  
+      }
+  }
+}
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void AliHMPIDQADataMakerRec::MakeDigits(TTree * data)
+{
+  //
+  //Opening the Digit Tree
+  //
+  TObjArray *pObjDig=new TObjArray(AliHMPIDParam::kMaxCh+1);
+  for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++){
+    TClonesArray *pCA=new TClonesArray("AliHMPIDDigit");
+    pObjDig->AddAt(pCA,iCh);
+  }
+  
+  pObjDig->SetOwner(kTRUE);
+  
+  for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++){
+    data->SetBranchAddress(Form("HMPID%i",iCh),&(*pObjDig)[iCh]);
+  }
+  data->GetEntry(0);
+  
+  MakeDigits((TClonesArray *)pObjDig);
+}
+
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDQADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
index bcae699..45fb4ef 100644 (file)
@@ -30,9 +30,12 @@ public:
   virtual ~AliHMPIDQADataMakerRec() {;} // dtor
 
 private:
+  virtual void   InitDigits();  //book cluster QA histo
   virtual void   InitRecPoints();  //book cluster QA histo
   virtual void   InitRaws();     //book raw QA histo
   virtual void   InitESDs() ;      //book ESD QA histo 
+  virtual void   MakeDigits(TClonesArray* digits) ;
+  virtual void   MakeDigits(TTree * digits)    ;  //Fill cluster QA histo
   virtual void   MakeRecPoints(TTree * clusters)    ;  //Fill cluster QA histo
   virtual void   MakeRaws(AliRawReader* rawReader);
   virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
index 99c7f58..48b3e77 100644 (file)
@@ -186,6 +186,33 @@ void AliITSQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________ 
+void AliITSQADataMakerRec::InitDigits()
+{
+  // Initialization for DIGITS
+  if(fSubDetector == 0 || fSubDetector == 1) {
+    AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitDigitss\n");
+    fSPDDataMaker->InitDigits();
+  }
+  if(fSubDetector == 0 || fSubDetector == 2) {
+    AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitDigits\n");
+    fSDDDataMaker->InitDigits();
+  }
+  if(fSubDetector == 0 || fSubDetector == 3) {
+    AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitDigits\n");
+    fSSDDataMaker->InitDigits();
+  }
+}
+
+//____________________________________________________________________________ 
+void AliITSQADataMakerRec::MakeDigits(TTree * digitsTree)
+{
+  // Fill QA for recpoints
+  if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeDigits(digitsTree);
+  if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeDigits(digitsTree);
+  if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digitsTree);
+}
+
+//____________________________________________________________________________ 
 void AliITSQADataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS
index a8948d0..e690f5d 100644 (file)
@@ -39,9 +39,11 @@ public:
   virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
   virtual void EndOfDetectorCycle(const char *fgDataName);
   virtual void InitRaws();
+  virtual void InitDigits();
   virtual void InitRecPoints();
   virtual void InitESDs();
   virtual void MakeRaws(AliRawReader *rawReader);
+  virtual void MakeDigits(TTree *digitsTree);
   virtual void MakeRecPoints(TTree *clustersTree);
   virtual void MakeESDs(AliESDEvent *esd);
 
index fabfa8d..7cc3ccb 100644 (file)
@@ -46,6 +46,7 @@
 #include "AliITSRawStreamSDD.h"
 #include "AliITSRawStreamSDDCompressed.h"
 #include "AliITSDetTypeRec.h"
+#include "AliITSDigit.h"
 #include "AliITSRecPoint.h"
 #include "AliITSgeomTGeo.h"
 #include "AliITSHLTforSDD.h"
@@ -63,8 +64,10 @@ fAliITSQADataMakerRec(aliITSQADataMakerRec),
 fkOnline(kMode),
 fLDC(ldc),
 fSDDhRawsTask(0),
+fSDDhDigitsTask(0),
 fSDDhRecPointsTask(0),
 fGenRawsOffset(0),
+fGenDigitsOffset(0),
 fGenRecPointsOffset(0),
 fTimeBinSize(1),
 fDDLModuleMap(0),
@@ -91,8 +94,10 @@ fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
 fkOnline(qadm.fkOnline),
 fLDC(qadm.fLDC),
 fSDDhRawsTask(qadm.fSDDhRawsTask),
+fSDDhDigitsTask(qadm.fSDDhDigitsTask),
 fSDDhRecPointsTask(qadm.fSDDhRecPointsTask),
 fGenRawsOffset(qadm.fGenRawsOffset),
+fGenDigitsOffset(qadm.fGenDigitsOffset),
 fGenRecPointsOffset(qadm.fGenRecPointsOffset),
 fTimeBinSize(1),
 fDDLModuleMap(0),
@@ -394,6 +399,71 @@ void AliITSQASDDDataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________ 
+void AliITSQASDDDataMakerRec::InitDigits()
+{ 
+  // Initialization for DIGIT data - SDD -  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ;
+  
+  fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
+  //fSDDhTask must be incremented by one unit every time a histogram is ADDED to the QA List
+  TH1F* h0=new TH1F("SDD DIGITS Module Pattern","SDD DIGITS Module Pattern",260,239.5,499.5);       //hmod
+  h0->GetXaxis()->SetTitle("SDD Module Number");
+  h0->GetYaxis()->SetTitle("# DIGITS");
+  fAliITSQADataMakerRec->Add2DigitsList(h0,fGenDigitsOffset, !expert, image);
+  fSDDhDigitsTask ++;
+  TH1F* h1=new TH1F("SDD Anode Distribution","DIGITS Anode Distribution",512,-0.5,511.5);      //hanocc
+  h1->GetXaxis()->SetTitle("Anode Number");
+  h1->GetYaxis()->SetTitle("# DIGITS");
+  fAliITSQADataMakerRec->Add2DigitsList(h1,1+fGenDigitsOffset, !expert, image);
+  fSDDhDigitsTask ++;
+  TH1F* h2=new TH1F("SDD Tbin Distribution","DIGITS Tbin Distribution",256,-0.5,255.5);      //htbocc
+  h2->GetXaxis()->SetTitle("Tbin Number");
+  h2->GetYaxis()->SetTitle("# DIGITS");
+  fAliITSQADataMakerRec->Add2DigitsList(h2,2+fGenDigitsOffset, !expert, image);
+  fSDDhDigitsTask ++;
+  TH1F* h3=new TH1F("SDD ADC Counts Distribution","DIGITS ADC Counts Distribution",200,0.,1024.);          //hsig
+  h3->GetXaxis()->SetTitle("ADC Value");
+  h3->GetYaxis()->SetTitle("# DIGITS");
+  fAliITSQADataMakerRec->Add2DigitsList(h3,3+fGenDigitsOffset, !expert, image);
+  fSDDhDigitsTask ++;
+  AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Digits histograms booked\n",fSDDhDigitsTask));
+}
+
+//____________________________________________________________________________
+void AliITSQASDDDataMakerRec::MakeDigits(TTree * digits)
+{ 
+  
+  // Fill QA for DIGIT - SDD -
+//  AliITS *fITS  = (AliITS*)gAlice->GetModule("ITS");
+//  fITS->SetTreeAddress();
+//  TClonesArray *iITSdigits  = fITS->DigitsAddress(1);
+  TBranch *branchD = digits->GetBranch("ITS");
+  if (!branchD) { 
+    AliError("can't get the branch with the ITS digits !");
+    return;
+  }
+  static TClonesArray statDigits("AliITSDigit");
+  TClonesArray *iITSdigits = &statDigits;
+  branchD->SetAddress(&iITSdigits);
+  for(Int_t i=0; i<260; i++){
+    Int_t nmod=i+240;
+    digits->GetEvent(nmod);
+    Int_t ndigits = iITSdigits->GetEntries();
+    fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset)->Fill(nmod,ndigits);
+    for (Int_t idig=0; idig<ndigits; idig++) {
+      AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);
+      Int_t iz=dig->GetCoord1();  // cell number z
+      Int_t ix=dig->GetCoord2();  // cell number x
+      Int_t sig=dig->GetSignal();
+      fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset)->Fill(iz);
+      fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset)->Fill(ix);
+      fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset)->Fill(sig);
+    }
+  }
+}
+
+//____________________________________________________________________________ 
 void AliITSQASDDDataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS - SDD -
index 4f56534..939952b 100644 (file)
@@ -27,8 +27,11 @@ public:
   AliITSQASDDDataMakerRec(const AliITSQASDDDataMakerRec& qadm);
   AliITSQASDDDataMakerRec& operator = (const AliITSQASDDDataMakerRec& qac);
   virtual void InitRaws();
+  virtual void InitDigits();
   virtual void InitRecPoints();
   virtual void MakeRaws(AliRawReader *rawReader);
+  virtual void MakeDigits(TClonesArray* /*digits*/)  {return;}
+  virtual void MakeDigits(TTree *clustersTree);
   virtual void MakeRecPoints(TTree *clustersTree);
   virtual void StartOfDetectorCycle();
   virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
@@ -56,8 +59,10 @@ private:
   Bool_t  fkOnline;                           // online (1) or offline (0) use
   Int_t   fLDC;                               // LDC number (0 for offline, 1 to 4 for online) 
   Int_t   fSDDhRawsTask;                      // number of histo booked for each the Raws Task SDD
+  Int_t   fSDDhDigitsTask;                    // number of histo booked for each the RecPoints Task SDD
   Int_t   fSDDhRecPointsTask;                 // number of histo booked for each the RecPoints Task SDD
   Int_t   fGenRawsOffset;                     // QAchecking Raws offset       
+  Int_t   fGenDigitsOffset;                   // QAchecking RecPoints offset       
   Int_t   fGenRecPointsOffset;                // QAchecking RecPoints offset       
   Int_t   fTimeBinSize;                              // time bin width in number of clocks
   AliITSDDLModuleMapSDD  *fDDLModuleMap;      // SDD Detector configuration for the decoding
index 4a44dca..08a3136 100644 (file)
@@ -39,6 +39,7 @@
 #include "AliRawReader.h"
 #include "AliITSRawStreamSPD.h"
 #include "AliITSRawStreamSPDErrorLog.h"
+#include "AliITSDigit.h"
 #include "AliITSRecPoint.h"
 
 ClassImp(AliITSQASPDDataMakerRec)
@@ -50,8 +51,10 @@ fAliITSQADataMakerRec(aliITSQADataMakerRec),
 fkOnline(kMode),
 fLDC(ldc),
 fSPDhRawsTask(0),
+fSPDhDigitsTask(0),
 fSPDhRecPointsTask(0),
 fGenRawsOffset(0),
+fGenDigitsOffset(0),
 fGenRecPointsOffset(0),
 fAdvLogger(aliITSRawStreamSPDErrorLog) 
 {
@@ -65,8 +68,10 @@ fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
 fkOnline(qadm.fkOnline),
 fLDC(qadm.fLDC),
 fSPDhRawsTask(qadm.fSPDhRawsTask),
+fSPDhDigitsTask(qadm.fSPDhDigitsTask),
 fSPDhRecPointsTask(qadm.fSPDhRecPointsTask),
 fGenRawsOffset(qadm.fGenRawsOffset),
+fGenDigitsOffset(qadm.fGenDigitsOffset),
 fGenRecPointsOffset(qadm.fGenRecPointsOffset),
 fAdvLogger(qadm.fAdvLogger)
 {
@@ -235,6 +240,114 @@ void AliITSQASPDDataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________ 
+void AliITSQASPDDataMakerRec::InitDigits()
+{ 
+  // Initialization for DIGIT data - SPD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ;
+  
+  fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
+  //fSPDhDigitsTask must be incremented by one unit every time a histogram is ADDED to the QA List
+  
+  Char_t name[50];
+  Char_t title[50];
+  
+  TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
+  hlayer->GetXaxis()->SetTitle("Layer number");
+  hlayer->GetYaxis()->SetTitle("Entries");
+  fAliITSQADataMakerRec->Add2DigitsList(hlayer,fGenDigitsOffset, expert, !image);
+  fSPDhDigitsTask++;
+  
+  TH1F **hmod = new TH1F*[2];
+  for (Int_t iLay=0; iLay<2; iLay++) {
+    sprintf(name,"SPDModPattern_SPD%d",iLay+1);
+    sprintf(title,"Module map - SPD Layer %d",iLay+1);
+    hmod[iLay]=new TH1F(name,title,240,0,240);
+    hmod[iLay]->GetXaxis()->SetTitle("Module number");
+    hmod[iLay]->GetYaxis()->SetTitle("Entries");
+    fAliITSQADataMakerRec->Add2DigitsList(hmod[iLay],1+iLay+fGenDigitsOffset, !expert, image);
+    fSPDhDigitsTask++;
+  }
+  
+  TH1F *hcolumns = new TH1F("SPDColumns_SPD","Columns - SPD",160,0.,160.);
+  hcolumns->GetXaxis()->SetTitle("Column number");
+  hcolumns->GetYaxis()->SetTitle("Entries");
+  fAliITSQADataMakerRec->Add2DigitsList(hcolumns,3+fGenDigitsOffset, expert, !image);
+  fSPDhDigitsTask++;
+  
+  TH1F *hrows = new TH1F("SPDRows_SPD","Rows - SPD",256,0.,256.);
+  hrows->GetXaxis()->SetTitle("Row number");
+  hrows->GetYaxis()->SetTitle("Entries");
+  fAliITSQADataMakerRec->Add2DigitsList(hrows,4+fGenDigitsOffset, expert, !image);
+  fSPDhDigitsTask++;
+  
+  TH1F** hMultSPDdigits = new TH1F*[2];
+  for (Int_t iLay=0; iLay<2; ++iLay) {
+    sprintf(name,"SPDDigitMultiplicity_SPD%d",iLay+1);
+    sprintf(title,"Digit multiplicity - SPD Layer %d",iLay+1);
+    hMultSPDdigits[iLay]=new TH1F(name,title,200,0.,200.);
+    hMultSPDdigits[iLay]->GetXaxis()->SetTitle("Digit multiplicity");
+    hMultSPDdigits[iLay]->GetYaxis()->SetTitle("Entries");
+    fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenDigitsOffset, !expert, image);
+    fSPDhDigitsTask++;
+  }
+  
+  TH2F *hMultSPDdig2MultSPDdig1 
+    = new TH2F("SPDDigitMultCorrelation_SPD","Digit multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
+  hMultSPDdig2MultSPDdig1->GetXaxis()->SetTitle("Digit multiplicity (Layer 1)");
+  hMultSPDdig2MultSPDdig1->GetYaxis()->SetTitle("Digit multiplicity (Layer 2)");
+  fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenDigitsOffset, !expert, image);
+  fSPDhDigitsTask++;
+  
+  AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Digits histograms booked\n",fSPDhDigitsTask));
+  
+}
+
+//____________________________________________________________________________
+void AliITSQASPDDataMakerRec::MakeDigits(TTree *digits)
+{ 
+  // Fill QA for DIGIT - SPD -
+//  AliITS *fITS  = (AliITS*)gAlice->GetModule("ITS");
+//  fITS->SetTreeAddress();
+//  TClonesArray *iITSdigits  = fITS->DigitsAddress(0);  // 0->SPD
+  TBranch *branchD = digits->GetBranch("ITS");
+  if (!branchD) { 
+    AliError("can't get the branch with the ITS digits !");
+    return;
+  }
+  static TClonesArray statDigits("AliITSDigit");
+  TClonesArray *iITSdigits = &statDigits;
+  branchD->SetAddress(&iITSdigits);  
+  Int_t nDigitsL1=0;
+  Int_t nDigitsL2=0;
+  
+  for (Int_t imod=0; imod<240; ++imod){
+    digits->GetEvent(imod);
+    Int_t ndigits = iITSdigits->GetEntries();
+    if (imod<80) {
+      fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset)->Fill(0.5,ndigits);
+      fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset)->Fill(imod,ndigits);
+      nDigitsL1+=ndigits;
+    }
+    else {
+      fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset)->Fill(1,ndigits);
+      fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset)->Fill(imod,ndigits);
+      nDigitsL2+=ndigits;
+    }
+    for (Int_t idig=0; idig<ndigits; ++idig) {
+      AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);
+      Int_t col=dig->GetCoord1();  // cell number z
+      Int_t row=dig->GetCoord2();  // cell number x
+      fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset)->Fill(col);
+      fAliITSQADataMakerRec->GetDigitsData(4+fGenDigitsOffset)->Fill(row);
+    }
+  }
+  fAliITSQADataMakerRec->GetDigitsData(5+fGenDigitsOffset)->Fill(nDigitsL1);
+  fAliITSQADataMakerRec->GetDigitsData(6+fGenDigitsOffset)->Fill(nDigitsL2);
+  fAliITSQADataMakerRec->GetDigitsData(7+fGenDigitsOffset)->Fill(nDigitsL1,nDigitsL2);
+}
+
+//____________________________________________________________________________ 
 void AliITSQASPDDataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS - SPD -
index 86ed213..53f75fe 100644 (file)
@@ -29,9 +29,12 @@ public:
   AliITSQASPDDataMakerRec(const AliITSQASPDDataMakerRec& qadm);
   AliITSQASPDDataMakerRec& operator = (const AliITSQASPDDataMakerRec& qac);
   virtual void InitRaws();
+  virtual void InitDigits();
   virtual void InitRecPoints();
   virtual void MakeRaws(AliRawReader *rawReader);
   virtual void MakeRecPoints(TTree *clustersTree);
+  virtual void MakeDigits(TClonesArray* /*digits*/)  {return;}
+  virtual void MakeDigits(TTree *clustersTree);
   virtual void StartOfDetectorCycle();
   virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
   virtual ~AliITSQASPDDataMakerRec();   // dtor
@@ -48,12 +51,14 @@ private:
   Bool_t  fkOnline;                           //online (1) or offline (0) use
   Int_t   fLDC;                               //LDC number (0 for offline, 1 to 4 for online) 
   Int_t   fSPDhRawsTask;                      // number of booked SPD histograms for the Raws Task
+  Int_t   fSPDhDigitsTask;                    // number of booked SPD histograms for the RecPoints Task
   Int_t   fSPDhRecPointsTask;                 // number of booked SPD histograms for the RecPoints Task
   Int_t   fGenRawsOffset;                     // QAchecking Raws offset
+  Int_t   fGenDigitsOffset;                   // QAchecking RecPoints offset
   Int_t   fGenRecPointsOffset;                // QAchecking RecPoints offset
   AliITSRawStreamSPDErrorLog *fAdvLogger;  // pointer to special error logger object
 
-  ClassDef(AliITSQASPDDataMakerRec,3)      // description 
+  ClassDef(AliITSQASPDDataMakerRec,4)      // description 
 
 };
 
index 49d65f7..e0f81f7 100644 (file)
@@ -42,6 +42,7 @@
 #include "AliITSgeomTGeo.h"
 #include "AliRawEventHeaderBase.h"
 #include "AliITSRecPoint.h"
+#include "AliITSDigit.h"
 #include "AliITSBadChannelsSSDv2.h"
 
 #include "AliCDBManager.h"
@@ -59,8 +60,10 @@ fLDC(ldc),
 fSSDRawsOffset(0), fSSDRawsDAOffset(0),
 fSSDRawsCommonLevelOffset(0),
 fSSDhRawsTask(0),
+fSSDhDigitsTask(0),
 fSSDhRecPointsTask(0),
 fGenRawsOffset(0),
+fGenDigitsOffset(0),
 fGenRecPointsOffset(0),
 fCDBManager(0) {
   // Default constructor   
@@ -112,8 +115,10 @@ fLDC(qadm.fLDC),
 fSSDRawsOffset(qadm.fSSDRawsOffset), fSSDRawsDAOffset(qadm.fSSDRawsDAOffset),
 fSSDRawsCommonLevelOffset(qadm.fSSDRawsCommonLevelOffset),
 fSSDhRawsTask(qadm.fSSDhRawsTask),
+fSSDhDigitsTask(qadm.fSSDhDigitsTask),
 fSSDhRecPointsTask(qadm.fSSDhRecPointsTask),
 fGenRawsOffset(qadm.fGenRawsOffset),
+fGenDigitsOffset(qadm.fGenDigitsOffset),
 fGenRecPointsOffset(qadm.fGenRecPointsOffset),
 fCDBManager(qadm.fCDBManager) {
   //copy ctor 
@@ -882,6 +887,62 @@ void AliITSQASSDDataMakerRec::MonitorOCDBObjects() {
 }
 
 //____________________________________________________________________________ 
+void AliITSQASSDDataMakerRec::InitDigits() { 
+  // Initialization for DIGIT data - SSD -
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
+  
+  // custom code here
+  TH1F *fHistSSDModule = new TH1F("fHistSSDDigitsModule",
+                                  ";SSD Module Number;N_{DIGITS}",
+                                  1698,499.5,2197.5);  
+  fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModule,
+                                        fGenDigitsOffset + 0, !expert, image);
+  fSSDhDigitsTask += 1;
+  TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
+                                       ";N_{Strip};N_{Module}",
+                                       1540,0,1540,1698,499.5,2197.5);  
+  fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModuleStrip,
+                                        fGenDigitsOffset + 1, !expert, image);
+  fSSDhDigitsTask += 1;
+  
+  AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Digits histograms booked\n",fSSDhDigitsTask));
+  
+}
+
+//____________________________________________________________________________
+void AliITSQASSDDataMakerRec::MakeDigits(TTree *digits) { 
+  // Fill QA for DIGIT - SSD -
+//  AliITS *fITS  = (AliITS*)gAlice->GetModule("ITS");
+//  fITS->SetTreeAddress();
+//  TClonesArray *iSSDdigits  = fITS->DigitsAddress(2);
+  TBranch *branchD = digits->GetBranch("ITS");
+  if (!branchD) { 
+    AliError("can't get the branch with the ITS digits !");
+    return;
+  }
+  static TClonesArray statDigits("AliITSDigit");
+  TClonesArray *iSSDdigits = &statDigits;
+  branchD->SetAddress(&iSSDdigits);  
+  for(Int_t iModule = 500; iModule < 2198; iModule++) {
+    iSSDdigits->Clear();
+    digits->GetEvent(iModule);    
+    Int_t ndigits = iSSDdigits->GetEntries();
+    fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset + 0)->Fill(iModule,ndigits);
+    if(ndigits != 0)
+      AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
+    
+    for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
+      AliITSdigit *dig = (AliITSdigit*)iSSDdigits->UncheckedAt(iDigit);
+      Int_t fStripNumber = (dig->GetCoord1() == 0) ? dig->GetCoord2() : dig->GetCoord2() + fgkNumberOfPSideStrips;
+      ((TH2F *)fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
+    }//digit loop
+  }//module loop
+}
+
+//____________________________________________________________________________ 
 void AliITSQASSDDataMakerRec::InitRecPoints()
 {
   // Initialization for RECPOINTS - SSD -
index e65d14c..7d1a56b 100644 (file)
@@ -31,8 +31,11 @@ public:
   AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm);
   AliITSQASSDDataMakerRec& operator = (const AliITSQASSDDataMakerRec& qac);
   virtual void InitRaws();
+  virtual void InitDigits();
   virtual void InitRecPoints();
   virtual void MakeRaws(AliRawReader *rawReader);
+  virtual void MakeDigits(TClonesArray* /*digits*/)  {return;}
+  virtual void MakeDigits(TTree *digitsTree);
   virtual void MakeRecPoints(TTree *clustersTree);
   virtual void StartOfDetectorCycle();
   virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
@@ -70,8 +73,10 @@ public:
   Int_t   fSSDRawsDAOffset;                     //SSD DA plot offset
   Int_t   fSSDRawsCommonLevelOffset;            //Raw data QA - top level offset - histos used both online and offline 
   Int_t   fSSDhRawsTask;                        //number of histo booked for the raws SSD task 
+  Int_t   fSSDhDigitsTask;                      //number of histo booked for the recpoints SSD task
   Int_t   fSSDhRecPointsTask;                   //number of histo booked for the recpoints SSD task
   Int_t   fGenRawsOffset;                       //qachecking raws       offset
+  Int_t   fGenDigitsOffset;                     //qachecking recpoints  offset
   Int_t   fGenRecPointsOffset;                  //qachecking recpoints  offset
   TH1D   *fHistSSDRawSignalModule[fgkSSDMODULES]; //raw signal vs strip number - SSD                   
   Int_t   fOccupancyMatrix[fgkSSDMODULES][2*fgkNumberOfPSideStrips]; //occupancy values per strip
index a247343..93a7a31 100644 (file)
@@ -64,6 +64,7 @@
 #include "AliQAChecker.h"
 #include "AliCodeTimer.h"
 #include "AliDCSValue.h"
+#include "AliMUONVDigit.h"
 
 // --- ROOT system ---
 #include <TClonesArray.h>
@@ -546,6 +547,21 @@ void AliMUONQADataMakerRec::InitRaws()
        fIsInitRaws = kTRUE;
 }
 
+//__________________________________________________________________
+void AliMUONQADataMakerRec::InitDigits() 
+{
+  /// Initialized Digits spectra 
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1I* h0 = new TH1I("hDigitsDetElem", "Detection element distribution in Digits",  1400, 100, 1500); 
+  Add2DigitsList(h0, 0, !expert, image);
+  
+  TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits", 4096, 0, 4095); 
+  Add2DigitsList(h1, 1, !expert, image);  
+  
+} 
+
 //____________________________________________________________________________ 
 void AliMUONQADataMakerRec::InitRecPoints()
 {
@@ -1025,6 +1041,26 @@ void AliMUONQADataMakerRec::MakeRawsTrigger(AliRawReader* rawReader)
     } // NextDDL
 }
 
+//__________________________________________________________________
+void AliMUONQADataMakerRec::MakeDigits(TTree* digitsTree)         
+{
+  /// makes data from Digits
+  if (!fDigitStore)
+    fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
+  fDigitStore->Connect(*digitsTree, false);
+  digitsTree->GetEvent(0);
+  
+  TIter next(fDigitStore->CreateIterator());
+  
+  AliMUONVDigit* dig = 0x0;
+  
+  while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
+    {
+    GetDigitsData(0)->Fill(dig->DetElemId());
+    GetDigitsData(1)->Fill(dig->ADC());
+    }
+}
+
 //____________________________________________________________________________
 void AliMUONQADataMakerRec::MakeRecPoints(TTree* clustersTree)
 {
index 29407d9..4d0483d 100644 (file)
@@ -36,10 +36,13 @@ protected:
   virtual void StartOfDetectorCycle(); 
 
   virtual void InitRaws(); 
+  virtual void InitDigits(); 
   virtual void InitRecPoints(); 
   virtual void InitESDs(); 
   
   virtual void MakeRaws(AliRawReader* rawReader); 
+  virtual void MakeDigits(TTree* dig); 
+  virtual void MakeDigits(TClonesArray* /*digits*/)  {return;}
   virtual void MakeRecPoints(TTree* recpo); 
   virtual void MakeESDs(AliESDEvent* esd) ;
   
index c05a209..8f929a8 100644 (file)
@@ -38,6 +38,7 @@
 #include "AliLog.h"
 #include "AliPHOSQADataMakerRec.h"
 #include "AliQAChecker.h"
+#include "AliPHOSDigit.h" 
 #include "AliPHOSCpvRecPoint.h" 
 #include "AliPHOSEmcRecPoint.h" 
 #include "AliPHOSRecParticle.h" 
@@ -119,6 +120,20 @@ void AliPHOSQADataMakerRec::InitESDs()
 }
 
 //____________________________________________________________________________ 
+void AliPHOSQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  TH1I * h0 = new TH1I("hPhosDigits",    "Digits amplitude distribution in PHOS",    500, 0, 1000) ; 
+  h0->Sumw2() ;
+  Add2DigitsList(h0, kDigits, !expert, image) ;
+  TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS", 2000, 0, 10000) ; 
+  h1->Sumw2() ;
+  Add2DigitsList(h1, kDigitsMul, !expert, image) ;
+}
+
+//____________________________________________________________________________ 
 void AliPHOSQADataMakerRec::InitRecPoints()
 {
   // create Reconstructed Points histograms in RecPoints subdir
@@ -460,6 +475,36 @@ void AliPHOSQADataMakerRec::MakeRaws(AliRawReader* rawReader)
   p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kNtotHG)->GetName()))) ; 
   if (p) p->SetVal(hgNtot) ; 
 }
+
+//____________________________________________________________________________
+void AliPHOSQADataMakerRec::MakeDigits(TClonesArray * digits)
+{
+  // makes data from Digits
+  
+  GetDigitsData(1)->Fill(digits->GetEntriesFast()) ; 
+  TIter next(digits) ; 
+  AliPHOSDigit * digit ; 
+  while ( (digit = dynamic_cast<AliPHOSDigit *>(next())) ) {
+    GetDigitsData(kDigits)->Fill( digit->GetEnergy()) ;
+  }  
+}
+
+//____________________________________________________________________________
+void AliPHOSQADataMakerRec::MakeDigits(TTree * digitTree)
+{
+       // makes data from Digit Tree
+       TClonesArray * digits = new TClonesArray("AliPHOSDigit", 1000) ; 
+  
+       TBranch * branch = digitTree->GetBranch("PHOS") ;
+       if ( ! branch ) {
+               AliWarning("PHOS branch in Digit Tree not found") ; 
+       } else {
+               branch->SetAddress(&digits) ;
+               branch->GetEntry(0) ; 
+               MakeDigits(digits) ; 
+       }
+}
+
 //____________________________________________________________________________
 void AliPHOSQADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
index 5401af1..4305a6c 100644 (file)
@@ -43,6 +43,8 @@ public:
                 kRPNtot,kRPEtot,kRPSpec,kRPTime,kRPNcpv} ;
   //Histograms for ESDs  control
   enum HESDType_t {kESDNtot,kESDEtot,kESDSpec,kESDpid} ;
+  enum HDigitType_t  {kDigits=0, kDigitsMul} ; 
+
                  
 
 public:
@@ -56,9 +58,12 @@ private:
 
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
+  virtual void   InitDigits() ; 
   virtual void   InitRecPoints() ; 
   virtual void   InitRaws() ; 
   virtual void   MakeESDs(AliESDEvent * esd) ;
+  virtual void   MakeDigits(TClonesArray * digits) ;
+  virtual void   MakeDigits(TTree * recpoTree) ; 
   virtual void   MakeRecPoints(TTree * recpoTree) ; 
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   StartOfDetectorCycle() ; 
index 0fb3e68..e6eeeb8 100644 (file)
@@ -35,6 +35,7 @@
 #include "AliLog.h"
 #include "AliPMDQADataMakerRec.h"
 #include "AliQAChecker.h"
+#include "AliPMDDigit.h" 
 #include "AliPMDrecpoint1.h" 
 #include "AliPMDRawStream.h"
 #include "AliPMDddldata.h"
@@ -285,6 +286,32 @@ void AliPMDQADataMakerRec::InitRaws()
     //Add2RawsList(h49, 49);//Ajay
 
 }
+
+//____________________________________________________________________________
+void AliPMDQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F *h0 = new TH1F("hPreDigitsEdep","Digits energy distribution in PRE(PMD)", 100, 0., 2000.);
+  h0->Sumw2();
+  Add2DigitsList(h0, 0, !expert, image);
+  
+  TH1F *h1 = new TH1F("hCpvDigitsEdep","Digits energy distribution in CPV(PMD)", 100, 0., 2000.); 
+  h1->Sumw2();
+  Add2DigitsList(h1, 1, !expert, image);
+  
+  TH1I *h2 = new TH1I("hPreDigitsMult","Digits multiplicity distribution in PRE(PMD)", 500, 0, 1000) ; 
+  h2->Sumw2();
+  Add2DigitsList(h2, 2, !expert, image);
+  
+  TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD)", 500, 0, 1000);
+  h3->Sumw2();
+  Add2DigitsList(h3, 3, !expert, image);
+  
+}
+
 //____________________________________________________________________________ 
 void AliPMDQADataMakerRec::InitRecPoints()
 {
@@ -461,6 +488,60 @@ void AliPMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 
 }
 //____________________________________________________________________________
+void AliPMDQADataMakerRec::MakeDigits(TClonesArray * digits)
+{
+  // makes data from Digits
+  
+  Int_t cpvmul = 0, premul = 0;
+  
+  TIter next(digits) ; 
+  AliPMDdigit * digit ; 
+  while ( (digit = dynamic_cast<AliPMDdigit *>(next())) )
+    {
+    if(digit->GetDetector() == 0)
+      {
+           GetDigitsData(0)->Fill( digit->GetADC()) ;
+           premul++;
+      }
+    if(digit->GetDetector() == 1)
+      {
+           GetDigitsData(1)->Fill( digit->GetADC());
+           cpvmul++;
+      }
+    }  
+  
+  if (premul > 0) GetDigitsData(2)->Fill(premul);
+  if (cpvmul > 0) GetDigitsData(3)->Fill(cpvmul);
+  
+  
+}
+
+//____________________________________________________________________________
+void AliPMDQADataMakerRec::MakeDigits(TTree * digitTree)
+{
+  // makes data from Digit Tree
+  
+  TClonesArray * digits = new TClonesArray("AliPMDdigit", 1000) ; 
+  
+  TBranch * branch = digitTree->GetBranch("PMDDigit") ;
+  branch->SetAddress(&digits) ;
+  
+  if ( ! branch )
+    {
+    AliWarning("PMD branch in Digit Tree not found") ; 
+    }
+  else
+    {
+    for (Int_t ient = 0; ient < branch->GetEntries(); ient++)
+      {
+           branch->GetEntry(ient) ; 
+           MakeDigits(digits) ; 
+      }
+    
+    }
+}
+
+//____________________________________________________________________________
 void AliPMDQADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
     // makes data from RecPoints
index 4bbe074..66d98da 100644 (file)
@@ -32,9 +32,12 @@ class AliPMDQADataMakerRec: public AliQADataMakerRec {
  private:
     
     virtual void   InitRaws() ; 
+    virtual void   InitDigits() ; 
     virtual void   InitRecPoints() ; 
     virtual void   InitESDs() ; 
     virtual void   MakeRaws(AliRawReader* rawReader) ; 
+    virtual void   MakeDigits(TClonesArray* digits)  ; 
+    virtual void   MakeDigits(TTree * recpoTree) ; 
     virtual void   MakeRecPoints(TTree * recpoTree) ; 
     virtual void   MakeESDs(AliESDEvent * esd) ;
     virtual void   StartOfDetectorCycle() ; 
index f7d16ef..b97726f 100644 (file)
@@ -29,7 +29,7 @@ class AliDetectorRecoParam : public TNamed
 
 private:
 
-  Int_t  fEventSpecie; // Event specie for which the reco-param object is valid
+  Int_t fEventSpecie; // Event specie for which the reco-param object is valid
   
   ClassDef(AliDetectorRecoParam, 3)
 };
index 9cd16ed..f3253fd 100644 (file)
@@ -312,7 +312,7 @@ void AliQAChecker::LoadRunInfoFromGRP()
 //_____________________________________________________________________________
 Bool_t AliQAChecker::Run(const char * fileName)
 {
-  // run the Quality Assurance Checker for all tasks Hits, SDigits, Digits, recpoints, tracksegments, recparticles and ESDs
+  // run the Quality Assurance Checker for all tasks Hits, SDigits, Digits, DigitsR, RecPoints, TrackSegments, RecParticles and ESDs
   // starting from data in file  
   TStopwatch stopwatch;
   stopwatch.Start();
@@ -357,6 +357,8 @@ Bool_t AliQAChecker::Run(const char * fileName)
         index = AliQAv1::kSIM ; 
       if ( taskName == AliQAv1::GetTaskName(AliQAv1::kDIGITS) ) 
         index = AliQAv1::kSIM ; 
+      if ( taskName == AliQAv1::GetTaskName(AliQAv1::kDIGITSR) ) 
+        index = AliQAv1::kREC ; 
       if ( taskName == AliQAv1::GetTaskName(AliQAv1::kRECPOINTS) ) 
         index = AliQAv1::kREC ; 
       if ( taskName == AliQAv1::GetTaskName(AliQAv1::kTRACKSEGMENTS) ) 
@@ -405,6 +407,8 @@ Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task
                index = AliQAv1::kSIM ; 
        else if ( task == AliQAv1::kDIGITS ) 
                index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kDIGITSR ) 
+               index = AliQAv1::kREC ; 
        else if ( task == AliQAv1::kRECPOINTS ) 
                index = AliQAv1::kREC ; 
        else if ( task == AliQAv1::kTRACKSEGMENTS ) 
@@ -443,6 +447,8 @@ Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task
                index = AliQAv1::kSIM ; 
        else if ( task == AliQAv1::kDIGITS ) 
                index = AliQAv1::kSIM ; 
+       else if ( task == AliQAv1::kDIGITSR ) 
+               index = AliQAv1::kREC ; 
        else if ( task == AliQAv1::kRECPOINTS ) 
                index = AliQAv1::kREC ; 
        else if ( task == AliQAv1::kTRACKSEGMENTS ) 
index 8bb2306..54e08cb 100644 (file)
@@ -50,6 +50,7 @@ AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) :
   AliQADataMaker(name, title), 
   fESDsQAList(NULL), 
   fRawsQAList(NULL), 
+  fDigitsQAList(NULL),
   fRecPointsQAList(NULL),
   fCorrNt(NULL), 
   fRecoParam(NULL) 
@@ -63,6 +64,7 @@ AliQADataMakerRec::AliQADataMakerRec(const AliQADataMakerRec& qadm) :
   AliQADataMaker(qadm.GetName(), qadm.GetTitle()), 
   fESDsQAList(qadm.fESDsQAList),
   fRawsQAList(qadm.fRawsQAList),
+  fDigitsQAList(qadm.fDigitsQAList),
   fRecPointsQAList(qadm.fRecPointsQAList),
   fCorrNt(qadm.fCorrNt),  
   fRecoParam(qadm.fRecoParam) 
@@ -95,6 +97,15 @@ AliQADataMakerRec::~AliQADataMakerRec()
     }
     delete[] fRawsQAList ;
   }
+       if ( fDigitsQAList ) {
+    for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+      if ( fDigitsQAList[specie] ) {
+        if ( fDigitsQAList[specie]->IsOwner() ) 
+          fDigitsQAList[specie]->Delete() ;
+      }
+    }
+               delete[] fDigitsQAList ; 
+  }
        if ( fRecPointsQAList ) {
     for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
       if ( fRecPointsQAList[specie] ) {
@@ -120,6 +131,7 @@ void AliQADataMakerRec::EndOfCycle()
 {
   // Finishes a cycle of QA for all the tasks
   EndOfCycle(AliQAv1::kRAWS) ; 
+  EndOfCycle(AliQAv1::kDIGITSR) ; 
   EndOfCycle(AliQAv1::kRECPOINTS) ; 
   EndOfCycle(AliQAv1::kESDS) ; 
   ResetCycle() ; 
@@ -134,6 +146,8 @@ void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task)
        
        if ( task == AliQAv1::kRAWS )     
                list = fRawsQAList ; 
+       else if ( task == AliQAv1::kDIGITSR ) 
+               list = fDigitsQAList ; 
        else if ( task == AliQAv1::kRECPOINTS ) 
                list = fRecPointsQAList ; 
        else if ( task == AliQAv1::kESDS )
@@ -202,6 +216,9 @@ void AliQADataMakerRec::MakeImage(AliQAv1::TASKINDEX_t task)
       break;  
     case AliQAv1::kDIGITS:
       break;  
+    case AliQAv1::kDIGITSR:
+      list = fDigitsQAList ; 
+      break;  
     case AliQAv1::kRECPOINTS:
       list = fRecPointsQAList ; 
       break;
@@ -277,6 +294,14 @@ void AliQADataMakerRec::Exec(AliQAv1::TASKINDEX_t task, TObject * data)
                        MakeRaws(rawReader) ;
                else
       AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;     
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ; 
+               TTree * tree = dynamic_cast<TTree *>(data) ; 
+               if (tree) {
+                       MakeDigits(tree) ; 
+               } else {
+                       AliWarning("data are not a TTree") ; 
+               }
        } else if ( task == AliQAv1::kRECPOINTS ) {
                AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ; 
                TTree * tree = dynamic_cast<TTree *>(data) ; 
@@ -315,6 +340,16 @@ TObjArray **  AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, Int_t cycles)
                        InitRaws() ;
                }
                rv = fRawsQAList ;
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               if ( ! fDigitsQAList ) {
+      fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
+      for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+        fDigitsQAList[specie] = new TObjArray(100) ; 
+        fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ; 
+      }
+      InitDigits() ;
+               }
+               rv = fDigitsQAList ;
        } else if ( task == AliQAv1::kRECPOINTS ) {
                if ( ! fRecPointsQAList ) {
       fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ; 
@@ -351,6 +386,8 @@ void AliQADataMakerRec::Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t
        
        if ( task == AliQAv1::kRAWS ) {
                fRawsQAList = list ;     
+       } else if ( task == AliQAv1::kDIGITSR ) {
+               fDigitsQAList = list ; 
        } else if ( task == AliQAv1::kRECPOINTS ) {
                fRecPointsQAList = list ; 
        } else if ( task == AliQAv1::kESDS ) {
@@ -401,6 +438,7 @@ void AliQADataMakerRec::StartOfCycle(Int_t run)
   Bool_t samecycle = kFALSE ; 
   StartOfCycle(AliQAv1::kRAWS,      run, samecycle) ;
   samecycle = kTRUE ; 
+  StartOfCycle(AliQAv1::kDIGITSR,   run, samecycle) ; 
   StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ; 
   StartOfCycle(AliQAv1::kESDS,      run, samecycle) ; 
 }
index 403132a..a464e54 100644 (file)
@@ -31,10 +31,14 @@ public:
        AliQADataMakerRec& operator = (const AliQADataMakerRec& qadm) ;
        virtual ~AliQADataMakerRec() ; // dtor
   
-       virtual Int_t Add2DigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)    { return -1 ; } 
-       virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)  { return Add2List(hist, index, fESDsQAList, expert, image) ; }
-       virtual Int_t Add2HitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)       { return -1 ; }  
-       virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)  { return Add2List(hist, index, fRecPointsQAList, expert, image) ; }
+       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)    
+    { return Add2List(hist, index, fDigitsQAList, expert, image) ; }
+       virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)                      
+    { return Add2List(hist, index, fESDsQAList, expert, image) ; }
+       virtual Int_t Add2HitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)      
+    { return -1 ; }  
+       virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)                 
+    { return Add2List(hist, index, fRecPointsQAList, expert, image) ; }
        virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE)  { 
     return Add2List(hist, index, fRawsQAList, expert, image, saveForCorr) ; }
        virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)   { return -1 ; } 
@@ -42,7 +46,7 @@ public:
        virtual void        EndOfCycle() ;
        virtual void        EndOfCycle(AliQAv1::TASKINDEX_t task) ;
        virtual void        EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");} 
-       virtual TH1 *       GetDigitsData(const Int_t /*index*/) { return NULL ; } 
+       virtual TH1 *       GetDigitsData(const Int_t index   )  { return dynamic_cast<TH1 *>(GetData(fDigitsQAList, index)) ; } 
        virtual TH1 *       GetESDsData(const Int_t index)       { return dynamic_cast<TH1 *>(GetData(fESDsQAList, index)) ; }
        virtual TH1 *       GetHitsData(const Int_t /*index*/)   { return NULL ; }
   virtual const AliDetectorRecoParam * GetRecoParam() { return fRecoParam ; }
@@ -59,7 +63,7 @@ public:
 
 protected: 
 
-       virtual void   InitDigits()                        {AliWarning("Call not valid") ; }
+       virtual void   InitDigits()                        {AliInfo("To be implemented by detectors");}
        virtual void   InitESDs()                          {AliInfo("To be implemented by detectors");}
   virtual void   InitRecoParams() ; 
        virtual void   InitHits()                          {AliWarning("Call not valid") ; }
@@ -71,8 +75,8 @@ protected:
        virtual void   MakeESDs(AliESDEvent * )            {AliInfo("To be implemented by detectors");} 
        virtual void   MakeHits(TClonesArray * )           {AliWarning("Call not valid") ; }
        virtual void   MakeHits(TTree * )                  {AliWarning("Call not valid") ; }  
-       virtual void   MakeDigits(TClonesArray * )         {AliWarning("Call not valid") ; }    
-       virtual void   MakeDigits(TTree * )                {AliWarning("Call not valid") ; }   
+       virtual void   MakeDigits(TClonesArray * )         {AliInfo("To be implemented by detectors");}   
+       virtual void   MakeDigits(TTree * )                {AliInfo("To be implemented by detectors");}   
        //virtual void   MakeRecParticles(TClonesArray * ) {AliInfo("To be implemented by detectors");} 
        virtual void   MakeRaws(AliRawReader *)            {AliInfo("To be implemented by detectors");} 
        virtual void   MakeRecPoints(TTree * )             {AliInfo("To be implemented by detectors");} 
@@ -80,13 +84,14 @@ protected:
        virtual void   MakeSDigits(TTree * )               {AliWarning("Call not valid") ; }    
        virtual void   StartOfDetectorCycle()              {AliInfo("To be implemented by detectors");} 
 
+       TObjArray * *               fDigitsQAList ;    //! list of the digits QA data objects
        TObjArray * *               fESDsQAList ;      //! list of the ESDs QA data objects
        TObjArray * *               fRawsQAList ;      //! list of the raws QA data objects
        TObjArray * *               fRecPointsQAList ; //! list of the RecPoints QA data objects
   TNtupleD  * *               fCorrNt ;          //! This is used by Corr only to hold its Ntuple. 
   const AliDetectorRecoParam *fRecoParam;        //! const pointer to the reco parameters to be used in the reco QA
   
- ClassDef(AliQADataMakerRec,2)  // description 
+ ClassDef(AliQADataMakerRec,3)  // description 
 
 };
 
index 01c7a96..b0dcbbe 100644 (file)
@@ -219,6 +219,8 @@ void AliQADataMakerSim::MakeImage(AliQAv1::TASKINDEX_t task)
     case AliQAv1::kDIGITS:
       list = fDigitsQAList ;
       break;  
+    case AliQAv1::kDIGITSR:
+      break;
     case AliQAv1::kRECPOINTS:
       break;
     case AliQAv1::kTRACKSEGMENTS:
index 3b7a0a2..130628f 100644 (file)
@@ -28,12 +28,18 @@ public:
        AliQADataMakerSim& operator = (const AliQADataMakerSim& qadm) ;
        virtual ~AliQADataMakerSim() ; // dtor
   
-       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)    { return Add2List(hist, index, fDigitsQAList, expert, image) ; }
-       virtual Int_t Add2ESDsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)      { return -1 ; } 
-       virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)      { return Add2List(hist, index, fHitsQAList, expert, image) ; }
-       virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/) { return -1 ; } 
-       virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*saveForCorr = kFALSE*/, const Bool_t /*image = kFALSE*/)      { return -1 ; }  
-       virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)   { return Add2List(hist, index, fSDigitsQAList, expert, image) ; }
+       virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)                    
+    { return Add2List(hist, index, fDigitsQAList, expert, image) ; }
+       virtual Int_t Add2ESDsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/)    
+    { return -1 ; } 
+       virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)                      
+    { return Add2List(hist, index, fHitsQAList, expert, image) ; }
+       virtual Int_t Add2RecPointsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/) 
+    { return -1 ; } 
+       virtual Int_t Add2RawsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*saveForCorr = kFALSE*/, const Bool_t /*image = kFALSE*/)      
+    { return -1 ; }  
+       virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE)   
+    { return Add2List(hist, index, fSDigitsQAList, expert, image) ; }
        virtual void        Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
        virtual void        EndOfCycle() ;
        virtual void        EndOfCycle(AliQAv1::TASKINDEX_t task) ;
index 60902ea..ec9786b 100644 (file)
@@ -1212,6 +1212,8 @@ void AliQAManager::RunOneEvent(AliESDEvent *& esd)
 void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree) 
 {
        // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
+  
+  TString test(tree->GetName()) ; 
        AliCodeTimerAuto("") ;
   if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
     if (IsSelected(AliQAv1::GetDetName(det))) {
@@ -1225,8 +1227,13 @@ void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
           qadm->EndOfCycle() ;
         }
         AliCodeTimerStart(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
-        qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
-        AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
+        if (test.Contains("TreeD")) {
+          qadm->Exec(AliQAv1::kDIGITSR, tree) ;
+          AliCodeTimerStop(Form("running Digits quality assurance data maker for %s", AliQAv1::GetDetName(det)));
+        } else  if (test.Contains("TreeR")) {
+          qadm->Exec(AliQAv1::kRECPOINTS, tree) ;
+          AliCodeTimerStop(Form("running RecPoints quality assurance data maker for %s", AliQAv1::GetDetName(det)));
+        }
       }
     }
   }
index 3f7aeb8..1ae28d3 100644 (file)
@@ -59,7 +59,7 @@ TString    AliQAv1::fgQAResultFileName     = "QA.root" ;
 TString    AliQAv1::fgDetNames[]           = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD",
                                             "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT", "Global", "CORR"} ;   
 TString    AliQAv1::fgGRPPath              = "GRP/GRP/Data" ; 
-TString       AliQAv1::fgTaskNames[]       = {"Raws", "Hits", "SDigits", "Digits", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
+TString       AliQAv1::fgTaskNames[]       = {"Raws", "Hits", "SDigits", "Digits", "DigitsR", "RecPoints", "TrackSegments", "RecParticles", "ESDs"} ;   
 const TString AliQAv1::fgkLabLocalFile     = "file://"  ; 
 const TString AliQAv1::fgkLabLocalOCDB     = "local://" ;  
 const TString AliQAv1::fgkLabAliEnOCDB     = "alien://" ;  
index c8fca2c..3554276 100644 (file)
@@ -27,7 +27,7 @@ public:
   enum QABIT_t {
     kNULLBit=-1, kINFO, kWARNING, kERROR, kFATAL, kNBIT };
   enum TASKINDEX_t {
-    kNULLTASKINDEX=-1, kRAWS, kHITS, kSDIGITS, kDIGITS, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
+    kNULLTASKINDEX=-1, kRAWS, kHITS, kSDIGITS, kDIGITS, kDIGITSR, kRECPOINTS, kTRACKSEGMENTS, kRECPARTICLES, kESDS, kNTASKINDEX };
   
   // Creators - destructors
   AliQAv1(); // beware singleton, not to be used
index c484a65..3c35dfb 100644 (file)
@@ -1970,10 +1970,10 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
     // although the HLT loader is missing
     if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
       if (fRawReader) {
-       reconstructor->Reconstruct(fRawReader, NULL);
+        reconstructor->Reconstruct(fRawReader, NULL);
       } else {
-       TTree* dummy=NULL;
-       reconstructor->Reconstruct(dummy, NULL);
+        TTree* dummy=NULL;
+        reconstructor->Reconstruct(dummy, NULL);
       }
       continue;
     }
@@ -2008,10 +2008,14 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
       loader->LoadDigits("read");
       TTree* digitsTree = loader->TreeD();
       if (!digitsTree) {
-       AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
-       if (fStopOnError) return kFALSE;
+        AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
+        if (fStopOnError) return kFALSE;
       } else {
-       reconstructor->Reconstruct(digitsTree, clustersTree);
+        reconstructor->Reconstruct(digitsTree, clustersTree);
+        if (fRunQA) {
+          fQAManager->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+          fQAManager->RunOneEventInOneDetector(iDet, digitsTree) ; 
+        }
       }
       loader->UnloadDigits();
     }
@@ -3045,7 +3049,7 @@ void AliReconstruction::RunAliEVE()
 Bool_t AliReconstruction::SetRunQA(TString detAndAction) 
 {
        // Allows to run QA for a selected set of detectors
-       // and a selected set of tasks among RAWS, RECPOINTS and ESDS
+       // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
        // all selected detectors run the same selected tasks
        
        if (!detAndAction.Contains(":")) {
@@ -3059,12 +3063,14 @@ Bool_t AliReconstruction::SetRunQA(TString detAndAction)
                fQADetectors = fFillESD ; 
                fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
        if (fQATasks.Contains("ALL") ) {
-               fQATasks = Form("%d %d %d", AliQAv1::kRAWS, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ; 
+               fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ; 
        } else {
                fQATasks.ToUpper() ; 
                TString tempo("") ; 
                if ( fQATasks.Contains("RAW") ) 
                        tempo = Form("%d ", AliQAv1::kRAWS) ; 
+               if ( fQATasks.Contains("DIGIT") ) 
+                       tempo += Form("%d ", AliQAv1::kDIGITSR) ; 
                if ( fQATasks.Contains("RECPOINT") ) 
                        tempo += Form("%d ", AliQAv1::kRECPOINTS) ; 
                if ( fQATasks.Contains("ESD") ) 
@@ -3078,6 +3084,7 @@ Bool_t AliReconstruction::SetRunQA(TString detAndAction)
        }       
        TString tempo(fQATasks) ; 
        tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS))      ;
+       tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;      
        tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;  
        tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;    
        AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;  
index ca435f4..e2a317a 100644 (file)
@@ -35,6 +35,7 @@
 #include "AliT0digit.h" 
 #include "AliT0hit.h"
 #include "AliT0RecPoint.h"
+#include "AliT0Digit.h"
 #include "AliT0QADataMakerRec.h"
 #include "AliQAChecker.h"
 #include "AliT0RawReader.h"
@@ -236,6 +237,24 @@ void AliT0QADataMakerRec::InitRaws()
 }
 
 //____________________________________________________________________________ 
+void AliT0QADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH2F * fhDigCFD = new TH2F("fhDigCFD", " CFD digits",25,-0.5,24.5,100,100,1000);
+  Add2DigitsList( fhDigCFD,0);
+  TH2F *fhDigLEDamp = new TH2F("fhDigLEDamp", " LED-CFD digits",25,-0.5,24.5,100,100,1000);
+  Add2DigitsList( fhDigLEDamp,1, !expert, image);
+  TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits",25,-0.5,24.5,100,100,1000);
+  Add2DigitsList( fhDigQTC,2, !expert, image);
+  
+  
+  
+}
+
+//____________________________________________________________________________ 
 
 void AliT0QADataMakerRec::InitRecPoints()
 {
@@ -403,6 +422,50 @@ void AliT0QADataMakerRec::MakeRaws( AliRawReader* rawReader)
 
 
 //____________________________________________________________________________
+void AliT0QADataMakerRec::MakeDigits( TTree *digitsTree)
+{
+  //fills QA histos for Digits
+  
+  TArrayI *digCFD = new TArrayI(24);
+  TArrayI *digLED = new TArrayI(24);
+  TArrayI *digQT0 = new TArrayI(24);
+  TArrayI *digQT1 = new TArrayI(24);
+  Int_t refpoint=0;
+  
+  TBranch *brDigits=digitsTree->GetBranch("T0");
+  AliT0digit *fDigits = new AliT0digit() ;
+  if (brDigits) {
+    brDigits->SetAddress(&fDigits);
+  }else{
+    AliError(Form("EXEC Branch T0 digits not found"));
+    return;
+  }
+  digitsTree->GetEvent(0);
+  digitsTree->GetEntry(0);
+  brDigits->GetEntry(0);
+  fDigits->GetTimeCFD(*digCFD);
+  fDigits->GetTimeLED(*digLED);
+  fDigits->GetQT0(*digQT0);
+  fDigits->GetQT1(*digQT1);
+  refpoint = fDigits->RefPoint();
+  for (Int_t i=0; i<24; i++)
+    {
+    if (digCFD->At(i)>0) {
+      Int_t cfd=digCFD->At(i)- refpoint;
+      GetDigitsData(0) ->Fill(i,cfd);
+      GetDigitsData(1) -> Fill(i,(digLED->At(i) - digCFD->At(i)));
+      GetDigitsData(2) -> Fill(i, (digQT1->At(i) - digQT0->At(i)));
+    }
+    }  
+  
+  delete digCFD;
+  delete digLED;
+  delete digQT0;
+  delete digQT1;
+  
+}
+
+//____________________________________________________________________________
 void AliT0QADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
   //fills QA histos for clusters
index 32b735d..1085ca2 100644 (file)
@@ -33,9 +33,12 @@ public:
 private:
   virtual void   InitRaws() ;    //book Digit QA histo
   virtual void   InitRecPoints();  //book cluster QA histo
+  virtual void   InitDigits() ; 
   virtual void   InitESDs() ;      //book ESD QA histo 
   virtual void   MakeRaws(AliRawReader* rawReader) ;
   virtual void   MakeRecPoints(TTree * clusters)    ;  //Fill cluster QA histo
+  virtual void   MakeDigits(TClonesArray * /*digits*/) {;} 
+  virtual void   MakeDigits(TTree * digTree);
   virtual void   MakeESDs(AliESDEvent * esd) ;         //Fill hit QA histo
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   StartOfDetectorCycle() ;
index 573db59..10bf16b 100644 (file)
@@ -38,6 +38,7 @@
 #include "AliTOFRawStream.h"
 #include "AliTOFrawData.h"
 #include "AliTOFGeometry.h"
+#include "AliTOFDigit.h"
 
 ClassImp(AliTOFQADataMakerRec)
            
@@ -109,6 +110,40 @@ void AliTOFQADataMakerRec::InitRaws()
 }
 
 //____________________________________________________________________________ 
+void AliTOFQADataMakerRec::InitDigits()
+{
+  //
+  // create Digits histograms in Digits subdir
+  //
+  
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  TH1F * h0 = new TH1F("hTOFDigits",    "Number of TOF Digits ",301, -1.02, 5.) ;
+  h0->Sumw2() ;
+  h0->GetXaxis()->SetTitle("TOF digit number [10 power]");
+  Add2DigitsList(h0, 0, !expert, image) ;
+  
+  TH1F * h1  = new TH1F("hTOFDigitsTime", "Digits Time Spectrum in TOF (ns)", 2000, 0., 200) ; 
+  h1->Sumw2() ;
+  h1->GetXaxis()->SetTitle("Digitized TOF time [ns]");
+  Add2DigitsList(h1, 1, !expert, image) ;
+  
+  TH1F * h2  = new TH1F("hTOFDigitsToT", "Digits ToT Spectrum in TOF (ns)", 500, 0., 50) ; 
+  h2->Sumw2() ;
+  h2->GetYaxis()->SetTitle("Digitized TOF time [ns]");
+  Add2DigitsList(h2, 2, !expert, image) ;
+  
+  TH2F * h3  = new TH2F("hTOFDigitsClusMap","Digits vs TOF eta-phi",183, -0.5, 182.5,865,-0.5,864.5) ; 
+  h3->Sumw2() ;
+  h3->GetXaxis()->SetTitle("2*strip+padz (eta)");
+  h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
+  h3->GetYaxis()->SetTitleOffset(1.15);
+  Add2DigitsList(h3, 3, !expert, image) ;
+  
+}
+
+//____________________________________________________________________________ 
 void AliTOFQADataMakerRec::InitRecPoints()
 {
   //
@@ -236,6 +271,60 @@ void AliTOFQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________
+void AliTOFQADataMakerRec::MakeDigits(TClonesArray * digits)
+{
+  //
+  // makes data from Digits
+  //
+  Double_t tdc2ns=AliTOFGeometry::TdcBinWidth()*1E-3;
+  Double_t tot2ns=AliTOFGeometry::ToTBinWidth()*1E-3;
+  Int_t in[5];
+  Int_t out[5];
+  
+  Int_t nentries=digits->GetEntriesFast();
+  if(nentries<=0){
+    GetDigitsData(0)->Fill(-1.) ; 
+  }else{
+    GetDigitsData(0)->Fill(TMath::Log10(nentries)) ; 
+  } 
+  
+  TIter next(digits) ; 
+  AliTOFdigit * digit ; 
+  while ( (digit = dynamic_cast<AliTOFdigit *>(next())) ) {
+    
+    GetDigitsData(1)->Fill( digit->GetTdc()*tdc2ns) ;//in ns
+    GetDigitsData(2)->Fill( digit->GetToT()*tot2ns) ;//in ns
+      
+      in[0] = digit->GetSector();
+      in[1] = digit->GetPlate();
+      in[2] = digit->GetStrip();
+      in[3] = digit->GetPadx();
+      in[4]= digit->GetPadz();
+      GetMapIndeces(in,out);
+      GetDigitsData(3)->Fill( out[0],out[1]) ;//digit map
+  }
+  
+}
+
+//____________________________________________________________________________
+void AliTOFQADataMakerRec::MakeDigits(TTree * digitTree)
+{
+  //
+  // makes data from Digit Tree
+  //
+  TClonesArray * digits = new TClonesArray("AliTOFdigit", 1000) ; 
+  
+  TBranch * branch = digitTree->GetBranch("TOF") ;
+  if ( ! branch ) {
+    AliError("TOF branch in Digit Tree not found") ; 
+    return;
+  }
+  branch->SetAddress(&digits) ;
+  branch->GetEntry(0) ; 
+  MakeDigits(digits) ; 
+}
+
+//____________________________________________________________________________
 void AliTOFQADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
   //
index 21f050e..d67e82e 100644 (file)
@@ -24,9 +24,12 @@ public:
 private:
   virtual void   InitESDs() ; 
   virtual void   InitRecPoints() ; 
+  virtual void   InitDigits() ; 
   virtual void   InitRaws() ; 
   virtual void   MakeESDs(AliESDEvent * esd) ;
   virtual void   MakeRecPoints(TTree * recTree) ; 
+  virtual void   MakeDigits(TTree * recTree) ; 
+  virtual void   MakeDigits(TClonesArray * digits) ;
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   StartOfDetectorCycle() ; 
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
index c2f295d..c23a9ad 100644 (file)
@@ -63,6 +63,7 @@
 #include "AliTPCCalROC.h"
 #include "AliTPCClustersRow.h"
 #include "AliTPCclusterMI.h"
+#include "AliSimDigits.h"
 
 ClassImp(AliTPCQADataMakerRec)
 
@@ -312,6 +313,18 @@ void AliTPCQADataMakerRec::InitRaws()
 }
 
 //____________________________________________________________________________ 
+void AliTPCQADataMakerRec::InitDigits()
+{
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  TH1F * histDigitsADC = 
+    new TH1F("hDigitsADC", "Digit ADC distribution; ADC; Counts",
+             1000, 0, 1000);
+  histDigitsADC->Sumw2();
+  Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
+}
+
+//____________________________________________________________________________ 
 void AliTPCQADataMakerRec::InitRecPoints()
 {
   const Bool_t expert   = kTRUE ; 
@@ -397,6 +410,28 @@ void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
  }
 
 //____________________________________________________________________________
+void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
+{
+  TBranch* branch = digitTree->GetBranch("Segment");
+  AliSimDigits* digArray = 0;
+  branch->SetAddress(&digArray);
+  
+  Int_t nEntries = Int_t(digitTree->GetEntries());
+  
+  for (Int_t n = 0; n < nEntries; n++) {
+    
+    digitTree->GetEvent(n);
+    
+    if (digArray->First())
+      do {
+        Float_t dig = digArray->CurrentDigit();
+        
+        GetDigitsData(kDigitsADC)->Fill(dig);
+      } while (digArray->Next());    
+  }
+}
+
+//____________________________________________________________________________
 void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
 {
   AliTPCClustersRow *clrow = new AliTPCClustersRow();
index 5af6c62..07f1393 100644 (file)
@@ -30,6 +30,7 @@ class AliTPCQADataMakerRec: public AliQADataMakerRec {
 
 public:
   enum HRawsType_t         {kTPCdataQA=0, kOccupancy, kOccupancyVsSector, kNClustersPerEventVsSector, kQVsSector, kQmaxVsSector} ; 
+  enum HDigitType_t        {kDigitsADC=0} ; 
   enum HRECPOINTsType_t    {KClusters=0, kRatio, kPt} ; 
   enum HESDsType_t         {kQmaxShort=0, kQmaxMedium, kQmaxLong, kQShort, kQMedium, kQLong, kRow} ; 
 
@@ -50,10 +51,15 @@ private:
   virtual void   InitRaws();
   virtual void   MakeRaws(AliRawReader* rawReader);
 
+  // Digits QA
+  virtual void   InitDigits();
+  virtual void   MakeDigits(TClonesArray* /*digits*/)  {return;}
+  virtual void   MakeDigits(TTree *digTree);
+  
   // RecPoints QA
   virtual void   InitRecPoints();
   virtual void   MakeRecPoints(TTree *recTree);
-
+  
   virtual void LoadMaps();
 
   
index 0e86711..a47cd42 100644 (file)
@@ -44,7 +44,9 @@
 #include "AliTRDgeometry.h"
 //#include "AliTRDdataArrayI.h"
 #include "AliTRDrawStream.h"
-
+#include "AliTRDdigitsManager.h"
+#include "AliTRDdigit.h"
+#include "AliTRDarrayADC.h"
 #include "AliQAChecker.h"
 
 ClassImp(AliTRDQADataMakerRec)
@@ -329,6 +331,29 @@ void AliTRDQADataMakerRec::InitESDs()
 }
 
 //____________________________________________________________________________ 
+void AliTRDQADataMakerRec::InitDigits()
+{
+  //
+  // Create Digits histograms in Digits subdir
+  //
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  const Int_t kNhist = 3;
+  TH1D *hist[kNhist];
+  
+  hist[0] = new TH1D("qaTRD_digits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
+  hist[1] = new TH1D("qaTRD_digits_time", ";Time bin", 40, -0.5, 39.5);
+  hist[2] = new TH1D("qaTRD_digits_amp", ";Amplitude", 100, -5.5, 94.5);
+  
+  for(Int_t i=0; i<kNhist; i++) {
+    hist[i]->Sumw2();
+    Add2DigitsList(hist[i], i, !expert, image);
+  }
+  
+}
+
+//____________________________________________________________________________ 
 void AliTRDQADataMakerRec::InitRecPoints()
 {
   //
@@ -686,6 +711,76 @@ void AliTRDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
 }
 
 //____________________________________________________________________________
+void AliTRDQADataMakerRec::MakeDigits(TClonesArray * digits)
+{
+  //
+  // Makes data from Digits
+  //
+  
+  TIter next(digits) ; 
+  AliTRDdigit * digit ; 
+  
+  // Info("Make digits", "From the arrya");
+  
+  while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
+    if (digit->GetAmp() < 1) continue;
+    GetDigitsData(0)->Fill(digit->GetDetector());
+    GetDigitsData(1)->Fill(digit->GetTime());
+    GetDigitsData(2)->Fill(digit->GetAmp());
+  }
+  
+}
+
+//____________________________________________________________________________
+void AliTRDQADataMakerRec::MakeDigits(TTree * digits)
+{
+  //
+  // Makes data from digits tree
+  //
+  
+  // Info("Make digits", "From a tree");
+  
+  AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
+  digitsManager->CreateArrays();
+  digitsManager->ReadDigits(digits);
+  
+  TH1D *histDet = (TH1D*)GetDigitsData(0);
+  TH1D *histTime = (TH1D*)GetDigitsData(1);
+  TH1D *histSignal = (TH1D*)GetDigitsData(2);
+  
+  for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++) 
+    {
+    AliTRDarrayADC *digitsIn = (AliTRDarrayADC *) digitsManager->GetDigits(i);      
+    
+    // This is to take care of switched off super modules
+    if (digitsIn->GetNtime() == 0) continue;
+    
+    digitsIn->Expand();
+    
+    //AliTRDSignalIndex* indexes = digitsManager->GetIndexes(i);
+    //if (indexes->IsAllocated() == kFALSE) digitsManager->BuildIndexes(i);
+    
+    Int_t nRows = digitsIn->GetNrow();
+    Int_t nCols = digitsIn->GetNcol();
+    Int_t nTbins = digitsIn->GetNtime();
+    
+    for(Int_t row = 0; row < nRows; row++) 
+      for(Int_t col = 0; col < nCols; col++) 
+        for(Int_t time = 0; time < nTbins; time++) 
+          {   
+          Float_t signal = digitsIn->GetData(row,col,time);
+          if (signal < 1) continue;
+          histDet->Fill(i);
+          histTime->Fill(time);
+          histSignal->Fill(signal);
+          }
+          
+          //delete digitsIn;
+    }
+    delete digitsManager;
+}
+
+//____________________________________________________________________________
 void AliTRDQADataMakerRec::MakeRecPoints(TTree * clustersTree)
 {
   //  
index 330717b..61dac7f 100644 (file)
@@ -37,10 +37,13 @@ class AliTRDQADataMakerRec: public AliQADataMakerRec {
 
   virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
   virtual void InitESDs() ; 
+  virtual void InitDigits() ; 
   virtual void InitRecPoints() ; 
   virtual void InitRaws() ; 
 
   virtual void MakeRaws(AliRawReader* rawReader); 
+  virtual void MakeDigits(TTree * dig); 
+  virtual void MakeDigits(TClonesArray * digits); 
   virtual void MakeRecPoints(TTree * recpo); 
   virtual void MakeESDs(AliESDEvent * esd);
 
index fe8e485..955b075 100644 (file)
@@ -41,6 +41,7 @@
 #include "AliQAChecker.h"
 #include "AliRawReader.h"
 #include "AliVZERORawStream.h"
+#include "AliVZERODigit.h"
 #include "AliVZEROReconstructor.h"
 #include "event.h"
 
@@ -428,6 +429,73 @@ void AliVZEROQADataMakerRec::InitESDs()
        AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto));
  }
 
+//____________________________________________________________________________ 
+void AliVZEROQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  char TDCname[100];
+  char ADCname[100];
+  TH1I *fhDigTDC[64]; 
+  TH1I *fhDigADC[64]; 
+  char texte[100];
+  
+  // create Digits histograms in Digits subdir
+  TH1I * h0 = new TH1I("hDigitMultiplicity", "Digits multiplicity distribution in VZERO", 100, 0, 99) ; 
+  h0->Sumw2() ;
+  Add2DigitsList(h0, 0, !expert, image) ;
+  
+  for (Int_t i=0; i<64; i++)
+    {
+    sprintf(TDCname, "hDigitTDC%d", i);
+    sprintf(texte,"Digit TDC in cell %d",i);    
+    fhDigTDC[i] = new TH1I(TDCname,texte,300,0.,149.);
+    
+    sprintf(ADCname,"hDigitADC%d",i);
+    sprintf(texte,"Digit ADC in cell %d",i);
+    fhDigADC[i]= new TH1I(ADCname,texte,1024,0.,1023.);
+    
+    Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
+    Add2DigitsList(fhDigADC[i],i+1+64, !expert, image);  
+    }  
+}
+
+//____________________________________________________________________________
+void AliVZEROQADataMakerRec::MakeDigits(TClonesArray * digits)
+{
+  // makes data from Digits
+  
+  GetDigitsData(0)->Fill(digits->GetEntriesFast()) ; 
+  TIter next(digits) ; 
+  AliVZEROdigit *VZERODigit ; 
+  while ( (VZERODigit = dynamic_cast<AliVZEROdigit *>(next())) ) {
+    Int_t   PMNumber  = VZERODigit->PMNumber();         
+    GetDigitsData(PMNumber +1)->Fill( VZERODigit->Time()) ;    // in 100 of picoseconds
+    GetDigitsData(PMNumber +1+64)->Fill( VZERODigit->ADC()) ;
+  }  
+}
+
+
+//____________________________________________________________________________
+void AliVZEROQADataMakerRec::MakeDigits(TTree *digitTree)
+{
+  // makes data from Digit Tree
+       
+  TClonesArray * digits = new TClonesArray("AliVZEROdigit", 1000) ; 
+  
+  TBranch * branch = digitTree->GetBranch("VZERODigit") ;
+  if ( ! branch ) {
+    AliWarning("VZERO branch in Digit Tree not found") ; 
+  } else {
+    branch->SetAddress(&digits) ;
+    branch->GetEntry(0) ; 
+    MakeDigits(digits) ; 
+  }  
+}
+
+
 //____________________________________________________________________________
 void AliVZEROQADataMakerRec::MakeESDs(AliESDEvent * esd)
 {
index 76ff6ee..7054750 100644 (file)
@@ -55,8 +55,11 @@ private:
   virtual void   EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
   virtual void   InitESDs() ; 
   virtual void   InitRaws() ; 
+  virtual void   InitDigits();  
   virtual void   MakeESDs(AliESDEvent * esd) ;
-  virtual void   MakeRaws(AliRawReader* rawReader) ; 
+  virtual void   MakeRaws(AliRawReader* rawReader) ;
+  virtual void   MakeDigits(TClonesArray* digits) ; 
+  virtual void   MakeDigits(TTree* digitTree) ; 
   virtual void   StartOfDetectorCycle() ; 
 
   Int_t   fEvent;
index 48e5d31..1ee14c9 100644 (file)
@@ -36,6 +36,7 @@
 #include "AliRawReader.h"
 #include "AliZDCQADataMakerRec.h"
 #include "AliZDCRawStream.h"
+#include "AliZDCDigit.h"
 #include "AliESDZDC.h"
 #include "AliESDEvent.h"
 
@@ -129,6 +130,72 @@ void AliZDCQADataMakerRec::InitRaws()
   Add2RawsList(hRawPMCZPAlg, 23, kTRUE);*/
 }
 
+//____________________________________________________________________________ 
+void AliZDCQADataMakerRec::InitDigits()
+{
+  // create Digits histograms in Digits subdir
+  //
+  const Bool_t expert   = kTRUE ; 
+  const Bool_t image    = kTRUE ; 
+  
+  // ------------------- HIGH GAIN CHAIN ---------------------------
+  TH1F * hDigZNCTot = new TH1F("hDigZNCTot", "Signal in ZNC", 100, 0., 6000.);
+  TH1F * hDigZNATot = new TH1F("hDigZNATot", "Signal in ZNA", 100, 0., 6000.);
+  TH1F * hDigZPCTot = new TH1F("hDigZPCTot", "Signal in ZPC", 100, 0., 6000.);
+  TH1F * hDigZPATot = new TH1F("hDigZPATot", "Signal in ZPA", 100, 0., 6000.);
+  Add2DigitsList(hDigZNCTot, 0, !expert, image);
+  Add2DigitsList(hDigZNATot, 1, !expert, image);
+  Add2DigitsList(hDigZPCTot, 2, !expert, image);
+  Add2DigitsList(hDigZPATot, 3, !expert, image);
+  //
+  TH1F * hDigSumQZNC = new TH1F("hDigSumQZNC", "Signal in 4 ZNC PMQ",100, 0., 4000.);
+  TH1F * hDigSumQZNA = new TH1F("hDigSumQZNA", "Signal in 4 ZNA PMQ",100, 0., 4000.);
+  TH1F * hDigSumQZPC = new TH1F("hDigSumQZPC", "Signal in 4 ZPC PMQ",100, 0., 4000.);
+  TH1F * hDigSumQZPA = new TH1F("hDigSumQZPA", "Signal in 4 ZPA PMQ",100, 0., 4000.);
+  Add2DigitsList(hDigSumQZNC, 4, expert, !image);
+  Add2DigitsList(hDigSumQZNA, 5, expert, !image);
+  Add2DigitsList(hDigSumQZPC, 6, expert, !image);
+  Add2DigitsList(hDigSumQZPA, 7, expert, !image);
+  //
+  TH1F * hDigPMCZNC = new TH1F("hDigPMCZNC", "Signal in ZNC PMC",100, 0., 4000.);
+  TH1F * hDigPMCZNA = new TH1F("hDigPMCZNA", "Signal in ZNA PMC",100, 0., 4000.);
+  TH1F * hDigPMCZPC = new TH1F("hDigPMCZPC", "Signal in ZPC PMC",100, 0., 4000.);
+  TH1F * hDigPMCZPA = new TH1F("hDigPMCZPA", "Signal in ZPA PMC",100, 0., 4000.);
+  Add2DigitsList(hDigPMCZNC, 8, expert, !image);
+  Add2DigitsList(hDigPMCZNA, 9, expert, !image);
+  Add2DigitsList(hDigPMCZPC, 10, expert, !image);
+  Add2DigitsList(hDigPMCZPA, 11, expert, !image);
+  // 
+  // ------------------- LOW GAIN CHAIN ---------------------------
+  /*  TH1F * hDigZNCTotlg = new TH1F("hDigZNCTotlg", "Digit lg signal in ZNC", 100, 0., 6000.);
+  TH1F * hDigZNATotlg = new TH1F("hDigZNATotlg", "Digit lg signal in ZNA", 100, 0., 6000.);
+  TH1F * hDigZPCTotlg = new TH1F("hDigZPCTotlg", "Digit lg signal in ZPC", 100, 0., 6000.);
+  TH1F * hDigZPATotlg = new TH1F("hDigZPATotlg", "Digit lg signal in ZPA", 100, 0., 6000.);
+  Add2DigitsList(hDigZNCTotlg, 12, !expert, image);
+  Add2DigitsList(hDigZNATotlg, 13, !expert, image);
+  Add2DigitsList(hDigZPCTotlg, 14, !expert, image);
+  Add2DigitsList(hDigZPATotlg, 15, !expert, image);
+  //
+  TH1F * hDigSumQZNClg = new TH1F("hDigSumQZNClg", "Signal in 4 ZNC PMQlg",100, 0., 4000.);
+  TH1F * hDigSumQZNAlg = new TH1F("hDigSumQZNAlg", "Signal in 4 ZNA PMQlg",100, 0., 4000.);
+  TH1F * hDigSumQZPClg = new TH1F("hDigSumQZPClg", "Signal in 4 ZPC PMQlg",100, 0., 4000.);
+  TH1F * hDigSumQZPAlg = new TH1F("hDigSumQZPAlg", "Signal in 4 ZPA PMQlg",100, 0., 4000.);
+  Add2DigitsList(hDigSumQZNClg, 16, expert, !image);
+  Add2DigitsList(hDigSumQZNAlg, 17, expert, !image);
+  Add2DigitsList(hDigSumQZPClg, 18, expert, !image);
+  Add2DigitsList(hDigSumQZPAlg, 19, expert, !image);
+  //
+  TH1F * hDigPMCZNClg = new TH1F("hDigPMCZNClg", "Signal in ZNC PMClg",100, 0., 4000.);
+  TH1F * hDigPMCZNAlg = new TH1F("hDigPMCZNAlg", "Signal in ZNA PMClg",100, 0., 4000.);
+  TH1F * hDigPMCZPClg = new TH1F("hDigPMCZPClg", "Signal in ZPC PMClg",100, 0., 4000.);
+  TH1F * hDigPMCZPAlg = new TH1F("hDigPMCZPAlg", "Signal in ZPA PMClg",100, 0., 4000.);
+  Add2DigitsList(hDigPMCZNClg, 20, expert, !image);
+  Add2DigitsList(hDigPMCZNAlg, 21, expert, !image);
+  Add2DigitsList(hDigPMCZPClg, 22, expert, !image);
+  Add2DigitsList(hDigPMCZPAlg, 23, expert, !image);
+  */
+}
+
 //____________________________________________________________________________
 void AliZDCQADataMakerRec::InitESDs()
 {
@@ -289,6 +356,109 @@ void AliZDCQADataMakerRec::MakeRaws(AliRawReader *rawReader)
   stream.Delete();
 }
 
+//___________________________________________________________________________
+void AliZDCQADataMakerRec::MakeDigits(TTree *digitTree )
+{
+  // makes data from Digit Tree
+  TBranch * branch = digitTree->GetBranch("ZDC");
+  if(!branch){
+    AliError("ZDC branch in Digit Tree not found"); 
+    return;
+  } 
+  AliZDCDigit* fDigit = NULL ; 
+  char** add = (char**) (branch->GetAddress());
+  if(add){
+    fDigit = (AliZDCDigit*)(*add);
+  } 
+  else{
+    if(!fDigit) fDigit = new AliZDCDigit();
+    branch->SetAddress(&fDigit);
+  }
+  
+  Int_t ndig = digitTree->GetEntries();
+  
+  Float_t adcSum_ZNC=0., adcSum_ZNA=0., adcSum_ZPC=0., adcSum_ZPA=0.;
+  Float_t adcSumQ_ZNC=0., adcSumQ_ZNA=0., adcSumQ_ZPC=0., adcSumQ_ZPA=0.;
+  //Float_t adcSum_ZNC_lg=0., adcSum_ZNA_lg=0., adcSum_ZPC_lg=0., adcSum_ZPA_lg=0.;
+  //Float_t adcSumQ_ZNC_lg=0., adcSumQ_ZNA_lg=0., adcSumQ_ZPC_lg=0., adcSumQ_ZPA_lg=0.;
+  //
+  for(Int_t i = 0; i < ndig; i++){
+    digitTree->GetEntry(i);
+    if(fDigit->GetSector(0)==1){
+      adcSum_ZNC += fDigit->GetADCValue(0);
+      //adcSum_ZNC_lg += fDigit->GetADCValue(1);
+      //
+      if(fDigit->GetSector(1)!=0){
+             adcSumQ_ZNC += fDigit->GetADCValue(0);
+             //adcSumQ_ZNC_lg+= fDigit->GetADCValue(1);
+      }
+      else{
+             GetDigitsData(8)->Fill(fDigit->GetADCValue(0));
+             //GetDigitsData(20)->Fill(fDigit->GetADCValue(1));
+      }
+    }
+    else if(fDigit->GetSector(0)==2){
+      adcSum_ZPC += fDigit->GetADCValue(0);
+      //adcSum_ZPC_lg += fDigit->GetADCValue(1);
+      //
+      if(fDigit->GetSector(1)!=0){
+             adcSumQ_ZPC += fDigit->GetADCValue(0);
+             //adcSumQ_ZPC_lg+= fDigit->GetADCValue(1);
+      }
+      else{
+             GetDigitsData(10)->Fill(fDigit->GetADCValue(0));
+             //GetDigitsData(22)->Fill(fDigit->GetADCValue(1));
+      }
+    }
+    else if(fDigit->GetSector(0)==4){
+      adcSum_ZNA += fDigit->GetADCValue(0);
+      //adcSum_ZNA_lg += fDigit->GetADCValue(1);
+      //
+      if(fDigit->GetSector(1)!=0){
+             adcSumQ_ZNA += fDigit->GetADCValue(0);
+             //adcSumQ_ZNA_lg+= fDigit->GetADCValue(1);
+      }
+      else{
+             GetDigitsData(9)->Fill(fDigit->GetADCValue(0));
+             //GetDigitsData(21)->Fill(fDigit->GetADCValue(1));
+      }
+    }
+    else if(fDigit->GetSector(0)==5){
+      adcSum_ZPA += fDigit->GetADCValue(0);
+      //adcSum_ZPA_lg += fDigit->GetADCValue(1);
+      //
+      if(fDigit->GetSector(1)!=0){
+             adcSumQ_ZPA += fDigit->GetADCValue(0);
+             //adcSumQ_ZPA_lg+= fDigit->GetADCValue(1);
+      }
+      else{
+             GetDigitsData(11)->Fill(fDigit->GetADCValue(0));
+             //GetDigitsData(23)->Fill(fDigit->GetADCValue(1));
+      }
+    }
+  }
+  //
+  GetDigitsData(0)->Fill(adcSum_ZNC);
+  GetDigitsData(1)->Fill(adcSum_ZNA);
+  GetDigitsData(2)->Fill(adcSum_ZPC);
+  GetDigitsData(3)->Fill(adcSum_ZPA);
+  //
+  GetDigitsData(4)->Fill(adcSumQ_ZNC);
+  GetDigitsData(5)->Fill(adcSumQ_ZNA);
+  GetDigitsData(6)->Fill(adcSumQ_ZPC);
+  GetDigitsData(7)->Fill(adcSumQ_ZPA);
+  //
+  /*GetDigitsData(12)->Fill(adcSum_ZNC_lg);
+  GetDigitsData(13)->Fill(adcSum_ZNA_lg);
+  GetDigitsData(14)->Fill(adcSum_ZPC_lg);
+  GetDigitsData(15)->Fill(adcSum_ZPA_lg);
+  //
+  GetDigitsData(16)->Fill(adcSumQ_ZNC_lg);
+  GetDigitsData(17)->Fill(adcSumQ_ZNA_lg);
+  GetDigitsData(18)->Fill(adcSumQ_ZPC_lg);
+  GetDigitsData(19)->Fill(adcSumQ_ZPA_lg);*/
+}
+
 //____________________________________________________________________________
 void AliZDCQADataMakerRec::MakeESDs(AliESDEvent * esd)
 {
index 4a35a69..624c077 100644 (file)
@@ -22,8 +22,11 @@ public:
   
 private:
   virtual void   InitESDs(); 
+  virtual void   InitDigits() ; 
   virtual void   InitRecPoints() {;} 
   virtual void   InitRaws(); 
+  virtual void   MakeDigits(TTree * /*recTree*/) ;
+  virtual void   MakeDigits(TClonesArray* /*digits*/)  {return;}
   virtual void   MakeRecPoints(TTree * /*recTree*/) {;} 
   virtual void   MakeRaws(AliRawReader* rawReader) ; 
   virtual void   MakeESDs(AliESDEvent * esd) ;
index 8e31554..b922897 100644 (file)
@@ -1,8 +1,8 @@
 Executable = "aliroot_new";
 Jobtag={"comment:PbPb, HIJING Central"};
 
-Packages={"VO_ALICE@AliRoot::v4-16-Rev-05",
-          "VO_ALICE@GEANT3::v1-9-8","VO_ALICE@ROOT::v5-22-00","VO_ALICE@APISCONFIG::V2.4"};
+Packages={"VO_ALICE@AliRoot::v4-16-Rev-10",
+          "VO_ALICE@GEANT3::v1-10","VO_ALICE@ROOT::v5-23-02","VO_ALICE@APISCONFIG::V2.4"};
 
 TTL = "72000";
 Price = 1;
@@ -10,7 +10,7 @@ Price = 1;
 Validationcommand ="/alice/cern.ch/user/a/aliprod/prod2007/configs_pbpb_hijing/validation.sh";
 
 InputFile= {"LF:/alice/cern.ch/user/e/estienne/prod2008/config_pbpb_hijing/Config.C",
-            "LF:/alice/cern.ch/user/e/estienne/prod2008/config_pbpb_hijing/simRun.C",
+            "LF:/alice/cern.ch/user/e/estienne/prod2008/config_pbpb_hijing/simrun.C",
             "LF:/alice/cern.ch/user/e/estienne/prod2008/config_pbpb_hijing/sim.C",
             "LF:/alice/cern.ch/user/e/estienne/prod2008/config_pbpb_hijing/rec.C",
             "LF:/alice/cern.ch/user/e/estienne/prod2008/config_pbpb_hijing/CheckESD.C",
@@ -24,7 +24,7 @@ OutputDir="[:OUTPUTDIR:]/$1/#alien_counter_03i#";
 JDLVariables={"Packages", "OutputDir"};
 GUIDFILE="guid.txt";
 
-splitarguments="simRun.C --run $1 --event #alien_counter# --bmin 0 --bmax 5 --quench 1 --qhat 1 --etamin -8 --etamax 8 --phimin 0 --phimax 360";
+splitarguments="simrun.C --run $1 --event #alien_counter# --bmin 0 --bmax 5 --quench 1 --qhat 1 --etamin -8 --etamax 8 --phimin 0 --phimax 360";
 split="production:1-1000";
 
 Workdirectorysize={"6000MB"};
index 1f8915c..7060a99 100755 (executable)
@@ -22,7 +22,7 @@ aliroot -b -q ${ALICE_ROOT}/STEER/CheckESD.C 2>&1 | tee check.log
 aliroot -b -q ${ALICE_ROOT}/STEER/CreateAODfromESD.C 2>&1 | tee aod.log
 
 cd recraw
-ln -s ../raw.root
+ln -s ../raw.root .
 aliroot -b -q rec.C      2>&1 | tee rec.log
 aliroot -b -q ${ALICE_ROOT}/STEER/CreateAODfromESD.C\(\"AliESDs.root\",\"AliAODs.root\",kFALSE\) 2>&1 | tee aod.log