From 44ed7a669ab9cf51d3f37f1f6736443b71c54926 Mon Sep 17 00:00:00 2001 From: hristov Date: Sun, 24 May 2009 14:25:47 +0000 Subject: [PATCH] Added QA for digits during reconstruction (Yves) --- ACORDE/AliACORDEQADataMakerRec.cxx | 41 +++++++ ACORDE/AliACORDEQADataMakerRec.h | 3 + EMCAL/AliEMCALQADataMakerRec.cxx | 47 ++++++++ EMCAL/AliEMCALQADataMakerRec.h | 3 + FMD/AliFMDQADataMakerRec.cxx | 17 ++- FMD/AliFMDQADataMakerRec.h | 6 +- HMPID/AliHMPIDQADataMakerRec.cxx | 74 +++++++++++++ HMPID/AliHMPIDQADataMakerRec.h | 3 + ITS/AliITSQADataMakerRec.cxx | 27 +++++ ITS/AliITSQADataMakerRec.h | 2 + ITS/AliITSQASDDDataMakerRec.cxx | 70 ++++++++++++ ITS/AliITSQASDDDataMakerRec.h | 5 + ITS/AliITSQASPDDataMakerRec.cxx | 113 +++++++++++++++++++ ITS/AliITSQASPDDataMakerRec.h | 7 +- ITS/AliITSQASSDDataMakerRec.cxx | 61 +++++++++++ ITS/AliITSQASSDDataMakerRec.h | 5 + MUON/AliMUONQADataMakerRec.cxx | 36 ++++++ MUON/AliMUONQADataMakerRec.h | 3 + PHOS/AliPHOSQADataMakerRec.cxx | 45 ++++++++ PHOS/AliPHOSQADataMakerRec.h | 5 + PMD/AliPMDQADataMakerRec.cxx | 81 ++++++++++++++ PMD/AliPMDQADataMakerRec.h | 3 + STEER/AliDetectorRecoParam.h | 2 +- STEER/AliQAChecker.cxx | 8 +- STEER/AliQADataMakerRec.cxx | 38 +++++++ STEER/AliQADataMakerRec.h | 23 ++-- STEER/AliQADataMakerSim.cxx | 2 + STEER/AliQADataMakerSim.h | 18 ++- STEER/AliQAManager.cxx | 11 +- STEER/AliQAv1.cxx | 2 +- STEER/AliQAv1.h | 2 +- STEER/AliReconstruction.cxx | 23 ++-- T0/AliT0QADataMakerRec.cxx | 63 +++++++++++ T0/AliT0QADataMakerRec.h | 3 + TOF/AliTOFQADataMakerRec.cxx | 89 +++++++++++++++ TOF/AliTOFQADataMakerRec.h | 3 + TPC/AliTPCQADataMakerRec.cxx | 35 ++++++ TPC/AliTPCQADataMakerRec.h | 8 +- TRD/AliTRDQADataMakerRec.cxx | 97 +++++++++++++++- TRD/AliTRDQADataMakerRec.h | 3 + VZERO/AliVZEROQADataMakerRec.cxx | 68 ++++++++++++ VZERO/AliVZEROQADataMakerRec.h | 5 +- ZDC/AliZDCQADataMakerRec.cxx | 170 +++++++++++++++++++++++++++++ ZDC/AliZDCQADataMakerRec.h | 3 + prod/LHC08d6/JDL | 8 +- test/ppbench/runtest.sh | 2 +- 46 files changed, 1300 insertions(+), 43 deletions(-) diff --git a/ACORDE/AliACORDEQADataMakerRec.cxx b/ACORDE/AliACORDEQADataMakerRec.cxx index 9203890f667..a6d2fe635ed 100755 --- a/ACORDE/AliACORDEQADataMakerRec.cxx +++ b/ACORDE/AliACORDEQADataMakerRec.cxx @@ -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" @@ -97,6 +98,22 @@ void AliACORDEQADataMakerRec::InitRaws() for(Int_t i=0;i<4;i++) 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() @@ -188,6 +205,30 @@ if(rawStream.Next()) }GetRawsData(2)->Fill(contSingle);GetRawsData(3)->Fill(contMulti); } } +//____________________________________________________________________________ +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) { diff --git a/ACORDE/AliACORDEQADataMakerRec.h b/ACORDE/AliACORDEQADataMakerRec.h index 606527ad5eb..91826db0632 100755 --- a/ACORDE/AliACORDEQADataMakerRec.h +++ b/ACORDE/AliACORDEQADataMakerRec.h @@ -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) ; diff --git a/EMCAL/AliEMCALQADataMakerRec.cxx b/EMCAL/AliEMCALQADataMakerRec.cxx index dfa8f09985c..68d5ab9efc3 100644 --- a/EMCAL/AliEMCALQADataMakerRec.cxx +++ b/EMCAL/AliEMCALQADataMakerRec.cxx @@ -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" @@ -107,6 +108,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() { @@ -366,6 +382,37 @@ void AliEMCALQADataMakerRec::MakeRaws(AliRawReader* rawReader) return; } +//____________________________________________________________________________ +void AliEMCALQADataMakerRec::MakeDigits(TClonesArray * digits) +{ + // makes data from Digits + + GetDigitsData(1)->Fill(digits->GetEntriesFast()) ; + TIter next(digits) ; + AliEMCALDigit * digit ; + while ( (digit = dynamic_cast(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) { diff --git a/EMCAL/AliEMCALQADataMakerRec.h b/EMCAL/AliEMCALQADataMakerRec.h index 0c0f6da7a82..b0c7e4e27ae 100644 --- a/EMCAL/AliEMCALQADataMakerRec.h +++ b/EMCAL/AliEMCALQADataMakerRec.h @@ -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() ; diff --git a/FMD/AliFMDQADataMakerRec.cxx b/FMD/AliFMDQADataMakerRec.cxx index f95d040b44b..7f8da63b089 100644 --- a/FMD/AliFMDQADataMakerRec.cxx +++ b/FMD/AliFMDQADataMakerRec.cxx @@ -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) { diff --git a/FMD/AliFMDQADataMakerRec.h b/FMD/AliFMDQADataMakerRec.h index 58898d4632f..7dbef41391f 100644 --- a/FMD/AliFMDQADataMakerRec.h +++ b/FMD/AliFMDQADataMakerRec.h @@ -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(); diff --git a/HMPID/AliHMPIDQADataMakerRec.cxx b/HMPID/AliHMPIDQADataMakerRec.cxx index b085dbfce3a..25e6607beb6 100644 --- a/HMPID/AliHMPIDQADataMakerRec.cxx +++ b/HMPID/AliHMPIDQADataMakerRec.cxx @@ -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" @@ -72,6 +73,30 @@ AliHMPIDQADataMakerRec& AliHMPIDQADataMakerRec::operator = (const AliHMPIDQAData return *this; } +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +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() { @@ -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(data); + if ( !chamber) { + AliError("Wrong type of digits container") ; + } else { + for(Int_t i =0; i< chamber->GetEntries(); i++) + { + TClonesArray * digits = dynamic_cast(chamber->At(i)); + GetDigitsData(0)->Fill(i,digits->GetEntriesFast()/(48.*80.*6.)); + TIter next(digits); + AliHMPIDDigit * digit; + while ( (digit = dynamic_cast(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) { diff --git a/HMPID/AliHMPIDQADataMakerRec.h b/HMPID/AliHMPIDQADataMakerRec.h index bcae699bab3..45fb4ef6a93 100644 --- a/HMPID/AliHMPIDQADataMakerRec.h +++ b/HMPID/AliHMPIDQADataMakerRec.h @@ -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 diff --git a/ITS/AliITSQADataMakerRec.cxx b/ITS/AliITSQADataMakerRec.cxx index 99c7f581032..48b3e774d40 100644 --- a/ITS/AliITSQADataMakerRec.cxx +++ b/ITS/AliITSQADataMakerRec.cxx @@ -185,6 +185,33 @@ void AliITSQADataMakerRec::MakeRaws(AliRawReader* rawReader) if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeRaws(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() { diff --git a/ITS/AliITSQADataMakerRec.h b/ITS/AliITSQADataMakerRec.h index a8948d009a8..e690f5d1b69 100644 --- a/ITS/AliITSQADataMakerRec.h +++ b/ITS/AliITSQADataMakerRec.h @@ -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); diff --git a/ITS/AliITSQASDDDataMakerRec.cxx b/ITS/AliITSQASDDDataMakerRec.cxx index fabfa8dea6a..7cc3ccb29f7 100644 --- a/ITS/AliITSQASDDDataMakerRec.cxx +++ b/ITS/AliITSQASDDDataMakerRec.cxx @@ -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), @@ -393,6 +398,71 @@ void AliITSQASDDDataMakerRec::MakeRaws(AliRawReader* rawReader) stream = NULL; } +//____________________________________________________________________________ +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; idigUncheckedAt(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() { diff --git a/ITS/AliITSQASDDDataMakerRec.h b/ITS/AliITSQASDDDataMakerRec.h index 4f56534e6a7..939952b89d6 100644 --- a/ITS/AliITSQASDDDataMakerRec.h +++ b/ITS/AliITSQASDDDataMakerRec.h @@ -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 diff --git a/ITS/AliITSQASPDDataMakerRec.cxx b/ITS/AliITSQASPDDataMakerRec.cxx index 4a44dca2051..08a3136f2ff 100644 --- a/ITS/AliITSQASPDDataMakerRec.cxx +++ b/ITS/AliITSQASPDDataMakerRec.cxx @@ -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) { @@ -234,6 +239,114 @@ void AliITSQASPDDataMakerRec::MakeRaws(AliRawReader* rawReader) AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",nDigitsL1+nDigitsL2)); } +//____________________________________________________________________________ +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; idigUncheckedAt(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() { diff --git a/ITS/AliITSQASPDDataMakerRec.h b/ITS/AliITSQASPDDataMakerRec.h index 86ed2134367..53f75fe43c5 100644 --- a/ITS/AliITSQASPDDataMakerRec.h +++ b/ITS/AliITSQASPDDataMakerRec.h @@ -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 }; diff --git a/ITS/AliITSQASSDDataMakerRec.cxx b/ITS/AliITSQASSDDataMakerRec.cxx index 49d65f72ebb..e0f81f7afd2 100644 --- a/ITS/AliITSQASSDDataMakerRec.cxx +++ b/ITS/AliITSQASSDDataMakerRec.cxx @@ -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 @@ -881,6 +886,62 @@ void AliITSQASSDDataMakerRec::MonitorOCDBObjects() { }//module loop } +//____________________________________________________________________________ +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() { diff --git a/ITS/AliITSQASSDDataMakerRec.h b/ITS/AliITSQASSDDataMakerRec.h index e65d14c196b..7d1a56b4966 100644 --- a/ITS/AliITSQASSDDataMakerRec.h +++ b/ITS/AliITSQASSDDataMakerRec.h @@ -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 diff --git a/MUON/AliMUONQADataMakerRec.cxx b/MUON/AliMUONQADataMakerRec.cxx index a247343450f..93a7a31ac20 100644 --- a/MUON/AliMUONQADataMakerRec.cxx +++ b/MUON/AliMUONQADataMakerRec.cxx @@ -64,6 +64,7 @@ #include "AliQAChecker.h" #include "AliCodeTimer.h" #include "AliDCSValue.h" +#include "AliMUONVDigit.h" // --- ROOT system --- #include @@ -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(next()) ) ) + { + GetDigitsData(0)->Fill(dig->DetElemId()); + GetDigitsData(1)->Fill(dig->ADC()); + } +} + //____________________________________________________________________________ void AliMUONQADataMakerRec::MakeRecPoints(TTree* clustersTree) { diff --git a/MUON/AliMUONQADataMakerRec.h b/MUON/AliMUONQADataMakerRec.h index 29407d9ab1c..4d0483d2833 100644 --- a/MUON/AliMUONQADataMakerRec.h +++ b/MUON/AliMUONQADataMakerRec.h @@ -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) ; diff --git a/PHOS/AliPHOSQADataMakerRec.cxx b/PHOS/AliPHOSQADataMakerRec.cxx index c05a2091e2e..8f929a820d6 100644 --- a/PHOS/AliPHOSQADataMakerRec.cxx +++ b/PHOS/AliPHOSQADataMakerRec.cxx @@ -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" @@ -118,6 +119,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() { @@ -460,6 +475,36 @@ void AliPHOSQADataMakerRec::MakeRaws(AliRawReader* rawReader) p = dynamic_cast*>(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(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) { diff --git a/PHOS/AliPHOSQADataMakerRec.h b/PHOS/AliPHOSQADataMakerRec.h index 5401af142f0..4305a6c10a8 100644 --- a/PHOS/AliPHOSQADataMakerRec.h +++ b/PHOS/AliPHOSQADataMakerRec.h @@ -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() ; diff --git a/PMD/AliPMDQADataMakerRec.cxx b/PMD/AliPMDQADataMakerRec.cxx index 0fb3e68289e..e6eeeb84933 100644 --- a/PMD/AliPMDQADataMakerRec.cxx +++ b/PMD/AliPMDQADataMakerRec.cxx @@ -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() { @@ -460,6 +487,60 @@ void AliPMDQADataMakerRec::MakeRaws(AliRawReader* rawReader) pmdddlcont = 0x0; } +//____________________________________________________________________________ +void AliPMDQADataMakerRec::MakeDigits(TClonesArray * digits) +{ + // makes data from Digits + + Int_t cpvmul = 0, premul = 0; + + TIter next(digits) ; + AliPMDdigit * digit ; + while ( (digit = dynamic_cast(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) { diff --git a/PMD/AliPMDQADataMakerRec.h b/PMD/AliPMDQADataMakerRec.h index 4bbe0746665..66d98dafeb6 100644 --- a/PMD/AliPMDQADataMakerRec.h +++ b/PMD/AliPMDQADataMakerRec.h @@ -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() ; diff --git a/STEER/AliDetectorRecoParam.h b/STEER/AliDetectorRecoParam.h index f7d16ef8a70..b97726fe8fd 100644 --- a/STEER/AliDetectorRecoParam.h +++ b/STEER/AliDetectorRecoParam.h @@ -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) }; diff --git a/STEER/AliQAChecker.cxx b/STEER/AliQAChecker.cxx index 9cd16ed0af8..f3253fd5d3b 100644 --- a/STEER/AliQAChecker.cxx +++ b/STEER/AliQAChecker.cxx @@ -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 ) diff --git a/STEER/AliQADataMakerRec.cxx b/STEER/AliQADataMakerRec.cxx index 8bb2306a56e..54e08cbffee 100644 --- a/STEER/AliQADataMakerRec.cxx +++ b/STEER/AliQADataMakerRec.cxx @@ -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) @@ -94,6 +96,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++) { @@ -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(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(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) ; } diff --git a/STEER/AliQADataMakerRec.h b/STEER/AliQADataMakerRec.h index 403132a2ca8..a464e54d5b4 100644 --- a/STEER/AliQADataMakerRec.h +++ b/STEER/AliQADataMakerRec.h @@ -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(GetData(fDigitsQAList, index)) ; } virtual TH1 * GetESDsData(const Int_t index) { return dynamic_cast(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 }; diff --git a/STEER/AliQADataMakerSim.cxx b/STEER/AliQADataMakerSim.cxx index 01c7a961cf0..b0dcbbe106c 100644 --- a/STEER/AliQADataMakerSim.cxx +++ b/STEER/AliQADataMakerSim.cxx @@ -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: diff --git a/STEER/AliQADataMakerSim.h b/STEER/AliQADataMakerSim.h index 3b7a0a20d43..130628f5135 100644 --- a/STEER/AliQADataMakerSim.h +++ b/STEER/AliQADataMakerSim.h @@ -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) ; diff --git a/STEER/AliQAManager.cxx b/STEER/AliQAManager.cxx index 60902ea5a53..ec9786b3cce 100644 --- a/STEER/AliQAManager.cxx +++ b/STEER/AliQAManager.cxx @@ -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))); + } } } } diff --git a/STEER/AliQAv1.cxx b/STEER/AliQAv1.cxx index 3f7aeb8253c..1ae28d3c804 100644 --- a/STEER/AliQAv1.cxx +++ b/STEER/AliQAv1.cxx @@ -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://" ; diff --git a/STEER/AliQAv1.h b/STEER/AliQAv1.h index c8fca2cfaad..3554276b4af 100644 --- a/STEER/AliQAv1.h +++ b/STEER/AliQAv1.h @@ -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 diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index c484a658f5b..3c35dfb3fcb 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -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()) ) ; diff --git a/T0/AliT0QADataMakerRec.cxx b/T0/AliT0QADataMakerRec.cxx index ca435f4a4fe..e2a317a8e28 100644 --- a/T0/AliT0QADataMakerRec.cxx +++ b/T0/AliT0QADataMakerRec.cxx @@ -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" @@ -233,6 +234,24 @@ void AliT0QADataMakerRec::InitRaws() // TH2F* fhLineQTC = new TH2F("hLineQTC","QTC amplitude boeder",24, 0 ,24, // 100,0,7000); // Add2RawsList( fhLineQTC,208, !expert, !image, saveCorr); +} + +//____________________________________________________________________________ +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); + + + } //____________________________________________________________________________ @@ -402,6 +421,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) { diff --git a/T0/AliT0QADataMakerRec.h b/T0/AliT0QADataMakerRec.h index 32b735da839..1085ca2b5d4 100644 --- a/T0/AliT0QADataMakerRec.h +++ b/T0/AliT0QADataMakerRec.h @@ -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() ; diff --git a/TOF/AliTOFQADataMakerRec.cxx b/TOF/AliTOFQADataMakerRec.cxx index 573db59a058..10bf16b1ba5 100644 --- a/TOF/AliTOFQADataMakerRec.cxx +++ b/TOF/AliTOFQADataMakerRec.cxx @@ -38,6 +38,7 @@ #include "AliTOFRawStream.h" #include "AliTOFrawData.h" #include "AliTOFGeometry.h" +#include "AliTOFDigit.h" ClassImp(AliTOFQADataMakerRec) @@ -108,6 +109,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() { @@ -235,6 +270,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(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) { diff --git a/TOF/AliTOFQADataMakerRec.h b/TOF/AliTOFQADataMakerRec.h index 21f050ed3b7..d67e82e72d4 100644 --- a/TOF/AliTOFQADataMakerRec.h +++ b/TOF/AliTOFQADataMakerRec.h @@ -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) ; diff --git a/TPC/AliTPCQADataMakerRec.cxx b/TPC/AliTPCQADataMakerRec.cxx index c2f295d519a..c23a9ad282c 100644 --- a/TPC/AliTPCQADataMakerRec.cxx +++ b/TPC/AliTPCQADataMakerRec.cxx @@ -63,6 +63,7 @@ #include "AliTPCCalROC.h" #include "AliTPCClustersRow.h" #include "AliTPCclusterMI.h" +#include "AliSimDigits.h" ClassImp(AliTPCQADataMakerRec) @@ -311,6 +312,18 @@ void AliTPCQADataMakerRec::InitRaws() Add2RawsList(histRawsQmaxVsSector, kQmaxVsSector, !expert, image, !saveCorr); } +//____________________________________________________________________________ +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() { @@ -396,6 +409,28 @@ void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader) fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(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) { diff --git a/TPC/AliTPCQADataMakerRec.h b/TPC/AliTPCQADataMakerRec.h index 5af6c625390..07f139322af 100644 --- a/TPC/AliTPCQADataMakerRec.h +++ b/TPC/AliTPCQADataMakerRec.h @@ -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(); diff --git a/TRD/AliTRDQADataMakerRec.cxx b/TRD/AliTRDQADataMakerRec.cxx index 0e86711b6ae..a47cd42788c 100644 --- a/TRD/AliTRDQADataMakerRec.cxx +++ b/TRD/AliTRDQADataMakerRec.cxx @@ -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) @@ -328,6 +330,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; iSumw2(); + Add2DigitsList(hist[i], i, !expert, image); + } + +} + //____________________________________________________________________________ void AliTRDQADataMakerRec::InitRecPoints() { @@ -685,6 +710,76 @@ void AliTRDQADataMakerRec::MakeRaws(AliRawReader* rawReader) delete raw; } +//____________________________________________________________________________ +void AliTRDQADataMakerRec::MakeDigits(TClonesArray * digits) +{ + // + // Makes data from Digits + // + + TIter next(digits) ; + AliTRDdigit * digit ; + + // Info("Make digits", "From the arrya"); + + while ( (digit = dynamic_cast(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) { diff --git a/TRD/AliTRDQADataMakerRec.h b/TRD/AliTRDQADataMakerRec.h index 330717b62f9..61dac7f2165 100644 --- a/TRD/AliTRDQADataMakerRec.h +++ b/TRD/AliTRDQADataMakerRec.h @@ -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); diff --git a/VZERO/AliVZEROQADataMakerRec.cxx b/VZERO/AliVZEROQADataMakerRec.cxx index fe8e485165d..955b075a784 100644 --- a/VZERO/AliVZEROQADataMakerRec.cxx +++ b/VZERO/AliVZEROQADataMakerRec.cxx @@ -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(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) { diff --git a/VZERO/AliVZEROQADataMakerRec.h b/VZERO/AliVZEROQADataMakerRec.h index 76ff6ee6616..7054750dbb5 100644 --- a/VZERO/AliVZEROQADataMakerRec.h +++ b/VZERO/AliVZEROQADataMakerRec.h @@ -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; diff --git a/ZDC/AliZDCQADataMakerRec.cxx b/ZDC/AliZDCQADataMakerRec.cxx index 48e5d3147cc..1ee14c93682 100644 --- a/ZDC/AliZDCQADataMakerRec.cxx +++ b/ZDC/AliZDCQADataMakerRec.cxx @@ -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) { diff --git a/ZDC/AliZDCQADataMakerRec.h b/ZDC/AliZDCQADataMakerRec.h index 4a35a69f440..624c0775ca8 100644 --- a/ZDC/AliZDCQADataMakerRec.h +++ b/ZDC/AliZDCQADataMakerRec.h @@ -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) ; diff --git a/prod/LHC08d6/JDL b/prod/LHC08d6/JDL index 8e315545b84..b922897b636 100644 --- a/prod/LHC08d6/JDL +++ b/prod/LHC08d6/JDL @@ -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"}; diff --git a/test/ppbench/runtest.sh b/test/ppbench/runtest.sh index 1f8915c5e82..7060a99505a 100755 --- a/test/ppbench/runtest.sh +++ b/test/ppbench/runtest.sh @@ -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 -- 2.43.0