void AliITSQADataMakerRec::InitRaws()
{
- if(fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
- Int_t rv = 0;
- //AliInfo(Form("Start InitRaws on specie %d\n",AliRecoParam::AConvert(fEventSpecie)));
- //AliInfo(Form("fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
- if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRaws\n");
- rv = fSPDDataMaker->InitRaws();
- }
- if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRaws\n");
- //AliInfo(Form("set offset to %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
- fSDDDataMaker->SetOffset(AliQAv1::kRAWS, fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
- rv = fSDDDataMaker->InitRaws();
- }
- if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRaws\n");
- //AliInfo(Form("set offset to %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
- fSSDDataMaker->SetOffset(AliQAv1::kRAWS, fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
- rv = fSSDDataMaker->InitRaws();
- }
+ //if(fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
+
+
+ if(fSubDetector == 0 || fSubDetector == 1) {
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRaws\n");
+ fSPDDataMaker->InitRaws();
+ }
+ if(fSubDetector == 0 || fSubDetector == 2) {
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRaws\n");
+
+ fSDDDataMaker->SetOffset(AliQAv1::kRAWS, fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSDDDataMaker->InitRaws();
+ }
+ if(fSubDetector == 0 || fSubDetector == 3) {
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRaws\n");
+
+ fSSDDataMaker->SetOffset(AliQAv1::kRAWS, fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSSDDataMaker->InitRaws();
+ }
}
//____________________________________________________________________________
// Fill QA for RAW
//return ;
- //AliInfo(Form("fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
+
if(fSubDetector == 0 || fSubDetector == 1) {
fSPDDataMaker->MakeRaws(rawReader) ;
}
- //AliInfo(Form("fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
if(fSubDetector == 0 || fSubDetector == 2) {
fSDDDataMaker->MakeRaws(rawReader) ;
}
- //AliInfo(Form("fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
+
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeRaws(rawReader);
- //AliInfo(Form("fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
+
}
//____________________________________________________________________________
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->SetOffset(AliQAv1::kDIGITSR, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+
fSDDDataMaker->InitDigits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitDigits\n");
+ fSSDDataMaker->SetOffset(AliQAv1::kDIGITSR, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+
fSSDDataMaker->InitDigits();
}
}
void AliITSQADataMakerRec::MakeDigits(TTree * digitsTree)
{
+
// Fill QA for recpoints
if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeDigits(digitsTree) ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kDIGITSR, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
+ fSPDDataMaker->MakeDigits(digitsTree) ;
}
if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeDigits(digitsTree) ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kDIGITSR, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
+ fSDDDataMaker->MakeDigits(digitsTree) ;
+
}
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digitsTree);
// Initialization for RECPOINTS
- //AliInfo(Form("AliRecoParam::AConvert(fEventSpecie) %d\n",AliRecoParam::AConvert(fEventSpecie)));
- //AliInfo(Form("fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
- if(fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
+
+ //if(fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
if(fSubDetector == 0 || fSubDetector == 1) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRecPoints\n");
fSPDDataMaker->InitRecPoints();
}
if(fSubDetector == 0 || fSubDetector == 2) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRecPoints\n");
- //AliInfo(Form("set offset to %d\n",fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
- fSDDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSDDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(), AliRecoParam::AConvert(fEventSpecie));
fSDDDataMaker->InitRecPoints();
}
if(fSubDetector == 0 || fSubDetector == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRecPoints\n");
- //AliInfo(Form("set offset to %d\n",fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
fSSDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
fSSDDataMaker->InitRecPoints();
}
- //AliInfo(Form("fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
const Bool_t expert = kTRUE ;
hPhiEta[iLay]->GetXaxis()->SetTitle("Pseudorapidity");
hPhiEta[iLay]->GetYaxis()->SetTitle("#varphi [rad]");
Add2RecPointsList((new TH2F(*hPhiEta[iLay])), iLay + offset, !expert, image);
- //AliInfo(Form("Added histo phi vs eta at position %d\n", iLay + offset));
+
delete hPhiEta[iLay];
}
- //AliInfo(Form("fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries() %d\n",fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()));
+
}
//____________________________________________________________________________
Double_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
Double_t theta = TMath::ACos(cluGlo[2]/rad);
Double_t eta = 100.;
- if(IsEqual(rad,0.) == kFALSE) {
+ if(AreEqual(rad,0.) == kFALSE) {
if(theta<=1.e-14){ eta=30.; }
else { eta = -TMath::Log(TMath::Tan(theta/2.));}
}
Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
// Check id histograms already created for this Event Specie
rcp.GetGlobalXYZ(cluGlo);
- Double_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]);
+ Double_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]+cluGlo[2]*cluGlo[2]);
Double_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
Double_t theta = TMath::ACos(cluGlo[2]/rad);
Double_t eta = 100.;
- if(IsEqual(rad,0.)==kFALSE) {
+ if(AreEqual(rad,0.)==kFALSE) {
if(theta<=1.e-14){eta=30.;}
else {eta = -TMath::Log(TMath::Tan(theta/2.));}
}
(GetRecPointsData( rcp.GetLayer() + offset - 6))->Fill(eta,phi);
- /*
- if(rad != 0) eta = -TMath::Log(TMath::Tan(theta/2.));
- (GetRecPointsData( rcp.GetLayer() + offset - 6))->Fill(eta,phi);
- */
+
}
//____________________________________________________________________________
//____________________________________________________________________
-Bool_t AliITSQADataMakerRec::IsEqual(Double_t a1,Double_t a2)
+Bool_t AliITSQADataMakerRec::AreEqual(Double_t a1,Double_t a2)
{
- const Double_t kEpsilon= 0.000000001;
+ const Double_t kEpsilon= 1.e-14;
return TMath::Abs(a1-a2)<=kEpsilon*TMath::Abs(a1);
}
Short_t GetSubDet(){return fSubDetector;};
Int_t GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task);
TH2F *GetITSGlobalHisto(Int_t layer);
- static Bool_t IsEqual(Double_t a1, Double_t a2);
+ Bool_t AreEqual(Double_t a1, Double_t a2);
private:
// Initialization for RAW data
if(fSubDetector == 0 || fSubDetector == 1) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitDigits\n");
+
fSPDDataMaker->InitDigits();
}
if(fSubDetector == 0 || fSubDetector == 2) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitDigits\n");
+
+ fSDDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
fSDDDataMaker->InitDigits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitDigits\n");
+
+ fSSDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
fSSDDataMaker->InitDigits();
}
}
void AliITSQADataMakerSim::MakeDigits()
{
// Fill QA for digits
- if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeDigits() ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ if(fSubDetector == 0 || fSubDetector == 1)
+ fSPDDataMaker->MakeDigits() ;
+
- if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeDigits() ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ if(fSubDetector == 0 || fSubDetector == 2)
+ fSDDDataMaker->MakeDigits() ;
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits();
}
void AliITSQADataMakerSim::MakeDigits(TTree * digits)
{
// Fill QA for digits
- if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeDigits(digits) ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
-
- if(fSubDetector == 0 || fSubDetector == 2){
- Int_t rv = fSDDDataMaker->MakeDigits(digits) ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ if(fSubDetector == 0 || fSubDetector == 1)
+ fSPDDataMaker->MakeDigits(digits) ;
+
+ if(fSubDetector == 0 || fSubDetector == 2)
+ fSDDDataMaker->MakeDigits(digits) ;
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digits);
}
// Initialization for RECPOINTS
if(fSubDetector == 0 || fSubDetector == 1) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitSDigits\n");
+
fSPDDataMaker->InitSDigits();
}
- if(fSubDetector == 0 || fSubDetector == 2) {
+ if(fSubDetector == 0 || fSubDetector == 2){
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitSDigits\n");
- fSDDDataMaker->InitSDigits();
+
+ fSDDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSDDDataMaker->InitSDigits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitSDigits\n");
- fSSDDataMaker->InitSDigits();
+
+ fSSDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSSDDataMaker->InitSDigits();
}
}
void AliITSQADataMakerSim::MakeSDigits()
{
// Fill QA for recpoints
- if(fSubDetector == 0 || fSubDetector == 1){
- Int_t rv = fSPDDataMaker->MakeSDigits() ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ if(fSubDetector == 0 || fSubDetector == 1)
+ fSPDDataMaker->MakeSDigits() ;
+
- if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeSDigits() ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ if(fSubDetector == 0 || fSubDetector == 2)
+ fSDDDataMaker->MakeSDigits() ;
+
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeSDigits();
}
{
// Fill QA for recpoints
if(fSubDetector == 0 || fSubDetector == 1){
- Int_t rv = fSPDDataMaker->MakeSDigits(sdigits) ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ fSPDDataMaker->MakeSDigits(sdigits) ;
+ }
if(fSubDetector == 0 || fSubDetector == 2){
- Int_t rv = fSDDDataMaker->MakeSDigits(sdigits) ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
+ fSDDDataMaker->MakeSDigits(sdigits) ;
}
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeSDigits(sdigits);
}
if(fSubDetector == 0 || fSubDetector == 2) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitHits\n");
- fSDDDataMaker->InitHits();
+
+ fSDDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSDDDataMaker->InitHits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitHits\n");
- fSSDDataMaker->InitHits();
+
+ fSSDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSSDDataMaker->InitHits();
}
}
{
// Fill QA for hits
if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeHits() ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ fSPDDataMaker->MakeHits() ;
+ }
if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeHits() ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
+ fSDDDataMaker->MakeHits() ;
}
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeHits();
{
// Fill QA for hits
if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeHits(hits) ;
- if ( rv != 0 )
- fSDDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
- }
+ fSPDDataMaker->MakeHits(hits) ;
+ }
if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeHits(hits) ;
- if ( rv != 0 )
- fSSDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
+ fSDDDataMaker->MakeHits(hits) ;
}
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeHits(hits);
virtual ~AliITSQADataMakerSim(); // dtor
Short_t GetSubDet(){return fSubDetector;};
Int_t GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task);
+ virtual Int_t GetEventSpecie() const { return AliRecoParam::AConvert(fEventSpecie); }
private:
}
fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies];
fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies];
+ fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies];
for(Int_t i=0; i<AliRecoParam::kNSpecies; i++) {
fGenRawsOffset[i] = 0;
fGenRecPointsOffset[i] = 0;
+ fGenDigitsOffset[i]=0;
}
}
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");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h0,fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h0,fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSDDhDigitsTask ++;
+ // printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , 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");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h1,1+fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h1,1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSDDhDigitsTask ++;
+ //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , 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");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h2,2+fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h2,2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSDDhDigitsTask ++;
+ //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , 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");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h3,3+fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h3,3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSDDhDigitsTask ++;
+ //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , fSDDhDigitsTask );
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Digits histograms booked\n",fSDDhDigitsTask));
return rv ;
}
Int_t nmod=i+240;
digits->GetEvent(nmod);
Int_t ndigits = iITSdigits->GetEntries();
- fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset)->Fill(nmod,ndigits);
+ fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->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);
+ fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(iz);
+ fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(ix);
+ fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(sig);
}
}
return rv ;
}
else if(task == AliQAv1::kDIGITSR )
{
- offset=fGenDigitsOffset;
+ offset=fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
}
else if( task == AliQAv1::kRECPOINTS )
{
fGenRawsOffset[specie]=offset;
}
else if( task == AliQAv1::kDIGITSR ) {
- fGenDigitsOffset=offset;
+ fGenDigitsOffset[specie]=offset;
}
else if( task == AliQAv1::kRECPOINTS ) {
fGenRecPointsOffset[specie]=offset;
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 *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
Int_t fBadAnodes;
Int_t fGoodAnodesCurrent;
Int_t fBadAnodesCurrent;
- ClassDef(AliITSQASDDDataMakerRec,8) // description
+ ClassDef(AliITSQASDDDataMakerRec,9) // description
};
fGenOffsetD(0)\r
{\r
//ctor used to discriminate OnLine-Offline analysis \r
+ fGenOffsetH= new Int_t[AliRecoParam::kNSpecies]; \r
+ fGenOffsetS= new Int_t[AliRecoParam::kNSpecies]; \r
+ fGenOffsetD= new Int_t[AliRecoParam::kNSpecies];\r
+ for(Int_t i=0; i<AliRecoParam::kNSpecies; i++) \r
+ {\r
+ fGenOffsetH[i]= 0;\r
+ fGenOffsetS[i]= 0;\r
+ fGenOffsetD[i]= 0;\r
+ } \r
}\r
\r
//____________________________________________________________________________ \r
//copy ctor \r
fAliITSQADataMakerSim->SetName((const char*)qadm.fAliITSQADataMakerSim->GetName()) ; \r
fAliITSQADataMakerSim->SetTitle((const char*)qadm.fAliITSQADataMakerSim->GetTitle());\r
- }\r
+\r
+}\r
\r
//__________________________________________________________________\r
AliITSQASDDDataMakerSim& AliITSQASDDDataMakerSim::operator = (const AliITSQASDDDataMakerSim& qac )\r
TH1F* h0=new TH1F("SDD DIGITS Module Pattern","SDD DIGITS Module Pattern",260,239.5,499.5); //hmod\r
h0->GetXaxis()->SetTitle("SDD Module Number");\r
h0->GetYaxis()->SetTitle("# DIGITS");\r
- rv = fAliITSQADataMakerSim->Add2DigitsList(h0,fGenOffsetD, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2DigitsList(h0,fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhDTask ++;\r
TH1F* h1=new TH1F("SDD Anode Distribution","SDD DIGITS Anode Distribution",512,-0.5,511.5); //hanocc\r
h1->GetXaxis()->SetTitle("Anode Number");\r
h1->GetYaxis()->SetTitle("# DIGITS");\r
- rv = fAliITSQADataMakerSim->Add2DigitsList(h1,1+fGenOffsetD, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2DigitsList(h1,1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhDTask ++;\r
TH1F* h2=new TH1F("SDD Tbin Distribution","SDD DIGITS Tbin Distribution",256,-0.5,255.5); //htbocc\r
h2->GetXaxis()->SetTitle("Tbin Number");\r
h2->GetYaxis()->SetTitle("# DIGITS");\r
- rv = fAliITSQADataMakerSim->Add2DigitsList(h2,2+fGenOffsetD, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2DigitsList(h2,2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhDTask ++;\r
TH1F* h3=new TH1F("SDD ADC Counts Distribution","SDD DIGITS ADC Counts Distribution",200,0.,1024.); //hsig\r
h3->GetXaxis()->SetTitle("ADC Value");\r
h3->GetYaxis()->SetTitle("# DIGITS");\r
- rv = fAliITSQADataMakerSim->Add2DigitsList(h3,3+fGenOffsetD, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2DigitsList(h3,3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhDTask ++;\r
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Digits histograms booked\n",fSDDhDTask));\r
return rv ; \r
Int_t nmod=i+240;\r
digits->GetEvent(nmod);\r
Int_t ndigits = iITSdigits->GetEntries();\r
- fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD)->Fill(nmod,ndigits);\r
+ fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nmod,ndigits);\r
for (Int_t idig=0; idig<ndigits; idig++) {\r
AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);\r
Int_t iz=dig->GetCoord1(); // cell number z\r
Int_t ix=dig->GetCoord2(); // cell number x\r
Int_t sig=dig->GetSignal();\r
- fAliITSQADataMakerSim->GetDigitsData(1+fGenOffsetD)->Fill(iz);\r
- fAliITSQADataMakerSim->GetDigitsData(2+fGenOffsetD)->Fill(ix);\r
- fAliITSQADataMakerSim->GetDigitsData(3+fGenOffsetD)->Fill(sig);\r
+ fAliITSQADataMakerSim->GetDigitsData(1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(iz);\r
+ fAliITSQADataMakerSim->GetDigitsData(2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(ix);\r
+ fAliITSQADataMakerSim->GetDigitsData(3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(sig);\r
}\r
}\r
return rv ; \r
TH1F* h0=new TH1F("SDD SDIGITS Module Pattern","SDIGITS SDD Module Pattern",260,239.5,499.5); //hmod\r
h0->GetXaxis()->SetTitle("SDD Module Number");\r
h0->GetYaxis()->SetTitle("# SDIGITS");\r
- rv = fAliITSQADataMakerSim->Add2SDigitsList(h0,fGenOffsetS, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2SDigitsList(h0,fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhSTask ++;\r
TH1F* h1=new TH1F("SDD Anode Distribution","SDIGITS SDD Anode Distribution",512,-0.5,511.5); //hanocc\r
h1->GetXaxis()->SetTitle("Anode Number");\r
h1->GetYaxis()->SetTitle("# SDIGITS");\r
- rv = fAliITSQADataMakerSim->Add2SDigitsList(h1,1+fGenOffsetS, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2SDigitsList(h1,1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhSTask ++;\r
TH1F* h2=new TH1F("SDD Tbin Distribution","SDIGITS SDD Tbin Distribution",256,-0.5,255.5); //htbocc\r
h2->GetXaxis()->SetTitle("Tbin Number");\r
h2->GetYaxis()->SetTitle("# SDIGITS");\r
- rv = fAliITSQADataMakerSim->Add2SDigitsList(h2,2+fGenOffsetS);\r
+ rv = fAliITSQADataMakerSim->Add2SDigitsList(h2,2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()]);\r
fSDDhSTask ++;\r
TH1F* h3=new TH1F("SDD ADC Counts Distribution","SDIGITS SDD ADC Counts Distribution",200,0.,1024.); //hsig\r
h3->GetXaxis()->SetTitle("ADC Value");\r
h3->GetYaxis()->SetTitle("# SDIGITS");\r
- rv = fAliITSQADataMakerSim->Add2SDigitsList(h3,3+fGenOffsetS, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2SDigitsList(h3,3+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhSTask ++;\r
\r
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD SDigits histograms booked\n",fSDDhSTask));\r
brchSDigits->SetAddress( &sdig );\r
brchSDigits->GetEvent(nmod);\r
Int_t nsdig=sdig->GetEntries();\r
- fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS)->Fill(nmod,nsdig);\r
+ fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nmod,nsdig);\r
for(Int_t i=0;i<nsdig;i++){\r
AliITSpListItem *cell=(AliITSpListItem*)sdig->At(i);\r
Float_t sig=cell->GetSignal();\r
Int_t idx=cell->GetIndex();\r
Int_t ia,it;\r
list->GetCell(idx,ia,it);\r
- fAliITSQADataMakerSim->GetSDigitsData(1+fGenOffsetS)->Fill(ia);\r
- fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS)->Fill(it);\r
- fAliITSQADataMakerSim->GetSDigitsData(3+fGenOffsetS)->Fill(sig);\r
+ fAliITSQADataMakerSim->GetSDigitsData(1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(ia);\r
+ fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(it);\r
+ fAliITSQADataMakerSim->GetSDigitsData(3+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(sig);\r
}\r
sdig->Clear();\r
}\r
TH1F *h0=new TH1F("SDD HITS Module Pattern","SDD HITS Module Pattern",260,239.5,499.5); \r
h0->GetXaxis()->SetTitle("SDD Module Number");\r
h0->GetYaxis()->SetTitle("# HITS");\r
- rv = fAliITSQADataMakerSim->Add2HitsList(h0,fGenOffsetH, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2HitsList(h0,fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhHTask ++;\r
TH1F *h1=new TH1F("SDD HIT lenght along local Y Coord","SDD HIT lenght along local Y Coord",200,0.,350.);\r
h1->GetXaxis()->SetTitle("HIT lenght (um)");\r
h1->GetYaxis()->SetTitle("# HITS");\r
- rv = fAliITSQADataMakerSim->Add2HitsList(h1,1+fGenOffsetH, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2HitsList(h1,1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhHTask ++;\r
TH1F *h2=new TH1F("SDD HIT lenght along local Y Coord - Zoom","SDD HIT lenght along local Y Coord - Zoom",200,250.,350.);\r
h2->GetXaxis()->SetTitle("HIT lenght (um)");\r
h2->GetYaxis()->SetTitle("# HITS");\r
- rv = fAliITSQADataMakerSim->Add2HitsList(h2,2+fGenOffsetH, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2HitsList(h2,2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhHTask ++;\r
TH1F *h3=new TH1F("SDD Deposited Energy Distribution (loc Y > 200um)","SDD HITS Deposited Energy Distribution (loc Y > 200um)",200,0.,350.);\r
h3->GetXaxis()->SetTitle("ADC counts ");\r
h3->GetYaxis()->SetTitle("# HITS");\r
- rv = fAliITSQADataMakerSim->Add2HitsList(h3,3+fGenOffsetH, !expert, image);\r
+ rv = fAliITSQADataMakerSim->Add2HitsList(h3,3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);\r
fSDDhHTask ++;\r
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Hits histograms booked\n",fSDDhHTask));\r
return rv ; \r
////printf("--w--AliITSQASDDDataMakerSim::MakeHits nhits = %d\n",nhits);\r
for (Int_t iHit=0;iHit<nhits;iHit++) {\r
AliITShit *hit = (AliITShit*) arrHits->At(iHit);\r
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH)->Fill(nmod);\r
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nmod);\r
Double_t xl,yl,zl,xl0,yl0,zl0;\r
Double_t tof,tof0;\r
hit->GetPositionL(xl,yl,zl,tof);\r
hit->GetPositionL0(xl0,yl0,zl0,tof0);\r
Float_t dyloc=TMath::Abs(yl-yl0)*10000.;\r
- fAliITSQADataMakerSim->GetHitsData(1+fGenOffsetH)->Fill(dyloc);\r
+ fAliITSQADataMakerSim->GetHitsData(1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(dyloc);\r
Float_t edep=hit->GetIonization()*1000000;\r
if(dyloc>200.){ \r
- fAliITSQADataMakerSim->GetHitsData(2+fGenOffsetH)->Fill(edep);\r
- fAliITSQADataMakerSim->GetHitsData(3+fGenOffsetH)->Fill(dyloc);\r
+ fAliITSQADataMakerSim->GetHitsData(2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(edep);\r
+ fAliITSQADataMakerSim->GetHitsData(3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(dyloc);\r
}\r
}\r
}\r
// Returns histogram offset according to the specified task\r
Int_t offset=0;\r
if( task == AliQAv1::kHITS){\r
- offset=fGenOffsetH; \r
+ offset=fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()]; \r
}\r
else if( task == AliQAv1::kSDIGITS) {\r
- offset=fGenOffsetS; \r
+ offset=fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()]; \r
}\r
else if( task == AliQAv1::kDIGITS) {\r
- offset=fGenOffsetD; \r
+ offset=fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()]; \r
}\r
else {\r
AliInfo("No task has been selected. TaskHisto set to zero.\n");\r
}\r
\r
//____________________________________________________________________________ \r
-void AliITSQASDDDataMakerSim::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset){\r
+void AliITSQASDDDataMakerSim::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset,Int_t specie ){\r
// Returns histogram offset according to the specified task\r
if( task == AliQAv1::kHITS){\r
- fGenOffsetH = offset; \r
+ fGenOffsetH[specie] = offset; \r
}\r
else if( task == AliQAv1::kSDIGITS) {\r
- fGenOffsetS = offset; \r
+ fGenOffsetS[specie] = offset; \r
}\r
else if( task == AliQAv1::kDIGITS) {\r
- fGenOffsetD = offset; \r
+ fGenOffsetD[specie] = offset; \r
}\r
else {\r
AliInfo("No task has been selected. TaskHisto set to zero.\n");\r
virtual Int_t MakeSDigits(TTree * sdigits);\r
virtual Int_t MakeHits(TTree * hits);\r
Int_t GetOffset(AliQAv1::TASKINDEX_t task);\r
- void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset);\r
+ void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset,Int_t specie = 0);\r
Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);\r
\r
private:\r
Int_t fSDDhHTask; //number of booked SDD histograms for each task;\r
Int_t fSDDhSTask; //number of booked SDD histograms for each task;\r
Int_t fSDDhDTask; //number of booked SDD histograms for each task;\r
- Int_t fGenOffsetH; // qachecking offset\r
- Int_t fGenOffsetS; // qachecking offset\r
- Int_t fGenOffsetD; // qachecking offset\r
- ClassDef(AliITSQASDDDataMakerSim,3) // description \r
+ Int_t *fGenOffsetH; // qachecking offset\r
+ Int_t *fGenOffsetS; // qachecking offset\r
+ Int_t *fGenOffsetD; // qachecking offset\r
+ ClassDef(AliITSQASDDDataMakerSim,4) // description \r
\r
};\r
\r
//AliInfo(Form("AliRecoParam::kNSpecies %d\n",AliRecoParam::kNSpecies));
fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies];
fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies];
+ fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies];
for(Int_t i=0; i<AliRecoParam::kNSpecies;i++) {
fGenRawsOffset[i] = 0;
fGenRecPointsOffset[i] = 0;
+ fGenDigitsOffset[i]=0;
}
}
TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
hlayer->GetXaxis()->SetTitle("Layer number");
hlayer->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2DigitsList(hlayer,fGenDigitsOffset, expert, !image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(hlayer,fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
fSPDhDigitsTask++;
TH1F **hmod = new TH1F*[2];
hmod[iLay]=new TH1F(name,title,240,0,240);
hmod[iLay]->GetXaxis()->SetTitle("Module number");
hmod[iLay]->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2DigitsList(hmod[iLay],1+iLay+fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(hmod[iLay],1+iLay+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSPDhDigitsTask++;
}
TH1F *hcolumns = new TH1F("SPDColumns_SPD","Columns - SPD",160,0.,160.);
hcolumns->GetXaxis()->SetTitle("Column number");
hcolumns->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2DigitsList(hcolumns,3+fGenDigitsOffset, expert, !image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(hcolumns,3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
fSPDhDigitsTask++;
TH1F *hrows = new TH1F("SPDRows_SPD","Rows - SPD",256,0.,256.);
hrows->GetXaxis()->SetTitle("Row number");
hrows->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2DigitsList(hrows,4+fGenDigitsOffset, expert, !image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(hrows,4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
fSPDhDigitsTask++;
TH1F** hMultSPDdigits = new TH1F*[2];
hMultSPDdigits[iLay]=new TH1F(name,title,200,0.,200.);
hMultSPDdigits[iLay]->GetXaxis()->SetTitle("Digit multiplicity");
hMultSPDdigits[iLay]->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSPDhDigitsTask++;
}
= 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)");
- rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenDigitsOffset, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
fSPDhDigitsTask++;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Digits histograms booked\n",fSPDhDigitsTask));
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);
+ fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(0.5,ndigits);
+ fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(imod,ndigits);
nDigitsL1+=ndigits;
}
else {
- fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset)->Fill(1,ndigits);
- fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset)->Fill(imod,ndigits);
+ fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(1,ndigits);
+ fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->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(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(col);
+ fAliITSQADataMakerRec->GetDigitsData(4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(row);
}
}
- fAliITSQADataMakerRec->GetDigitsData(5+fGenDigitsOffset)->Fill(nDigitsL1);
- fAliITSQADataMakerRec->GetDigitsData(6+fGenDigitsOffset)->Fill(nDigitsL2);
- fAliITSQADataMakerRec->GetDigitsData(7+fGenDigitsOffset)->Fill(nDigitsL1,nDigitsL2);
+ fAliITSQADataMakerRec->GetDigitsData(5+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL1);
+ fAliITSQADataMakerRec->GetDigitsData(6+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL2);
+ fAliITSQADataMakerRec->GetDigitsData(7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL1,nDigitsL2);
return rv ;
}
offset=fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
}
else if( task == AliQAv1::kDIGITSR ) {
- offset=fGenDigitsOffset;
+ offset=fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
}
else if( task == AliQAv1::kRECPOINTS ) {
offset=fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
}
- else if( task == AliQAv1::kDIGITS ) {
- offset=fGenDigitsOffset;
- }
return offset;
}
fGenRawsOffset[specie]=offset;
}
else if( task == AliQAv1::kDIGITSR ) {
- fGenDigitsOffset=offset;
+ fGenDigitsOffset[specie]=offset;
}
else if( task == AliQAv1::kRECPOINTS ) {
fGenRecPointsOffset[specie]=offset;
else if( task == AliQAv1::kRECPOINTS ){
histotot=fSPDhRecPointsTask;
}
- else if( task == AliQAv1::kDIGITS ){
- histotot=fSPDhDigitsTask;
- }
- else {
- AliInfo("No task has been selected. TaskHisto set to zero.\n");
- }
+
return histotot;
}
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 Digits offset
+ Int_t *fGenDigitsOffset; // QAchecking Digits offset
Int_t *fGenRecPointsOffset; // QAchecking RecPoints offset
AliITSRawStreamSPDErrorLog *fAdvLogger; // pointer to special error logger object
- ClassDef(AliITSQASPDDataMakerRec,5) // description
+ ClassDef(AliITSQASPDDataMakerRec,6) // description
};
fGenOffsetD(0)
{
//ctor used to discriminate OnLine-Offline analysis
+ fGenOffsetH= new Int_t[AliRecoParam::kNSpecies];
+ fGenOffsetS= new Int_t[AliRecoParam::kNSpecies];
+ fGenOffsetD= new Int_t[AliRecoParam::kNSpecies];
+ for(Int_t i=0; i<AliRecoParam::kNSpecies; i++) {
+ fGenOffsetH[i]= 0;
+ fGenOffsetS[i]= 0;
+ fGenOffsetD[i]= 0;
+ }
}
//____________________________________________________________________________
//copy ctor
fAliITSQADataMakerSim->SetName((const char*)qadm.fAliITSQADataMakerSim->GetName()) ;
fAliITSQADataMakerSim->SetTitle((const char*)qadm.fAliITSQADataMakerSim->GetTitle());
- }
+
+}
//__________________________________________________________________
AliITSQASPDDataMakerSim& AliITSQASPDDataMakerSim::operator = (const AliITSQASPDDataMakerSim& qac )
TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
hlayer->GetXaxis()->SetTitle("Layer number");
hlayer->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2DigitsList(hlayer,fGenOffsetD, expert, !image);
+ rv = fAliITSQADataMakerSim->Add2DigitsList(hlayer,fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], expert, !image);
fSPDhDTask++;
TH1F **hmod = new TH1F*[2];
hmod[iLay]=new TH1F(name,title,240,0,240);
hmod[iLay]->GetXaxis()->SetTitle("Module number");
hmod[iLay]->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2DigitsList(hmod[iLay],1+iLay+fGenOffsetD, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2DigitsList(hmod[iLay],1+iLay+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhDTask++;
}
TH1F *hcolumns = new TH1F("SPDColumns_SPD","Columns - SPD",160,0.,160.);
hcolumns->GetXaxis()->SetTitle("Column number");
hcolumns->GetYaxis()->SetTitle("Entries");
- fAliITSQADataMakerSim->Add2DigitsList(hcolumns,3+fGenOffsetD, expert, !image);
+ fAliITSQADataMakerSim->Add2DigitsList(hcolumns,3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], expert, !image);
fSPDhDTask++;
TH1F *hrows = new TH1F("SPDRows_SPD","Rows - SPD",256,0.,256.);
hrows->GetXaxis()->SetTitle("Row number");
hrows->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2DigitsList(hrows,4+fGenOffsetD, expert, !image);
+ rv = fAliITSQADataMakerSim->Add2DigitsList(hrows,4+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], expert, !image);
fSPDhDTask++;
TH1F** hMultSPDdigits = new TH1F*[2];
hMultSPDdigits[iLay]=new TH1F(name,title,200,0.,200.);
hMultSPDdigits[iLay]->GetXaxis()->SetTitle("Digit multiplicity");
hMultSPDdigits[iLay]->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenOffsetD, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhDTask++;
}
= 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)");
- rv = fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenOffsetD, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhDTask++;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Digits histograms booked\n",fSPDhDTask));
digits->GetEvent(imod);
Int_t ndigits = iITSdigits->GetEntries();
if (imod<80) {
- fAliITSQADataMakerSim->GetDigitsData(0+fGenOffsetD)->Fill(0.5,ndigits);
- fAliITSQADataMakerSim->GetDigitsData(1+fGenOffsetD)->Fill(imod,ndigits);
+ fAliITSQADataMakerSim->GetDigitsData(0+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(0.5,ndigits);
+ fAliITSQADataMakerSim->GetDigitsData(1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,ndigits);
nDigitsL1+=ndigits;
}
else {
- fAliITSQADataMakerSim->GetDigitsData(0+fGenOffsetD)->Fill(1,ndigits);
- fAliITSQADataMakerSim->GetDigitsData(2+fGenOffsetD)->Fill(imod,ndigits);
+ fAliITSQADataMakerSim->GetDigitsData(0+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(1,ndigits);
+ fAliITSQADataMakerSim->GetDigitsData(2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->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
- fAliITSQADataMakerSim->GetDigitsData(3+fGenOffsetD)->Fill(col);
- fAliITSQADataMakerSim->GetDigitsData(4+fGenOffsetD)->Fill(row);
+ fAliITSQADataMakerSim->GetDigitsData(3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(col);
+ fAliITSQADataMakerSim->GetDigitsData(4+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(row);
}
}
- fAliITSQADataMakerSim->GetDigitsData(5+fGenOffsetD)->Fill(nDigitsL1);
- fAliITSQADataMakerSim->GetDigitsData(6+fGenOffsetD)->Fill(nDigitsL2);
- fAliITSQADataMakerSim->GetDigitsData(7+fGenOffsetD)->Fill(nDigitsL1,nDigitsL2);
+ fAliITSQADataMakerSim->GetDigitsData(5+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nDigitsL1);
+ fAliITSQADataMakerSim->GetDigitsData(6+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nDigitsL2);
+ fAliITSQADataMakerSim->GetDigitsData(7+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nDigitsL1,nDigitsL2);
return rv ;
}
TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
hlayer->GetXaxis()->SetTitle("Layer number");
hlayer->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2SDigitsList(hlayer,fGenOffsetS, expert, !image);
+ rv = fAliITSQADataMakerSim->Add2SDigitsList(hlayer,fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()], expert, !image);
fSPDhSTask++;
TH1F **hmod = new TH1F*[2];
hmod[iLay]=new TH1F(name,title,240,0,240);
hmod[iLay]->GetXaxis()->SetTitle("Module number");
hmod[iLay]->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2SDigitsList(hmod[iLay],1+iLay+fGenOffsetS, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2SDigitsList(hmod[iLay],1+iLay+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhSTask++;
}
brchSDigits->GetEvent(imod);
Int_t nsdig=sdig->GetEntries();
if (imod<80) {
- fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS)->Fill(0.5,nsdig);
- fAliITSQADataMakerSim->GetSDigitsData(1+fGenOffsetS)->Fill(imod,nsdig);
+ fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(0.5,nsdig);
+ fAliITSQADataMakerSim->GetSDigitsData(1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nsdig);
}
else {
- fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS)->Fill(1,nsdig);
- fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS)->Fill(imod,nsdig);
+ fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(1,nsdig);
+ fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nsdig);
}
sdig->Clear() ;
}
TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
hlayer->GetXaxis()->SetTitle("Layer number");
hlayer->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2HitsList(hlayer,fGenOffsetH, expert, !image);
+ rv = fAliITSQADataMakerSim->Add2HitsList(hlayer,fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], expert, !image);
fSPDhHTask++;
TH1F **hmod = new TH1F*[2];
hmod[iLay]=new TH1F(name,title,240,0,240);
hmod[iLay]->GetXaxis()->SetTitle("Module number");
hmod[iLay]->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerSim->Add2HitsList(hmod[iLay],1+iLay+fGenOffsetH, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2HitsList(hmod[iLay],1+iLay+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhHTask++;
}
TH1F *hhitlenght = new TH1F("SPDLenght_SPD","SPD Hit lenght along y_{loc} coord",210,0.,210.);
hhitlenght->GetXaxis()->SetTitle("Hit lenght [#mum]");
hhitlenght->GetYaxis()->SetTitle("# hits");
- rv = fAliITSQADataMakerSim->Add2HitsList(hhitlenght,3+fGenOffsetH, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2HitsList(hhitlenght,3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhHTask++;
TH1F *hEdepos = new TH1F("SPDEnergyDeposit_SPD","SPD Deposited energy distribution (y_{loc}>180 #mum)",150,0.,300.);
hEdepos->GetXaxis()->SetTitle("Deposited energy [keV]");
hEdepos->GetYaxis()->SetTitle("# hits");
- rv = fAliITSQADataMakerSim->Add2HitsList(hEdepos,4+fGenOffsetH, !expert, image);
+ rv = fAliITSQADataMakerSim->Add2HitsList(hEdepos,4+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()], !expert, image);
fSPDhHTask++;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Hits histograms booked\n",fSPDhHTask));
TObjArray *arrHits = module->GetHits();
Int_t nhits = arrHits->GetEntriesFast();
if (imod<80) {
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH)->Fill(0.5,nhits);
- fAliITSQADataMakerSim->GetHitsData(1+fGenOffsetH)->Fill(imod,nhits);
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(0.5,nhits);
+ fAliITSQADataMakerSim->GetHitsData(1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nhits);
} else {
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH)->Fill(1,nhits);
- fAliITSQADataMakerSim->GetHitsData(2+fGenOffsetH)->Fill(imod,nhits);
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(1,nhits);
+ fAliITSQADataMakerSim->GetHitsData(2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nhits);
}
for (Int_t iHit=0; iHit<nhits; ++iHit) {
AliITShit *hit = (AliITShit*) arrHits->At(iHit);
hit->GetPositionL(xl,yl,zl,tof);
hit->GetPositionL0(xl0,yl0,zl0,tof0);
Float_t dyloc=TMath::Abs(yl-yl0)*10000.;
- fAliITSQADataMakerSim->GetHitsData(3+fGenOffsetH)->Fill(dyloc);
+ fAliITSQADataMakerSim->GetHitsData(3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(dyloc);
Float_t edep=hit->GetIonization()*1000000;
if(dyloc>180.){
- fAliITSQADataMakerSim->GetHitsData(4+fGenOffsetH)->Fill(edep);
+ fAliITSQADataMakerSim->GetHitsData(4+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(edep);
}
}
}
// Returns histogram offset according to the specified task
Int_t offset=0;
if( task == AliQAv1::kHITS){
- offset=fGenOffsetH;
+ offset=fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()];
}
else if( task == AliQAv1::kSDIGITS) {
- offset=fGenOffsetS;
+ offset=fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()];
}
else if( task == AliQAv1::kDIGITS) {
- offset=fGenOffsetD;
+ offset=fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()];
}
else {
AliInfo("No task has been selected. TaskHisto set to zero.\n");
}
//____________________________________________________________________________
-void AliITSQASPDDataMakerSim::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset){
+void AliITSQASPDDataMakerSim::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset,Int_t specie ){
// Returns histogram offset according to the specified task
if( task == AliQAv1::kHITS){
- fGenOffsetH = offset;
+ fGenOffsetH[specie] = offset;
}
else if( task == AliQAv1::kSDIGITS) {
- fGenOffsetS = offset;
+ fGenOffsetS[specie] = offset;
}
else if( task == AliQAv1::kDIGITS) {
- fGenOffsetD = offset;
+ fGenOffsetD[specie] = offset;
}
else {
AliInfo("No task has been selected. TaskHisto set to zero.\n");
virtual Int_t MakeSDigits(TTree * sdigits);
virtual Int_t MakeHits(TTree * hits);
Int_t GetOffset(AliQAv1::TASKINDEX_t task);
- void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset);
+ void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset,Int_t specie = 0);
Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
//Int_t GetOffsetH() { return fGenOffsetH; }
//Int_t GetOffsetS() { return fGenOffsetS; }
Int_t fSPDhHTask; // number of booked SPD histograms for each task;
Int_t fSPDhSTask; // number of booked SPD histograms for each task;
Int_t fSPDhDTask; // number of booked SPD histograms for each task;
- Int_t fGenOffsetH; // qachecking offset
- Int_t fGenOffsetS; // qachecking offset
- Int_t fGenOffsetD; // qachecking offset
- ClassDef(AliITSQASPDDataMakerSim,3) // description
+ Int_t *fGenOffsetH; // qachecking offset
+ Int_t *fGenOffsetS; // qachecking offset
+ Int_t *fGenOffsetD; // qachecking offset
+ ClassDef(AliITSQASPDDataMakerSim,4) // description
};
//initilize the raw signal vs strip number histograms
fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies];
fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies];
+ fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies];
for(Int_t i=0; i<AliRecoParam::kNSpecies; i++) {
fGenRawsOffset[i] = 0;
fGenRecPointsOffset[i] = 0;
+ fGenDigitsOffset[i]=0;
}
if(fkOnline) {
fCDBManager = AliCDBManager::Instance();
void AliITSQASSDDataMakerRec::StartOfDetectorCycle()
{
- if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
- return ;
-
- //Detector specific actions at start of cycle
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SSD Cycle\n");
-
- //Data size per DDL
- ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+4)))->Reset();
- //Data size per LDC
- ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+22)))->Reset();
-
- //online part
- if(fkOnline) {
- for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
- for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)
- fOccupancyMatrix[iModule-500][iStrip] = 0;
- }//module loop
-
- Int_t gHistPositionOccupancyPerLadder = 0;
- Int_t gLayer = 0, gLadder = 0, gModule = 0;
- for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
- AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
-
- gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
-
- //P-SIDE OCCUPANCY
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset();
- //N-SIDE OCCUPANCY
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset();
-
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->Reset();
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->Reset();
- }//module loop
- }//online flag
+ if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
+ return ;
+
+ //Detector specific actions at start of cycle
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SSD Cycle\n");
+
+ //Data size per DDL
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+4)))->Reset();
+ //Data size per LDC
+ ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+22)))->Reset();
+
+ //online part
+ if(fkOnline) {
+ for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
+ for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)
+ fOccupancyMatrix[iModule-500][iStrip] = 0;
+ }//module loop
+
+ Int_t gHistPositionOccupancyPerLadder = 0;
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
+ AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
+
+ gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
+
+ //P-SIDE OCCUPANCY
+ fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset();
+ //N-SIDE OCCUPANCY
+ fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset();
+
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->Reset();
+ ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->Reset();
+ }//module loop
+ }//online flag
+
}
//____________________________________________________________________________
";SSD Module Number;N_{DIGITS}",
1698,499.5,2197.5);
rv = fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModule,
- fGenDigitsOffset + 0, !expert, image);
+ fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0, !expert, image);
fSSDhDigitsTask += 1;
TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
";N_{Strip};N_{Module}",
1540,0,1540,1698,499.5,2197.5);
rv = fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModuleStrip,
- fGenDigitsOffset + 1, !expert, image);
+ fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1, !expert, image);
fSSDhDigitsTask += 1;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Digits histograms booked\n",fSSDhDigitsTask));
iSSDdigits->Clear();
digits->GetEvent(iModule);
Int_t ndigits = iSSDdigits->GetEntries();
- fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset + 0)->Fill(iModule,ndigits);
+ //printf("Module = %i \t ndigits = %i\t offset = %i \n",iModule,ndigits,fAliITSQADataMakerRec->GetEventSpecie() );
+ fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 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());
+ ((TH2F *)fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
}//digit loop
}//module loop
return rv ;
offset=fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
}
else if( task == AliQAv1::kDIGITSR ) {
- offset=fGenDigitsOffset;
+ offset=fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
}
else if( task == AliQAv1::kRECPOINTS ) {
offset=fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
fGenRawsOffset[specie]=offset;
}
else if( task == AliQAv1::kDIGITSR ) {
- fGenDigitsOffset=offset;
+ fGenDigitsOffset[specie]=offset;
}
else if( task == AliQAv1::kRECPOINTS ) {
fGenRecPointsOffset[specie]=offset;
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 *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
AliCDBManager *fCDBManager; //CDB manager
- ClassDef(AliITSQASSDDataMakerRec,6) // description
+ ClassDef(AliITSQASSDDataMakerRec,7) // description
};
#endif
fGenOffsetS(0),
fGenOffsetD(0)
{
- //ctor used to discriminate OnLine-Offline analysis
+ //ctor used to discriminate OnLine-Offline analysis
+ fGenOffsetH= new Int_t[AliRecoParam::kNSpecies];
+ fGenOffsetS= new Int_t[AliRecoParam::kNSpecies];
+ fGenOffsetD= new Int_t[AliRecoParam::kNSpecies];
+ for(Int_t i=0; i<AliRecoParam::kNSpecies; i++)
+ {
+ fGenOffsetH[i]= 0;
+ fGenOffsetS[i]= 0;
+ fGenOffsetD[i]= 0;
+ }
}
//____________________________________________________________________________
"SSD Digits Module;SSD Module Number;N_{DIGITS}",
1698,499.5,2197.5);
rv = fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModule,
- fGenOffsetD + 0, !expert, image);
+ fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 0, !expert, image);
fSSDhDTask += 1;
TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
"SSD Digits Module Strip;N_{Strip};N_{Module}",
1540,0,1540,1698,499.5,2197.5);
rv = fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModuleStrip,
- fGenOffsetD + 1, !expert, image);
+ fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 1, !expert, image);
fSSDhDTask += 1;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Digits histograms booked\n",fSSDhDTask));
iSSDdigits->Clear();
digits->GetEvent(iModule);
Int_t ndigits = iSSDdigits->GetEntries();
- fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD + 0)->Fill(iModule,ndigits);
+ fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 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 *)fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
+ ((TH2F *)fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
}//digit loop
}//module loop
return rv ;
"SSD SDigits Module;SSD Module Number;N_{SDIGITS}",
1698,499.5,2197.5);
rv = fAliITSQADataMakerSim->Add2SDigitsList(fHistSSDModule,
- fGenOffsetS + 0, !expert, image);
+ fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()] + 0, !expert, image);
fSSDhSTask += 1;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD SDigits histograms booked\n",fSSDhSTask));
iSSDsdigits->Clear();
sdigits->GetEvent(iModule);
Int_t ndigits = iSSDsdigits->GetEntries();
- fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS + 0)->Fill(iModule,ndigits);
+ fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()] + 0)->Fill(iModule,ndigits);
if(ndigits != 0)
AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
"SSD Hits Module;SDD Module Number;N_{HITS}",
1698,499.5,2197.5);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDModule,
- fGenOffsetH + 0, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 0, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDGlobalX = new TH1F("fHistSSDHitsGlobalX",
"SSD Hits Global X;x [cm];Entries",
1000,-50.,50.);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalX,
- fGenOffsetH + 1, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 1, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDGlobalY = new TH1F("fHistSSDHitsGlobalY",
"SSD Hits Global Y;y [cm];Entries",
1000,-50.,50.);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalY,
- fGenOffsetH + 2, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 2, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDGlobalZ = new TH1F("fHistSSDHitsGlobalZ",
"SSD Hits Global Z ;z [cm];Entries",
1000,-60.,60.);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalZ,
- fGenOffsetH + 3, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 3, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDLocalX = new TH1F("fHistSSDHitsLocalX",
"SSD Hits Local X;x [cm];Entries",
1000,-4.,4.);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalX,
- fGenOffsetH + 4, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 4, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDLocalY = new TH1F("fHistSSDHitsLocalY",
"SSD Hits Local Y;y [cm];Entries",
1000,-0.1,0.1);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalY,
- fGenOffsetH + 5, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 5, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDLocalZ = new TH1F("fHistSSDHitsLocalZ",
"SSD Hits Local Z;z [cm];Entries",
1000,-4.,4.);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalZ,
- fGenOffsetH + 6, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 6, !expert, image);
fSSDhHTask += 1;
TH1F *fHistSSDIonization = new TH1F("fHistSSDHitsIonization",
"SSD Hits Ionization;log(dE/dx) [KeV];N_{Hits}",
100,-7,-2);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDIonization,
- fGenOffsetH + 7, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 7, !expert, image);
fSSDhHTask += 1;
TH2F *fHistSSDGlobalXY = new TH2F("fHistSSDHitsGlobalXY",
"SSD Hits Global XY;x [cm];y [cm]",
1000,-50.,50.,
1000,-50.,50.);
rv = fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalXY,
- fGenOffsetH + 8, !expert, image);
+ fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 8, !expert, image);
fSSDhHTask += 1;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Hits histograms booked\n",fSSDhHTask));
for (Int_t iHit = 0; iHit < nhits; iHit++) {
AliITShit *hit = (AliITShit*) arrHits->At(iHit);
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 0)->Fill(iModule);
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 1)->Fill(hit->GetXG());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 2)->Fill(hit->GetYG());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 3)->Fill(hit->GetZG());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 4)->Fill(hit->GetXL());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 5)->Fill(hit->GetYL());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 6)->Fill(hit->GetZL());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 0)->Fill(iModule);
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 1)->Fill(hit->GetXG());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 2)->Fill(hit->GetYG());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 3)->Fill(hit->GetZG());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 4)->Fill(hit->GetXL());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 5)->Fill(hit->GetYL());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 6)->Fill(hit->GetZL());
if(hit->GetIonization())
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 7)->Fill(TMath::Log10(hit->GetIonization()));
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH + 8)->Fill(hit->GetXG(),hit->GetYG());
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 7)->Fill(TMath::Log10(hit->GetIonization()));
+ fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 8)->Fill(hit->GetXG(),hit->GetYG());
}//hit loop
}//module loop
return rv ;
// Returns histogram offset according to the specified task
Int_t offset=0;
if( task == AliQAv1::kHITS){
- offset=fGenOffsetH;
+ offset=fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()];
}
else if( task == AliQAv1::kSDIGITS) {
- offset=fGenOffsetS;
+ offset=fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()];
}
else if( task == AliQAv1::kDIGITS) {
- offset=fGenOffsetD;
+ offset=fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()];
}
else {
AliInfo("No task has been selected. TaskHisto set to zero.\n");
//____________________________________________________________________________
-void AliITSQASSDDataMakerSim::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset){
+void AliITSQASSDDataMakerSim::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset,Int_t specie ){
// Returns histogram offset according to the specified task
if( task == AliQAv1::kHITS){
- fGenOffsetH = offset;
+ fGenOffsetH[specie] = offset;
}
else if( task == AliQAv1::kSDIGITS) {
- fGenOffsetS = offset;
+ fGenOffsetS[specie] = offset;
}
else if( task == AliQAv1::kDIGITS) {
- fGenOffsetD = offset;
+ fGenOffsetD[specie] = offset;
}
else {
AliInfo("No task has been selected. TaskHisto set to zero.\n");
virtual Int_t MakeSDigits(TTree * sdigits);
virtual Int_t MakeHits(TTree * hits);
Int_t GetOffset(AliQAv1::TASKINDEX_t task);
- void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset);
+ void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset,Int_t specie = 0);
Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
private:
Int_t fSSDhHTask; //number of booked SSD histograms for the hit task;
Int_t fSSDhSTask; //number of booked SSD histograms for the sdigits task;
Int_t fSSDhDTask; //number of booked SSD histograms for the digit task;
- Int_t fGenOffsetH; // qachecking offset hits
- Int_t fGenOffsetS; // qachecking offset sdigits
- Int_t fGenOffsetD; // qachecking offset digits
+ Int_t *fGenOffsetH; // qachecking offset hits
+ Int_t *fGenOffsetS; // qachecking offset sdigits
+ Int_t *fGenOffsetD; // qachecking offset digits
static const Int_t fgkNumberOfPSideStrips = 768; //number of P-side strips
- ClassDef(AliITSQASSDDataMakerSim,2) // description
+ ClassDef(AliITSQASSDDataMakerSim,3) // description
};
#endif