#include "AliLog.h"
#include "AliACORDEdigit.h"
#include "AliACORDEhit.h"
+#include "AliACORDEDigit.h"
#include "AliACORDEQADataMakerRec.h"
#include "AliQAChecker.h"
#include "AliACORDERawReader.h"
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()
}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)
{
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) ;
#include "AliLog.h"
#include "AliEMCALQADataMakerRec.h"
#include "AliQAChecker.h"
+#include "AliEMCALDigit.h"
#include "AliEMCALRecPoint.h"
#include "AliEMCALRawUtils.h"
#include "AliEMCALReconstructor.h"
}
+//____________________________________________________________________________
+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()
{
return;
}
+//____________________________________________________________________________
+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)
{
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() ;
}
+//_____________________________________________________________________
+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()
{
}
}
-/*
+
//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeDigits(TClonesArray * digits)
{
branch->GetEntry(0);
MakeDigits(digitsAddress);
}
-*/
+
//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
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();
#include "AliLog.h"
#include "AliHMPIDDigit.h"
#include "AliHMPIDHit.h"
+#include "AliHMPIDDigit.h"
#include "AliHMPIDCluster.h"
#include "AliHMPIDQADataMakerRec.h"
#include "AliHMPIDQAChecker.h"
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()
{
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)
{
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
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()
{
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);
#include "AliITSRawStreamSDD.h"
#include "AliITSRawStreamSDDCompressed.h"
#include "AliITSDetTypeRec.h"
+#include "AliITSDigit.h"
#include "AliITSRecPoint.h"
#include "AliITSgeomTGeo.h"
#include "AliITSHLTforSDD.h"
fkOnline(kMode),
fLDC(ldc),
fSDDhRawsTask(0),
+fSDDhDigitsTask(0),
fSDDhRecPointsTask(0),
fGenRawsOffset(0),
+fGenDigitsOffset(0),
fGenRecPointsOffset(0),
fTimeBinSize(1),
fDDLModuleMap(0),
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),
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; 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()
{
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);
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
#include "AliRawReader.h"
#include "AliITSRawStreamSPD.h"
#include "AliITSRawStreamSPDErrorLog.h"
+#include "AliITSDigit.h"
#include "AliITSRecPoint.h"
ClassImp(AliITSQASPDDataMakerRec)
fkOnline(kMode),
fLDC(ldc),
fSPDhRawsTask(0),
+fSPDhDigitsTask(0),
fSPDhRecPointsTask(0),
fGenRawsOffset(0),
+fGenDigitsOffset(0),
fGenRecPointsOffset(0),
fAdvLogger(aliITSRawStreamSPDErrorLog)
{
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)
{
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; 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()
{
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
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
};
#include "AliITSgeomTGeo.h"
#include "AliRawEventHeaderBase.h"
#include "AliITSRecPoint.h"
+#include "AliITSDigit.h"
#include "AliITSBadChannelsSSDv2.h"
#include "AliCDBManager.h"
fSSDRawsOffset(0), fSSDRawsDAOffset(0),
fSSDRawsCommonLevelOffset(0),
fSSDhRawsTask(0),
+fSSDhDigitsTask(0),
fSSDhRecPointsTask(0),
fGenRawsOffset(0),
+fGenDigitsOffset(0),
fGenRecPointsOffset(0),
fCDBManager(0) {
// Default constructor
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
}//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()
{
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);
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
#include "AliQAChecker.h"
#include "AliCodeTimer.h"
#include "AliDCSValue.h"
+#include "AliMUONVDigit.h"
// --- ROOT system ---
#include <TClonesArray.h>
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()
{
} // 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)
{
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) ;
#include "AliLog.h"
#include "AliPHOSQADataMakerRec.h"
#include "AliQAChecker.h"
+#include "AliPHOSDigit.h"
#include "AliPHOSCpvRecPoint.h"
#include "AliPHOSEmcRecPoint.h"
#include "AliPHOSRecParticle.h"
}
+//____________________________________________________________________________
+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()
{
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)
{
kRPNtot,kRPEtot,kRPSpec,kRPTime,kRPNcpv} ;
//Histograms for ESDs control
enum HESDType_t {kESDNtot,kESDEtot,kESDSpec,kESDpid} ;
+ enum HDigitType_t {kDigits=0, kDigitsMul} ;
+
public:
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() ;
#include "AliLog.h"
#include "AliPMDQADataMakerRec.h"
#include "AliQAChecker.h"
+#include "AliPMDDigit.h"
#include "AliPMDrecpoint1.h"
#include "AliPMDRawStream.h"
#include "AliPMDddldata.h"
//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()
{
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<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)
{
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() ;
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)
};
//_____________________________________________________________________________
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();
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) )
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 = 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 )
AliQADataMaker(name, title),
fESDsQAList(NULL),
fRawsQAList(NULL),
+ fDigitsQAList(NULL),
fRecPointsQAList(NULL),
fCorrNt(NULL),
fRecoParam(NULL)
AliQADataMaker(qadm.GetName(), qadm.GetTitle()),
fESDsQAList(qadm.fESDsQAList),
fRawsQAList(qadm.fRawsQAList),
+ fDigitsQAList(qadm.fDigitsQAList),
fRecPointsQAList(qadm.fRecPointsQAList),
fCorrNt(qadm.fCorrNt),
fRecoParam(qadm.fRecoParam)
}
}
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++) {
{
// Finishes a cycle of QA for all the tasks
EndOfCycle(AliQAv1::kRAWS) ;
+ EndOfCycle(AliQAv1::kDIGITSR) ;
EndOfCycle(AliQAv1::kRECPOINTS) ;
EndOfCycle(AliQAv1::kESDS) ;
ResetCycle() ;
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 )
break;
case AliQAv1::kDIGITS:
break;
+ case AliQAv1::kDIGITSR:
+ list = fDigitsQAList ;
+ break;
case AliQAv1::kRECPOINTS:
list = fRecPointsQAList ;
break;
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) ;
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] ;
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 ) {
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) ;
}
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 ; }
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 ; }
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") ; }
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");}
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
};
case AliQAv1::kDIGITS:
list = fDigitsQAList ;
break;
+ case AliQAv1::kDIGITSR:
+ break;
case AliQAv1::kRECPOINTS:
break;
case AliQAv1::kTRACKSEGMENTS:
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) ;
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))) {
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)));
+ }
}
}
}
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://" ;
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
// 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;
}
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();
}
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(":")) {
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") )
}
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()) ) ;
#include "AliT0digit.h"
#include "AliT0hit.h"
#include "AliT0RecPoint.h"
+#include "AliT0Digit.h"
#include "AliT0QADataMakerRec.h"
#include "AliQAChecker.h"
#include "AliT0RawReader.h"
// 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);
+
+
+
}
//____________________________________________________________________________
+//____________________________________________________________________________
+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)
{
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() ;
#include "AliTOFRawStream.h"
#include "AliTOFrawData.h"
#include "AliTOFGeometry.h"
+#include "AliTOFDigit.h"
ClassImp(AliTOFQADataMakerRec)
}
+//____________________________________________________________________________
+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()
{
}
}
+//____________________________________________________________________________
+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)
{
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) ;
#include "AliTPCCalROC.h"
#include "AliTPCClustersRow.h"
#include "AliTPCclusterMI.h"
+#include "AliSimDigits.h"
ClassImp(AliTPCQADataMakerRec)
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()
{
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)
{
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} ;
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();
#include "AliTRDgeometry.h"
//#include "AliTRDdataArrayI.h"
#include "AliTRDrawStream.h"
-
+#include "AliTRDdigitsManager.h"
+#include "AliTRDdigit.h"
+#include "AliTRDarrayADC.h"
#include "AliQAChecker.h"
ClassImp(AliTRDQADataMakerRec)
}
+//____________________________________________________________________________
+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()
{
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<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)
{
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);
#include "AliQAChecker.h"
#include "AliRawReader.h"
#include "AliVZERORawStream.h"
+#include "AliVZERODigit.h"
#include "AliVZEROReconstructor.h"
#include "event.h"
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)
{
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;
#include "AliRawReader.h"
#include "AliZDCQADataMakerRec.h"
#include "AliZDCRawStream.h"
+#include "AliZDCDigit.h"
#include "AliESDZDC.h"
#include "AliESDEvent.h"
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()
{
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)
{
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) ;
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;
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",
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"};
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
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff