{
//fills QA histos for RAW
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
-
rawReader->Reset();
AliACORDERawStream rawStream(rawReader);
size_t contSingle=0;
void AliACORDEQADataMakerRec::MakeDigits( TTree *digitsTree)
{
//fills QA histos for Digits
- TClonesArray * digits = new TClonesArray("AliACORDEdigit",1000);
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliACORDEdigit",1000);
TBranch * branch = digitsTree->GetBranch("ACORDEdigit");
if (!branch) {
AliWarning("ACORDE branch in Digits Tree not found");
} else {
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- branch->SetAddress(&digits);
+ branch->SetAddress(&fDigitsArray);
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);
+ for(Int_t idigit = 0 ; idigit < fDigitsArray->GetEntriesFast() ; idigit++) {
+ AliACORDEdigit *AcoDigit = (AliACORDEdigit*) fDigitsArray->UncheckedAt(idigit);
if (!AcoDigit) {
AliError("The unchecked digit doesn't exist");
continue ;
{
//fills QA histos for ESD
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
-
AliESDACORDE * fESDACORDE= esd->GetACORDEData();
Int_t *fACORDEMultiMuon =fESDACORDE->GetACORDEMultiMuon();
Int_t *fACORDESingleMuon=fESDACORDE->GetACORDESingleMuon();
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 MakeDigits() {} //Dummy for the moment
virtual void InitRecPoints(); //book cluster QA histo
virtual void InitESDs() ; //book ESD QA histo
virtual void MakeRaws(AliRawReader* rawReader) ;
{
// Here we fill the QA histos for Hits declared above
- TClonesArray * hits = new TClonesArray("AliACORDEhit",1000);
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliACORDEhit",1000);
TBranch * branch = hitTree->GetBranch("ACORDE");
if (!branch) {
AliWarning("ACORDE branch in Hit Tree not found");
} else {
-
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
- branch->SetAddress(&hits);
+ branch->SetAddress(&fHitsArray);
for(Int_t track = 0 ; track < branch->GetEntries() ; track++) {
branch->GetEntry(track);
- for(Int_t ihit=0 ; ihit < hits->GetEntriesFast() ; ihit++) {
- AliACORDEhit *AcoHit = (AliACORDEhit*) hits->UncheckedAt(ihit);
+ for(Int_t ihit=0 ; ihit < fHitsArray->GetEntriesFast() ; ihit++) {
+ AliACORDEhit *AcoHit = (AliACORDEhit*) fHitsArray->UncheckedAt(ihit);
if(!AcoHit) {
AliError("The unchecked hit doesn't exist");
continue ;
void AliACORDEQADataMakerSim::MakeDigits( TTree *digitsTree)
{
//fills QA histos for Digits
- TClonesArray * digits = new TClonesArray("AliACORDEdigit",1000);
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliACORDEdigit",1000);
+
TBranch * branch = digitsTree->GetBranch("ACORDEdigit");
if (!branch) {
AliWarning("ACORDE branch in Digits Tree not found");
} else {
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- branch->SetAddress(&digits);
+ branch->SetAddress(&fDigitsArray);
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);
+ for(Int_t idigit = 0 ; idigit < fDigitsArray->GetEntriesFast() ; idigit++) {
+ AliACORDEdigit *AcoDigit = (AliACORDEdigit*) fDigitsArray->UncheckedAt(idigit);
if (!AcoDigit) {
AliError("The unchecked digit doesn't exist");
continue ;
virtual void InitHits() ; //book hit QA histo
virtual void InitDigits() ; //book Digit QA histo
virtual void MakeHits(TTree * hits) ; //Fill hit QA histo
- virtual void MakeHits(TClonesArray *) {} //Dummy for the moment
+ virtual void MakeHits() {} //Dummy for the moment
virtual void MakeDigits(TTree* digitsTree) ; //Fill Digit QA histo
- virtual void MakeDigits(TClonesArray *) {} //Dummy for the moment
+ virtual void MakeDigits() {} //Dummy for the moment
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliACORDEQADataMakerSim,1) // description
{
// make QA data from ESDs
-
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(kESDCaloClusE) )
- InitESDs() ;
-
Int_t nTot = 0 ;
for ( Int_t index = 0; index < esd->GetNumberOfCaloClusters() ; index++ ) {
AliESDCaloCluster * clu = esd->GetCaloCluster(index) ;
// look at max vs min of the signal spextra, a la online usage in
// AliCaloCalibPedestal
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(kSigLG) )
- InitRaws() ;
-
rawReader->Reset() ;
AliCaloRawStreamV3 in(rawReader,"EMCAL");
}
//____________________________________________________________________________
-void AliEMCALQADataMakerRec::MakeDigits(TClonesArray * digits)
+void AliEMCALQADataMakerRec::MakeDigits()
{
// makes data from Digits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
- GetDigitsData(1)->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
+ GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
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) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
TBranch * branch = digitTree->GetBranch("EMCAL") ;
if ( ! branch ) {
AliWarning("EMCAL branch in Digit Tree not found") ;
} else {
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
AliError("can't get the branch with the EMCAL clusters !");
return;
}
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(kRecPM) )
- InitRecPoints() ;
TObjArray * emcrecpoints = new TObjArray(100) ;
emcbranch->SetAddress(&emcrecpoints);
virtual void InitRecPoints() ;
virtual void InitRaws() ;
virtual void MakeESDs(AliESDEvent * esd) ;
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * digTree) ;
virtual void MakeRecPoints(TTree * recpoTree) ;
virtual void MakeRaws(AliRawReader* rawReader) ;
}
//____________________________________________________________________________
-void AliEMCALQADataMakerSim::MakeHits(TClonesArray * hits)
+void AliEMCALQADataMakerSim::MakeHits()
{
//make QA data from Hits
-
-
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
- GetHitsData(1)->Fill(hits->GetEntriesFast()) ;
- TIter next(hits) ;
+
+ GetHitsData(1)->Fill(fHitsArray->GetEntriesFast()) ;
+ TIter next(fHitsArray) ;
AliEMCALHit * hit ;
while ( (hit = dynamic_cast<AliEMCALHit *>(next())) ) {
GetHitsData(0)->Fill( hit->GetEnergy()) ;
{
// make QA data from Hit Tree
- TClonesArray * hits = new TClonesArray("AliEMCALHit", 1000);
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliEMCALHit", 1000);
TBranch * branch = hitTree->GetBranch("EMCAL") ;
if ( ! branch ) {
AliWarning("EMCAL branch in Hit Tree not found") ;
} else {
- TClonesArray * tmp = new TClonesArray("AliEMCALHit", 1000) ;
- branch->SetAddress(&tmp) ;
- Int_t index = 0 ;
+ branch->SetAddress(&fHitsArray) ;
for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
branch->GetEntry(ientry) ;
- for (Int_t ihit = 0 ; ihit < tmp->GetEntries() ; ihit++) {
- AliEMCALHit * hit = dynamic_cast<AliEMCALHit *> (tmp->At(ihit)) ;
- new((*hits)[index]) AliEMCALHit(*hit) ;
- index++ ;
- }
- }
- tmp->Delete() ;
- delete tmp ;
- MakeHits(hits) ;
+ MakeHits() ;
+ fHitsArray->Clear() ;
+ }
}
}
//____________________________________________________________________________
-void AliEMCALQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliEMCALQADataMakerSim::MakeDigits()
{
// makes data from Digits
-
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- GetDigitsData(1)->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
+
+ GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
AliEMCALDigit * digit ;
while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) {
GetDigitsData(0)->Fill( digit->GetAmp()) ;
void AliEMCALQADataMakerSim::MakeDigits(TTree * digitTree)
{
// makes data from Digit Tree
- TClonesArray * digits = new TClonesArray("AliEMCALDigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
TBranch * branch = digitTree->GetBranch("EMCAL") ;
if ( ! branch ) {
AliWarning("EMCAL branch in Digit Tree not found") ;
} else {
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
//____________________________________________________________________________
-void AliEMCALQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliEMCALQADataMakerSim::MakeSDigits()
{
// makes data from SDigits
//Need a copy of the SDigitizer to calibrate the sdigit amplitude to
//energy in GeV
-
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
-
+
AliEMCALSDigitizer* sDigitizer = new AliEMCALSDigitizer();
- GetSDigitsData(1)->Fill(sdigits->GetEntriesFast()) ;
- TIter next(sdigits) ;
+ GetSDigitsData(1)->Fill(fSDigitsArray->GetEntriesFast()) ;
+ TIter next(fSDigitsArray) ;
AliEMCALDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliEMCALDigit *>(next())) ) {
GetSDigitsData(0)->Fill( sDigitizer->Calibrate(sdigit->GetAmp())) ;
void AliEMCALQADataMakerSim::MakeSDigits(TTree * sdigitTree)
{
// makes data from SDigit Tree
- TClonesArray * sdigits = new TClonesArray("AliEMCALDigit", 1000) ;
+ if (fSDigitsArray)
+ fSDigitsArray->Clear() ;
+ else
+ fSDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
TBranch * branch = sdigitTree->GetBranch("EMCAL") ;
if ( ! branch ) {
AliWarning("EMCAL branch in SDigit Tree not found") ;
} else {
- branch->SetAddress(&sdigits) ;
+ branch->SetAddress(&fSDigitsArray) ;
branch->GetEntry(0) ;
- MakeSDigits(sdigits) ;
+ MakeSDigits() ;
}
}
virtual void InitHits() ;
virtual void InitDigits() ;
virtual void InitSDigits() ;
- virtual void MakeHits(TClonesArray * hits) ;
+ virtual void MakeHits() ;
virtual void MakeHits(TTree * hitTree) ;
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * digitTree) ;
- virtual void MakeSDigits(TClonesArray * sigits) ;
+ virtual void MakeSDigits() ;
virtual void MakeSDigits(TTree * sigitTree) ;
virtual void StartOfDetectorCycle() ;
AliFMDQADataMakerRec::AliFMDQADataMakerRec() :
AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD),
"FMD Quality Assurance Data Maker"),
- fDigitsArray("AliFMDDigit", 0),
fRecPointsArray("AliFMDRecPoint", 1000)
{
// ctor
AliFMDQADataMakerRec::AliFMDQADataMakerRec(const AliFMDQADataMakerRec& qadm)
: AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kFMD),
"FMD Quality Assurance Data Maker"),
- fDigitsArray(qadm.fDigitsArray),
fRecPointsArray(qadm.fRecPointsArray)
{
// copy ctor
//_____________________________________________________________________
AliFMDQADataMakerRec& AliFMDQADataMakerRec::operator = (const AliFMDQADataMakerRec& qadm )
{
- fDigitsArray = qadm.fDigitsArray;
fRecPointsArray = qadm.fRecPointsArray;
return *this;
AliESDFMD* fmd = esd->GetFMDData();
if (!fmd) return;
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
-
for(UShort_t det=1;det<=3;det++) {
for (UShort_t ir = 0; ir < 2; ir++) {
Char_t ring = (ir == 0 ? 'I' : 'O');
//_____________________________________________________________________
-void AliFMDQADataMakerRec::MakeDigits(TClonesArray * digits)
+void AliFMDQADataMakerRec::MakeDigits()
{
// makes data from Digits
- if(!digits) {
+ if(!fDigitsArray) {
AliError("FMD Digit object not found!!") ;
return;
}
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- for(Int_t i=0;i<digits->GetEntriesFast();i++) {
+ for(Int_t i=0;i<fDigitsArray->GetEntriesFast();i++) {
//Raw ADC counts
- AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
+ AliFMDDigit* digit = static_cast<AliFMDDigit*>(fDigitsArray->At(i));
GetDigitsData(0)->Fill(digit->Counts());
}
}
void AliFMDQADataMakerRec::MakeDigits(TTree * digitTree)
{
- fDigitsArray.Clear();
+ if (fDigitsArray)
+ fDigitsArray->Clear();
+ else
+ fDigitsArray = new TClonesArray("AliFMDDigit", 1000);
+
TBranch* branch = digitTree->GetBranch("FMD");
if (!branch) {
AliWarning("FMD branch in Digit Tree not found") ;
return;
}
- TClonesArray* digitsAddress = &fDigitsArray;
- branch->SetAddress(&digitsAddress);
+ branch->SetAddress(&fDigitsArray);
branch->GetEntry(0);
- MakeDigits(digitsAddress);
+ MakeDigits();
}
//_____________________________________________________________________
void AliFMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
+ AliFMDRawReader fmdReader(rawReader,0);
+
+ if (fDigitsArray)
+ fDigitsArray->Clear();
+ else
+ fDigitsArray = new TClonesArray("AliFMDDigit", 1000);
- AliFMDRawReader fmdReader(rawReader,0);
- TClonesArray* digitsAddress = &fDigitsArray;
+ TClonesArray* digitsAddress = fDigitsArray;
rawReader->Reset();
{
// makes data from RecPoints
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(0) )
- InitRecPoints() ;
-
- AliFMDParameters* pars = AliFMDParameters::Instance();
+ AliFMDParameters* pars = AliFMDParameters::Instance();
fRecPointsArray.Clear();
TBranch *fmdbranch = clustersTree->GetBranch("FMD");
if (!fmdbranch) {
virtual void InitRecPoints();
virtual void InitRaws();
virtual void MakeESDs(AliESDEvent * esd);
- virtual void MakeDigits(TClonesArray * digits);
+ virtual void MakeDigits();
virtual void MakeDigits(TTree * digitTree);
virtual void MakeRecPoints(TTree * recpoTree);
virtual void MakeRaws(AliRawReader* rawReader);
virtual void StartOfDetectorCycle();
Int_t GetHalfringIndex(UShort_t det, Char_t ring, UShort_t board, UShort_t monitor = 0);
ClassDef(AliFMDQADataMakerRec,0) // description
- TClonesArray fDigitsArray;
TClonesArray fRecPointsArray;
};
//_____________________________________________________________________
AliFMDQADataMakerSim::AliFMDQADataMakerSim()
: AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kFMD),
- "FMD Quality Assurance Data Maker"),
- fSDigitsArray("AliFMDSDigit", 1000),
- fDigitsArray("AliFMDDigit", 1000),
- fHitsArray("AliFMDHit", 10)
+ "FMD Quality Assurance Data Maker")
{
// ctor
//_____________________________________________________________________
AliFMDQADataMakerSim::AliFMDQADataMakerSim(const AliFMDQADataMakerSim& qadm)
- : AliQADataMakerSim(),
- fSDigitsArray(qadm.fSDigitsArray),
- fDigitsArray(qadm.fDigitsArray),
- fHitsArray(qadm.fHitsArray)
+ : AliQADataMakerSim()
{
//copy ctor
}
//_____________________________________________________________________
-AliFMDQADataMakerSim& AliFMDQADataMakerSim::operator = (const AliFMDQADataMakerSim& qadm )
+AliFMDQADataMakerSim& AliFMDQADataMakerSim::operator = (const AliFMDQADataMakerSim& )
{
- fSDigitsArray = qadm.fSDigitsArray;
- fDigitsArray = qadm.fDigitsArray;
- fHitsArray = qadm.fHitsArray;
return *this;
}
}
//_____________________________________________________________________
-void AliFMDQADataMakerSim::MakeHits(TClonesArray * hits)
+void AliFMDQADataMakerSim::MakeHits()
{
// Check id histograms already created for this Event Specie
if ( ! GetHitsData(0) )
InitHits() ;
- TIter next(hits);
+ TIter next(fHitsArray);
AliFMDHit * hit;
while ((hit = static_cast<AliFMDHit *>(next())))
GetHitsData(0)->Fill(hit->Edep()/hit->Length()*0.032);
{
// make QA data from Hit Tree
- fHitsArray.Clear();
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliFMDHit", 1000) ;
TBranch * branch = hitTree->GetBranch("FMD") ;
if (!branch) {
AliWarning("FMD branch in Hit Tree not found") ;
return;
}
-
- TClonesArray* hitsAddress = &fHitsArray;
-
- branch->SetAddress(&hitsAddress) ;
+
+ branch->SetAddress(&fHitsArray) ;
for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
branch->GetEntry(ientry);
- MakeHits(hitsAddress); //tmp);
+ MakeHits(); //tmp);
+ fHitsArray->Clear() ;
}
-
}
//_____________________________________________________________________
-void AliFMDQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliFMDQADataMakerSim::MakeDigits()
{
// makes data from Digits
- if(!digits) return;
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- for(Int_t i = 0 ; i < digits->GetEntriesFast() ; i++) {
+ if(!fDigitsArray) return;
+
+ for(Int_t i = 0 ; i < fDigitsArray->GetEntriesFast() ; i++) {
//Raw ADC counts
- AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
+ AliFMDDigit* digit = static_cast<AliFMDDigit*>(fDigitsArray->At(i));
GetDigitsData(0)->Fill(digit->Counts());
}
}
void AliFMDQADataMakerSim::MakeDigits(TTree * digitTree)
{
- fDigitsArray.Clear();
+ if (fDigitsArray)
+ fDigitsArray->Clear();
+ else
+ fDigitsArray = new TClonesArray("AliFMDDigit", 1000) ;
+
TBranch * branch = digitTree->GetBranch("FMD") ;
if (!branch) {
AliWarning("FMD branch in Digit Tree not found") ;
return;
}
- TClonesArray* digitAddress = &fDigitsArray;
- branch->SetAddress(&digitAddress) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digitAddress) ;
+ MakeDigits() ;
}
//_____________________________________________________________________
-void AliFMDQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliFMDQADataMakerSim::MakeSDigits()
{
// makes data from Digits
- if(!sdigits) return;
+ if(!fSDigitsArray) return;
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
-
- for(Int_t i = 0 ; i < sdigits->GetEntriesFast() ; i++) {
+ for(Int_t i = 0 ; i < fSDigitsArray->GetEntriesFast() ; i++) {
//Raw ADC counts
- AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(sdigits->At(i));
+ AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fSDigitsArray->At(i));
GetSDigitsData(0)->Fill(sdigit->Counts());
}
}
void AliFMDQADataMakerSim::MakeSDigits(TTree * sdigitTree)
{
- fSDigitsArray.Clear();
+ if (fSDigitsArray)
+ fSDigitsArray->Clear() ;
+ else
+ fSDigitsArray = new TClonesArray("AliFMDSDigit", 1000) ;
TBranch * branch = sdigitTree->GetBranch("FMD") ;
if (!branch) {
AliWarning("FMD branch in SDigit Tree not found") ;
return;
}
- TClonesArray* sdigitAddress = &fSDigitsArray;
- branch->SetAddress(&sdigitAddress) ;
+ branch->SetAddress(&fSDigitsArray) ;
branch->GetEntry(0) ;
- MakeSDigits(sdigitAddress) ;
+ MakeSDigits() ;
}
//_____________________________________________________________________
virtual void InitDigits();
// virtual void InitRaws() ;
virtual void InitSDigits() ;
- virtual void MakeHits(TClonesArray* hits) ;
+ virtual void MakeHits() ;
virtual void MakeHits(TTree* hitTree) ;
- virtual void MakeDigits(TClonesArray* digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree* digitTree) ;
// virtual void MakeRaws(AliRawReader* rawReader) ;
- virtual void MakeSDigits(TClonesArray * sigits) ;
+ virtual void MakeSDigits() ;
virtual void MakeSDigits(TTree * sigitTree) ;
virtual void StartOfDetectorCycle() ;
- TClonesArray fSDigitsArray;
- TClonesArray fDigitsArray;
- TClonesArray fHitsArray;
ClassDef(AliFMDQADataMakerSim,0) // description
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDQADataMakerRec::AliHMPIDQADataMakerRec() :
- AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0)
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0), fChannel(0)
{
// ctor
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDQADataMakerRec::AliHMPIDQADataMakerRec(const AliHMPIDQADataMakerRec& qadm) :
- AliQADataMakerRec(),fEvtRaw(qadm.fEvtRaw)
+ AliQADataMakerRec(),fEvtRaw(qadm.fEvtRaw), fChannel(qadm.fChannel)
{
//copy ctor
SetName((const char*)qadm.GetName()) ;
//
// Filling Raws QA histos
//
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
-
rawReader->Reset() ;
AliHMPIDRawStream stream(rawReader);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-void AliHMPIDQADataMakerRec::MakeDigits(TClonesArray * data)
+void AliHMPIDQADataMakerRec::MakeDigits()
{
//
//filling QA histos for Digits
//
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
+ Int_t i = fChannel ;
+ GetDigitsData(0)->Fill(i,fDigitsArray->GetEntriesFast()/(48.*80.*6.));
+ TIter next(fDigitsArray);
+ 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());
+ }
+}
- 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);
+ if(fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray=new TClonesArray("AliHMPIDDigit");
for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++){
- data->SetBranchAddress(Form("HMPID%i",iCh),&(*pObjDig)[iCh]);
+ fChannel = iCh ;
+ fDigitsArray->Clear() ;
+ data->SetBranchAddress(Form("HMPID%i",iCh),&fDigitsArray);
+ data->GetEntry(0);
+ MakeDigits();
}
- data->GetEntry(0);
-
- MakeDigits((TClonesArray *)pObjDig);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//filling QA histos for clusters
//
AliHMPIDParam *pPar =AliHMPIDParam::Instance();
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(0) )
- InitRecPoints() ;
-
- static TClonesArray *clusters;
- if(!clusters) clusters = new TClonesArray("AliHMPIDCluster");
+
+ if (fRecPointsArray)
+ fRecPointsArray->Clear() ;
+ else
+ fRecPointsArray = new TClonesArray("AliHMPIDCluster");
for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++){
TBranch *branch = clustersTree->GetBranch(Form("HMPID%d",iCh));
- branch->SetAddress(&clusters);
+ branch->SetAddress(&fRecPointsArray);
branch->GetEntry(0);
- GetRecPointsData(0)->Fill(iCh,clusters->GetEntries());
- TIter next(clusters);
+ GetRecPointsData(0)->Fill(iCh,fRecPointsArray->GetEntries());
+ TIter next(fRecPointsArray);
AliHMPIDCluster *clu;
while ( (clu = dynamic_cast<AliHMPIDCluster *>(next())) ) {
GetRecPointsData(1)->Fill(clu->Status(),iCh);
if(clu->Q()>100) GetRecPointsData(2+iCh)->Fill(clu->Size());
else {
GetRecPointsData(2+7+iCh)->Fill(clu->Size());
- GetRecPointsData(2+14+iCh*6+sect)->Fill(clu->Q());
+ GetRecPointsData(2+14+iCh*6+sect)->Fill(clu->Q());
}
GetRecPointsData(2+14+42+iCh*6+sect)->Fill(clu->Q());
}
}
-
- clusters->Clear();
-
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::MakeESDs(AliESDEvent * esd)
//
//fills QA histos for ESD
//
-
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
-
+
for(Int_t iTrk = 0 ; iTrk < esd->GetNumberOfTracks() ; iTrk++){
AliESDtrack *pTrk = esd->GetTrack(iTrk) ;
GetESDsData(0)->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal());
if(task==AliQAv1::kRAWS) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ if (! IsValidEventSpecie(specie, histos) )
continue ;
for(Int_t iddl=0;iddl<14;iddl++) {
TH1F *h = (TH1F*)histos[specie]->At(14+iddl); //ddl histos scaled by the number of events
}
}
}
-
AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, histos);
-
}
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() ;
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
virtual void StartOfDetectorCycle() ;
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** obj) ;
- Int_t fEvtRaw; //internal event counter for raw
+ Int_t fEvtRaw; //!internal event counter for raw
+ Int_t fChannel ; //!
- ClassDef(AliHMPIDQADataMakerRec,1) // description
+ ClassDef(AliHMPIDQADataMakerRec,2) // description
};
//____________________________________________________________________________
AliHMPIDQADataMakerSim::AliHMPIDQADataMakerSim() :
- AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"), fChannel(0)
{
// ctor
}
//____________________________________________________________________________
AliHMPIDQADataMakerSim::AliHMPIDQADataMakerSim(const AliHMPIDQADataMakerSim& qadm) :
- AliQADataMakerSim()
+ AliQADataMakerSim(),fChannel(0)
{
//copy ctor
SetName((const char*)qadm.GetName()) ;
//____________________________________________________________________________
-void AliHMPIDQADataMakerSim::MakeHits(TClonesArray * data)
+void AliHMPIDQADataMakerSim::MakeHits()
{
//
//filling QA histos for Hits
//
- TClonesArray * hits = dynamic_cast<TClonesArray *>(data) ;
- if (!hits){
- AliError("Wrong type of hits container") ;
- } else {
-
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
- TIter next(hits);
- AliHMPIDHit * hit ;
- while ( (hit = dynamic_cast<AliHMPIDHit *>(next())) ) {
- if(hit->Pid()<500000) GetHitsData(0)->Fill(hit->Q()) ;
- if(hit->Pid()<500000) GetHitsData(hit->Ch()+1)->Fill(hit->LorsX(),hit->LorsY());
- }
- }
+
+ TIter next(fHitsArray);
+ AliHMPIDHit * hit ;
+ while ( (hit = dynamic_cast<AliHMPIDHit *>(next())) ) {
+ if(hit->Pid()<500000) GetHitsData(0)->Fill(hit->Q()) ;
+ if(hit->Pid()<500000) GetHitsData(hit->Ch()+1)->Fill(hit->LorsX(),hit->LorsY());
+ }
+}
-}
//___________________________________________________________________________
void AliHMPIDQADataMakerSim::MakeHits(TTree * data)
{
//
//Opening of the Hit TTree
//
- TClonesArray *pHits=new TClonesArray("AliHMPIDHit"); data->SetBranchAddress("HMPID",&pHits);
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray=new TClonesArray("AliHMPIDHit");
+ data->SetBranchAddress("HMPID",&fHitsArray);
for(Int_t iEnt=0;iEnt<data->GetEntriesFast();iEnt++){//entries loop
data->GetEntry(iEnt);
- MakeHits(pHits);
+ MakeHits();
}//entries loop
}
-//____________________________________________________________________________
-void AliHMPIDQADataMakerSim::MakeDigits(TClonesArray * data)
+//___________________________________________________________________________
+void AliHMPIDQADataMakerSim::MakeDigits()
{
- //
- //filling QA histos for Digits
- //
-
- TObjArray *chamber = dynamic_cast<TObjArray*>(data);
- if ( !chamber) {
- AliError("Wrong type of digits container") ;
- } else {
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- 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());
- }
- }
- }
-}
+ //
+ //filling QA histos for Digits
+ //
+
+ Int_t i = fChannel ;
+ GetDigitsData(0)->Fill(i,fDigitsArray->GetEntriesFast()/(48.*80.*6.));
+ TIter next(fDigitsArray);
+ 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 AliHMPIDQADataMakerSim::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);
-
+ //
+ //Opening the Digit Tree
+ //
+
+ if(fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray=new TClonesArray("AliHMPIDDigit");
+
for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++){
- data->SetBranchAddress(Form("HMPID%i",iCh),&(*pObjDig)[iCh]);
+ fChannel = iCh ;
+ data->SetBranchAddress(Form("HMPID%i",iCh),&fDigitsArray);
+ data->GetEntry(0);
+ MakeDigits();
+ fDigitsArray->Clear() ;
}
- data->GetEntry(0);
-
- MakeDigits((TClonesArray *)pObjDig);
}
+
//____________________________________________________________________________
-void AliHMPIDQADataMakerSim::MakeSDigits(TClonesArray * data)
+void AliHMPIDQADataMakerSim::MakeSDigits()
{
//
//filling QA histos for SDigits
//
- TClonesArray * sdigits = dynamic_cast<TClonesArray *>(data) ;
- if (!sdigits) {
- AliError("Wrong type of sdigits container") ;
- } else {
-
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
-
- TIter next(sdigits) ;
- AliHMPIDDigit * sdigit ;
- while ( (sdigit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
- GetSDigitsData(0)->Fill(sdigit->Q());
- }
- }
+
+ TIter next(fSDigitsArray) ;
+ AliHMPIDDigit * sdigit ;
+ while ( (sdigit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
+ GetSDigitsData(0)->Fill(sdigit->Q());
+ }
}
//___________________________________________________________________________
void AliHMPIDQADataMakerSim::MakeSDigits(TTree * data)
//
// Opening the SDigit Tree
//
- TClonesArray * sdigits = new TClonesArray("AliHMPIDDigit", 1000) ;
+ if (fSDigitsArray)
+ fSDigitsArray->Clear() ;
+ else
+ fSDigitsArray = new TClonesArray("AliHMPIDDigit", 1000) ;
TBranch * branch = data->GetBranch("HMPID") ;
if ( ! branch ) {
AliError("HMPID SDigit Tree not found") ;
return;
}
- branch->SetAddress(&sdigits) ;
+ branch->SetAddress(&fSDigitsArray) ;
branch->GetEntry(0) ;
- MakeSDigits(sdigits) ;
+ MakeSDigits() ;
}
//____________________________________________________________________________
void AliHMPIDQADataMakerSim::StartOfDetectorCycle()
virtual void InitHits() ; //book hit QA histo
virtual void InitDigits() ; //book Digit QA histo
virtual void InitSDigits() ; //book SDigits QA histo
- virtual void MakeHits(TClonesArray * hits) ; //Fill hit QA histo
+ virtual void MakeHits() ; //Fill hit QA histo
virtual void MakeHits(TTree * hits) ; // access to hit tree
- virtual void MakeDigits(TClonesArray * digits) ; //Fill Digit QA histo
+ virtual void MakeDigits() ; //Fill Digit QA histo
virtual void MakeDigits(TTree * digits) ; //access to digit tree
- virtual void MakeSDigits(TClonesArray * sdigits) ; //Fill SDigit QA histo
+ virtual void MakeSDigits() ; //Fill SDigit QA histo
virtual void MakeSDigits(TTree * sdigits) ; //access to SDigits tree
virtual void StartOfDetectorCycle() ;
+
+ Int_t fChannel ; //!
- ClassDef(AliHMPIDQADataMakerSim,1) // description
+ ClassDef(AliHMPIDQADataMakerSim,2) // description
};
virtual void InitRecPoints();
virtual void InitESDs();
virtual void MakeRaws(AliRawReader *rawReader);
- virtual void MakeDigits(TClonesArray * ){AliWarning("Signature not implemented. A TTree* of digits should be passed as input argument");}
+ virtual void MakeDigits(){AliWarning("Signature not implemented. A TTree* of digits should be passed as input argument");}
virtual void MakeDigits(TTree *digitsTree);
virtual void MakeRecPoints(TTree *clustersTree);
virtual void MakeESDs(AliESDEvent *esd);
{
// launch the QA checking
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ if (! IsValidEventSpecie(specie, list) )
+ continue ;
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[specie]);
}
//____________________________________________________________________________
-void AliITSQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliITSQADataMakerSim::MakeDigits()
{
// Fill QA for digits
if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeDigits(digits) ;
+ Int_t rv = fSPDDataMaker->MakeDigits() ;
if ( rv != 0 )
fSDDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
}
if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeDigits(digits) ;
+ Int_t rv = fSDDDataMaker->MakeDigits() ;
if ( rv != 0 )
fSSDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
}
- if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digits);
+ if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits();
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-void AliITSQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliITSQADataMakerSim::MakeSDigits()
{
// Fill QA for recpoints
if(fSubDetector == 0 || fSubDetector == 1){
- Int_t rv = fSPDDataMaker->MakeSDigits(sdigits) ;
+ Int_t rv = fSPDDataMaker->MakeSDigits() ;
if ( rv != 0 )
fSDDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
}
if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeSDigits(sdigits) ;
+ Int_t rv = fSDDDataMaker->MakeSDigits() ;
if ( rv != 0 )
fSSDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
}
- if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeSDigits(sdigits);
+ if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeSDigits();
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-void AliITSQADataMakerSim::MakeHits(TClonesArray * hits)
+void AliITSQADataMakerSim::MakeHits()
{
// Fill QA for hits
if(fSubDetector == 0 || fSubDetector == 1) {
- Int_t rv = fSPDDataMaker->MakeHits(hits) ;
+ Int_t rv = fSPDDataMaker->MakeHits() ;
if ( rv != 0 )
fSDDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
}
if(fSubDetector == 0 || fSubDetector == 2) {
- Int_t rv = fSDDDataMaker->MakeHits(hits) ;
+ Int_t rv = fSDDDataMaker->MakeHits() ;
if ( rv != 0 )
fSSDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries());
}
- if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeHits(hits);
+ if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeHits();
}
//____________________________________________________________________________
virtual void InitDigits();
virtual void InitSDigits();
virtual void InitHits();
- virtual void MakeDigits(TClonesArray * digits);
- virtual void MakeSDigits(TClonesArray * sdigits);
- virtual void MakeHits(TClonesArray * hits);
+ virtual void MakeDigits();
+ virtual void MakeSDigits();
+ virtual void MakeHits();
virtual void MakeDigits(TTree * digits);
virtual void MakeSDigits(TTree * sdigits);
virtual void MakeHits(TTree * hits);
virtual Int_t InitDigits();
virtual Int_t InitRecPoints();
virtual Int_t MakeRaws(AliRawReader *rawReader);
- virtual Int_t MakeDigits(TClonesArray* /*digits*/) {return 0;}
+ virtual Int_t MakeDigits() {return 0;}
virtual Int_t MakeDigits(TTree *clustersTree);
virtual Int_t MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
\r
// Fill QA for DIGIT - SDD -\r
Int_t rv = 0 ; \r
- // Check id histograms already created for this Event Specie\r
- if ( ! fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD) )\r
- rv = InitDigits() ;\r
- \r
+\r
AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");\r
fITS->SetTreeAddress();\r
TClonesArray *iITSdigits = fITS->DigitsAddress(1);\r
{ \r
// Fill QA for SDIGIT - SDD -\r
Int_t rv = 0 ; \r
- // Check id histograms already created for this Event Specie\r
- if ( ! fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS) )\r
- rv = InitSDigits() ;\r
\r
AliITSsegmentationSDD* seg = new AliITSsegmentationSDD();\r
Int_t nan=seg->Npz();\r
\r
\r
TBranch *brchSDigits = sdigits->GetBranch("ITS");\r
+ static TClonesArray * sdig ; \r
+ if (! sdig )\r
+ sdig = new TClonesArray( "AliITSpListItem",1000 );\r
for(Int_t id=0; id<260; id++){\r
Int_t nmod=id+240;\r
- TClonesArray * sdig = new TClonesArray( "AliITSpListItem",1000 );\r
brchSDigits->SetAddress( &sdig );\r
brchSDigits->GetEvent(nmod);\r
Int_t nsdig=sdig->GetEntries();\r
fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS)->Fill(it);\r
fAliITSQADataMakerSim->GetSDigitsData(3+fGenOffsetS)->Fill(sig);\r
}\r
- delete sdig;\r
+ sdig->Clear();\r
}\r
return rv ; \r
}\r
{ \r
// Fill QA for HITS - SDD -\r
Int_t rv = 0 ; \r
- // Check id histograms already created for this Event Specie\r
- if ( ! fAliITSQADataMakerSim->GetHitsData(fGenOffsetH) )\r
- rv = InitHits() ;\r
- \r
+\r
AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");\r
fITS->SetTreeAddress();\r
Int_t nmodules;\r
virtual Int_t InitDigits();\r
virtual Int_t InitSDigits();\r
virtual Int_t InitHits();\r
- virtual Int_t MakeDigits(TClonesArray * /*digits*/){return 0;}\r
- virtual Int_t MakeSDigits(TClonesArray * /*sdigits*/){return 0;}\r
- virtual Int_t MakeHits(TClonesArray * /*hits*/){return 0;}\r
+ virtual Int_t MakeDigits(){return 0;}\r
+ virtual Int_t MakeSDigits(){return 0;}\r
+ virtual Int_t MakeHits(){return 0;}\r
virtual Int_t MakeDigits(TTree * digits);\r
virtual Int_t MakeSDigits(TTree * sdigits);\r
virtual Int_t MakeHits(TTree * hits);\r
{
// Fill QA for RAW - SPD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset) )
- rv = InitRaws() ;
rawReader->Reset();
AliITSRawStreamSPD *rawStreamSPD = new AliITSRawStreamSPD(rawReader);
{
// Fill QA for DIGIT - SPD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset) )
- rv = InitDigits() ;
// AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
// fITS->SetTreeAddress();
AliError("can't get the branch with the ITS clusters !");
return rv;
}
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset) )
- rv = InitRecPoints() ;
itsClusterBranch->SetAddress(&ITSCluster);
Int_t nItsMods = (Int_t)clusterTree->GetEntries();
virtual Int_t InitRecPoints();
virtual Int_t MakeRaws(AliRawReader *rawReader);
virtual Int_t MakeRecPoints(TTree *clustersTree);
- virtual Int_t MakeDigits(TClonesArray* /*digits*/) {return 0;}
+ virtual Int_t MakeDigits() {return 0;}
virtual Int_t MakeDigits(TTree *clustersTree);
virtual void StartOfDetectorCycle();
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
{
// Fill QA for DIGIT - SPD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD) )
- rv = InitDigits() ;
-
+
AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
fITS->SetTreeAddress();
TClonesArray *iITSdigits = fITS->DigitsAddress(0); // 0->SPD
{
// Fill QA for SDIGIT - SPD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS) )
- rv = InitSDigits() ;
-
+
+ static TClonesArray * sdig ;
+ if (! sdig )
+ sdig = new TClonesArray( "AliITSpListItem",1000 );
+
TBranch *brchSDigits = sdigits->GetBranch("ITS");
for (Int_t imod=0; imod<240; ++imod){
- TClonesArray * sdig = new TClonesArray( "AliITSpListItem",1000 );
brchSDigits->SetAddress( &sdig );
brchSDigits->GetEvent(imod);
Int_t nsdig=sdig->GetEntries();
fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS)->Fill(1,nsdig);
fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS)->Fill(imod,nsdig);
}
- delete sdig;
+ sdig->Clear() ;
}
return rv ;
}
{
// Fill QA for HITS - SPD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerSim->GetHitsData(fGenOffsetH) )
- rv = InitHits() ;
AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
fITS->SetTreeAddress();
virtual Int_t InitDigits();
virtual Int_t InitSDigits();
virtual Int_t InitHits();
- virtual Int_t MakeDigits(TClonesArray * /*digits*/){return 0;}
- virtual Int_t MakeSDigits(TClonesArray * /*sdigits*/){return 0;}
- virtual Int_t MakeHits(TClonesArray * /*hits*/){return 0;}
+ virtual Int_t MakeDigits(){return 0;}
+ virtual Int_t MakeSDigits(){return 0;}
+ virtual Int_t MakeHits(){return 0;}
virtual Int_t MakeDigits(TTree * digits);
virtual Int_t MakeSDigits(TTree * sdigits);
virtual Int_t MakeHits(TTree * hits);
Int_t AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) {
// Fill QA for RAW - SSD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset) )
- rv = InitRaws() ;
Int_t gStripNumber;
Int_t gHistPosition;
return rv;
}
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset) )
- rv = InitDigits() ;
-
static TClonesArray statDigits("AliITSdigitSSD");
TClonesArray *iSSDdigits = &statDigits;
branchD->SetAddress(&iSSDdigits);
AliError("can't get the branch with the ITS clusters !");
return rv;
}
-
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset) )
- rv = InitRecPoints() ;
-
+
static TClonesArray statRecpoints("AliITSRecPoint");
TClonesArray *recpoints = &statRecpoints;
branchRecP->SetAddress(&recpoints);
virtual Int_t InitDigits();
virtual Int_t InitRecPoints();
virtual Int_t MakeRaws(AliRawReader *rawReader);
- virtual Int_t MakeDigits(TClonesArray* /*digits*/) {return 0;}
+ virtual Int_t MakeDigits() {return 0;}
virtual Int_t MakeDigits(TTree *digitsTree);
virtual Int_t MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
Int_t AliITSQASSDDataMakerSim::MakeDigits(TTree *digits) {
// Fill QA for DIGIT - SSD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD) )
- rv = InitDigits() ;
-
+
AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
fITS->SetTreeAddress();
TClonesArray *iSSDdigits = fITS->DigitsAddress(2);
Int_t AliITSQASSDDataMakerSim::MakeSDigits(TTree *sdigits) {
// Fill QA for SDIGIT - SSD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS) )
- rv = InitSDigits() ;
static TClonesArray iSSDEmpty("AliITSpListItem",10000);
iSSDEmpty.Clear();
Int_t AliITSQASSDDataMakerSim::MakeHits(TTree *hits) {
// Fill QA for HITS - SSD -
Int_t rv = 0 ;
- // Check id histograms already created for this Event Specie
- if ( ! fAliITSQADataMakerSim->GetHitsData(fGenOffsetH) )
- rv = InitHits() ;
AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
fITS->SetTreeAddress();
virtual Int_t InitDigits();
virtual Int_t InitSDigits();
virtual Int_t InitHits();
- virtual Int_t MakeDigits(TClonesArray * /*digits*/){return 0;}
- virtual Int_t MakeSDigits(TClonesArray * /*sdigits*/){return 0;}
- virtual Int_t MakeHits (TClonesArray * /*hits*/){return 0;}
+ virtual Int_t MakeDigits(){return 0;}
+ virtual Int_t MakeSDigits(){return 0;}
+ virtual Int_t MakeHits (){return 0;}
virtual Int_t MakeDigits(TTree * digits);
virtual Int_t MakeSDigits(TTree * sdigits);
virtual Int_t MakeHits(TTree * hits);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
{
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ if (! IsValidEventSpecie(specie, list) )
continue ;
SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
if ( task == AliQAv1::kRAWS && fTrackerDataMaker )
{
/// make QA for rawdata
- if ( ! GetRawsData(kTriggerScalersBP) )
- InitRaws() ;
-
if ( ! fIsInitRaws ) {
AliWarningStream()
<< "Skipping function due to a failure in Init" << endl;
{
/// makes data from Digits
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
if (!fDigitStore)
fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
fDigitStore->Connect(*digitsTree, false);
{
/// Fill histograms from treeR
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(kTrackerNumberOfClustersPerChamber) )
- InitRecPoints() ;
-
if (fIsInitRecPointsTracker) MakeRecPointsTracker(clustersTree);
if (fIsInitRecPointsTrigger) MakeRecPointsTrigger(clustersTree);
}
{
/// make QA data from ESDs
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(kESDnTracks) )
- InitESDs() ;
-
if ( ! fIsInitESDs ) {
AliWarningStream()
<< "Skipping function due to a failure in Init" << endl;
virtual void MakeRaws(AliRawReader* rawReader);
virtual void MakeDigits(TTree* dig);
- virtual void MakeDigits(TClonesArray* /*digits*/) {return;}
+ virtual void MakeDigits() {return;}
virtual void MakeRecPoints(TTree* recpo);
virtual void MakeESDs(AliESDEvent* esd) ;
void AliMUONQADataMakerSim::MakeHits(TTree* hitsTree)
{
/// makes data from Hits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
if (!fHitStore)
fHitStore = AliMUONVHitStore::Create(*hitsTree);
{
/// makes data from SDigits
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
-
if (!fDigitStore)
fDigitStore = AliMUONVDigitStore::Create(*sdigitsTree);
fDigitStore->Connect(*sdigitsTree, false);
{
/// makes data from Digits
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
if (!fDigitStore)
fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
fDigitStore->Connect(*digitsTree, false);
virtual void InitDigits();
/// make hits QA from Array (not implemented)
- virtual void MakeHits(TClonesArray* /*hits*/) {return;}
+ virtual void MakeHits() {return;}
/// make hits QA from tree
virtual void MakeHits(TTree* hitsTree);
/// make SDigits QA from Array (not implemented)
- virtual void MakeSDigits(TClonesArray* /*sigits*/) {return;}
+ virtual void MakeSDigits() {return;}
/// make SDigits QA from Tree
virtual void MakeSDigits(TTree* sigitsTree);
/// make Digits QA from Array (not implemented)
- virtual void MakeDigits(TClonesArray* /*digits*/) {return;}
+ virtual void MakeDigits() {return;}
/// make SDigits QA from Tree
virtual void MakeDigits(TTree* digitsTree);
void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
- if(GetRawsData(kHGqualMod1) && GetRawsData(kHGmod1))
- GetRawsData(kHGqualMod1)->Divide( GetRawsData(kHGmod1) ) ;
- if(GetRawsData(kHGqualMod2) && GetRawsData(kHGmod2))
- GetRawsData(kHGqualMod2)->Divide( GetRawsData(kHGmod2) ) ;
- if(GetRawsData(kHGqualMod3) && GetRawsData(kHGmod3))
- GetRawsData(kHGqualMod3)->Divide( GetRawsData(kHGmod3) ) ;
- if(GetRawsData(kHGqualMod4) && GetRawsData(kHGmod4))
- GetRawsData(kHGqualMod4)->Divide( GetRawsData(kHGmod4) ) ;
- if(GetRawsData(kHGqualMod5) && GetRawsData(kHGmod5))
- GetRawsData(kHGqualMod5)->Divide( GetRawsData(kHGmod5) ) ;
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ if (! IsValidEventSpecie(specie, list))
+ continue ;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
+ if(GetRawsData(kHGqualMod1) && GetRawsData(kHGmod1))
+ GetRawsData(kHGqualMod1)->Divide( GetRawsData(kHGmod1) ) ;
+ if(GetRawsData(kHGqualMod2) && GetRawsData(kHGmod2))
+ GetRawsData(kHGqualMod2)->Divide( GetRawsData(kHGmod2) ) ;
+ if(GetRawsData(kHGqualMod3) && GetRawsData(kHGmod3))
+ GetRawsData(kHGqualMod3)->Divide( GetRawsData(kHGmod3) ) ;
+ if(GetRawsData(kHGqualMod4) && GetRawsData(kHGmod4))
+ GetRawsData(kHGqualMod4)->Divide( GetRawsData(kHGmod4) ) ;
+ if(GetRawsData(kHGqualMod5) && GetRawsData(kHGmod5))
+ GetRawsData(kHGqualMod5)->Divide( GetRawsData(kHGmod5) ) ;
+ }
// do the QA checking
AliQAChecker::Instance()->Run(AliQAv1::kPHOS, task, list) ;
}
void AliPHOSQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
// make QA data from ESDs
-
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(kESDSpec) )
- InitESDs() ;
-
+
Int_t nTot = 0 ;
Double_t eTot = 0 ;
for ( Int_t index = 0; index < esd->GetNumberOfCaloClusters() ; index++ ) {
{
//Fill prepared histograms with Raw digit properties
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(kLGpedRMS) )
- InitRaws() ;
-
rawReader->Reset() ;
AliPHOSRawDecoder * decoder ;
if(strcmp(GetRecoParam()->EMCDecoderVersion(),"v1")==0)
}
//____________________________________________________________________________
-void AliPHOSQADataMakerRec::MakeDigits(TClonesArray * digits)
+void AliPHOSQADataMakerRec::MakeDigits()
{
// makes data from Digits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(kDigits) )
- InitDigits() ;
TH1 * hist = GetDigitsData(kDigitsMul) ;
if ( ! hist )
InitDigits() ;
- GetDigitsData(kDigitsMul)->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
+ GetDigitsData(kDigitsMul)->Fill(fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
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) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliPHOSDigit", 1000) ;
TBranch * branch = digitTree->GetBranch("PHOS") ;
if ( ! branch ) {
AliWarning("PHOS branch in Digit Tree not found") ;
} else {
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
return;
}
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(kRPSpec) )
- InitRecPoints() ;
-
TObjArray * emcrecpoints = new TObjArray(100) ;
emcbranch->SetAddress(&emcrecpoints);
emcbranch->GetEntry(0);
virtual void InitRecPoints() ;
virtual void InitRaws() ;
virtual void MakeESDs(AliESDEvent * esd) ;
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * recpoTree) ;
virtual void MakeRecPoints(TTree * recpoTree) ;
virtual void MakeRaws(AliRawReader* rawReader) ;
//____________________________________________________________________________
AliPHOSQADataMakerSim::AliPHOSQADataMakerSim() :
- AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kPHOS), "PHOS Quality Assurance Data Maker"),
- fHits(0x0)
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kPHOS), "PHOS Quality Assurance Data Maker")
{
// ctor
- fHits = new TClonesArray("AliPHOSHit", 1000);
}
//____________________________________________________________________________
AliPHOSQADataMakerSim::AliPHOSQADataMakerSim(const AliPHOSQADataMakerSim& qadm) :
- AliQADataMakerSim(),
- fHits(0x0)
+ AliQADataMakerSim()
{
//copy ctor
SetName((const char*)qadm.GetName()) ;
SetTitle((const char*)qadm.GetTitle());
- fHits = new TClonesArray("AliPHOSHit", 1000);
}
//__________________________________________________________________
{
//make QA data from Hits
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(kHits) )
- InitHits() ;
-
-
- TIter next(fHits) ;
+ TIter next(fHitsArray) ;
AliPHOSHit * hit ;
while ( (hit = dynamic_cast<AliPHOSHit *>(next())) ) {
GetHitsData(kHits)->Fill( hit->GetEnergy()) ;
{
// make QA data from Hit Tree
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliPHOSHit", 1000);
+
TBranch * branch = hitTree->GetBranch("PHOS") ;
if ( ! branch ) {
AliWarning("PHOS branch in Hit Tree not found") ;
} else {
Int_t nHits = 0;
- branch->SetAddress(&fHits) ;
+ branch->SetAddress(&fHitsArray) ;
for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
branch->GetEntry(ientry) ;
- nHits += fHits->GetEntriesFast();
+ nHits += fHitsArray->GetEntriesFast();
MakeHits() ;
- fHits->Clear();
+ fHitsArray->Clear();
}
GetHitsData(1)->Fill(nHits) ;
}
}
//____________________________________________________________________________
-void AliPHOSQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliPHOSQADataMakerSim::MakeDigits()
{
// makes data from Digits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(kDigits) )
- InitDigits() ;
-
- GetDigitsData(1)->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
- AliPHOSDigit * digit ;
- while ( (digit = dynamic_cast<AliPHOSDigit *>(next())) ) {
- GetDigitsData(kDigits)->Fill( digit->GetEnergy()) ;
- }
+
+ GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
+ AliPHOSDigit * digit ;
+ while ( (digit = dynamic_cast<AliPHOSDigit *>(next())) ) {
+ GetDigitsData(kDigits)->Fill( digit->GetEnergy()) ;
+ }
}
//____________________________________________________________________________
void AliPHOSQADataMakerSim::MakeDigits(TTree * digitTree)
{
// makes data from Digit Tree
- TClonesArray * digits = new TClonesArray("AliPHOSDigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliPHOSDigit", 1000) ;
TBranch * branch = digitTree->GetBranch("PHOS") ;
if ( ! branch ) {
AliWarning("PHOS branch in Digit Tree not found") ;
} else {
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
//____________________________________________________________________________
-void AliPHOSQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliPHOSQADataMakerSim::MakeSDigits()
{
// makes data from SDigits
-
-
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(kSDigits) )
- InitSDigits() ;
- GetSDigitsData(1)->Fill(sdigits->GetEntriesFast()) ;
- TIter next(sdigits) ;
+ GetSDigitsData(1)->Fill(fSDigitsArray->GetEntriesFast()) ;
+ TIter next(fSDigitsArray) ;
AliPHOSDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliPHOSDigit *>(next())) ) {
GetSDigitsData(kSDigits)->Fill( sdigit->GetEnergy()) ;
void AliPHOSQADataMakerSim::MakeSDigits(TTree * sdigitTree)
{
// makes data from SDigit Tree
- TClonesArray * sdigits = new TClonesArray("AliPHOSDigit", 1000) ;
-
+ if (fSDigitsArray)
+ fSDigitsArray->Clear() ;
+ else
+ fSDigitsArray = new TClonesArray("AliPHOSDigit", 1000) ;
+
TBranch * branch = sdigitTree->GetBranch("PHOS") ;
if ( ! branch ) {
AliWarning("PHOS branch in SDigit Tree not found") ;
} else {
- branch->SetAddress(&sdigits) ;
+ branch->SetAddress(&fSDigitsArray) ;
branch->GetEntry(0) ;
- MakeSDigits(sdigits) ;
+ MakeSDigits() ;
}
}
virtual void InitHits() ;
virtual void InitDigits() ;
virtual void InitSDigits() ;
- using AliQADataMakerSim::MakeHits;
- void MakeHits() ;
+ virtual void MakeHits() ;
virtual void MakeHits(TTree * hitTree) ;
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * digitTree) ;
- virtual void MakeSDigits(TClonesArray * sigits) ;
+ virtual void MakeSDigits() ;
virtual void MakeSDigits(TTree * sigitTree) ;
virtual void StartOfDetectorCycle() ;
-private:
- TClonesArray * fHits; //!Array of PHOS hits
-
ClassDef(AliPHOSQADataMakerSim,2) // description
};
{
//Fill prepared histograms with Raw digit properties
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
-
TObjArray *pmdddlcont = 0x0;
pmdddlcont = new TObjArray();
AliPMDRawStream stream(rawReader);
}
//____________________________________________________________________________
-void AliPMDQADataMakerRec::MakeDigits(TClonesArray * digits)
+void AliPMDQADataMakerRec::MakeDigits()
{
// makes data from Digits
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- Int_t cpvmul = 0, premul = 0;
+ Int_t cpvmul = 0, premul = 0;
- TIter next(digits) ;
+ TIter next(fDigitsArray) ;
AliPMDdigit * digit ;
while ( (digit = dynamic_cast<AliPMDdigit *>(next())) )
{
{
// makes data from Digit Tree
- TClonesArray * digits = new TClonesArray("AliPMDdigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliPMDdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("PMDDigit") ;
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
if ( ! branch )
{
for (Int_t ient = 0; ient < branch->GetEntries(); ient++)
{
branch->GetEntry(ient) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
{
// makes data from RecPoints
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(0) )
- InitRecPoints() ;
-
Int_t multDdl0 = 0, multDdl1 = 0, multDdl2 = 0;
Int_t multDdl3 = 0, multDdl4 = 0, multDdl5 = 0;
AliPMDrecpoint1 * recpoint;
- TClonesArray * recpoints = 0x0;
- recpoints = new TClonesArray("AliPMDrecpoint1", 1000) ;
+ if (fRecPointsArray)
+ fRecPointsArray->Clear() ;
+ else
+ fRecPointsArray = new TClonesArray("AliPMDrecpoint1", 1000) ;
TBranch * branch = clustersTree->GetBranch("PMDRecpoint") ;
- branch->SetAddress(&recpoints) ;
+ branch->SetAddress(&fRecPointsArray) ;
if ( ! branch )
{
{
branch->GetEntry(imod) ;
- TIter next(recpoints) ;
+ TIter next(fRecPointsArray) ;
while ( (recpoint = dynamic_cast<AliPMDrecpoint1 *>(next())) )
{
GetRecPointsData(6)->Fill(multDdl0,multDdl1);
GetRecPointsData(7)->Fill(multDdl2,multDdl3);
GetRecPointsData(8)->Fill(multDdl4,multDdl5);
-
- recpoints->Delete() ;
- delete recpoints;
-
}
//____________________________________________________________________________
{
// make QA data from ESDs
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
-
Int_t premul = 0, cpvmul = 0;
for (Int_t icl = 0; icl < esd->GetNumberOfPmdTracks(); icl++)
virtual void InitRecPoints() ;
virtual void InitESDs() ;
virtual void MakeRaws(AliRawReader* rawReader) ;
- virtual void MakeDigits(TClonesArray* digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * recpoTree) ;
virtual void MakeRecPoints(TTree * recpoTree) ;
virtual void MakeESDs(AliESDEvent * esd) ;
}
//____________________________________________________________________________
-void AliPMDQADataMakerSim::MakeHits(TClonesArray *hits)
+void AliPMDQADataMakerSim::MakeHits()
{
//make QA data from Hits
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
Int_t premul = 0, cpvmul = 0;
Float_t edepkev = 0.;
- TIter next(hits);
+ TIter next(fHitsArray);
AliPMDhit * hit;
while ( (hit = dynamic_cast<AliPMDhit *>(next())) )
return;
}
- static TClonesArray statichits("AliPMDhit", 1000);
- statichits.Clear();
- TClonesArray *hits = &statichits;
- static TClonesArray staticdummy("AliPMDhit", 1000);
- staticdummy.Clear();
- TClonesArray *dummy = &staticdummy;
- branch->SetAddress(&dummy);
- Int_t index = 0 ;
-
- for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
- branch->GetEntry(ientry) ;
- for (Int_t ihit = 0 ; ihit < dummy->GetEntries() ; ihit++) {
- AliPMDhit * hit = dynamic_cast<AliPMDhit *> (dummy->At(ihit)) ;
- new((*hits)[index]) AliPMDhit(*hit) ;
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliPMDhit", 1000);
- index++ ;
- }
- }
-
- MakeHits(hits);
+ branch->SetAddress(&fHitsArray);
+ for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
+ branch->GetEntry(ientry) ;
+ MakeHits();
+ fHitsArray->Clear() ;
+ }
}
//____________________________________________________________________________
-void AliPMDQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliPMDQADataMakerSim::MakeSDigits()
{
// makes data from SDigits
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
-
Int_t cpvmul = 0, premul = 0;
Float_t edepkev = 0.;
- TIter next(sdigits) ;
+ TIter next(fSDigitsArray) ;
AliPMDsdigit * sdigit ;
while ( (sdigit = dynamic_cast<AliPMDsdigit *>(next())) )
{
{
// makes data from SDigit Tree
- TClonesArray * sdigits = new TClonesArray("AliPMDsdigit", 1000) ;
+ if (fSDigitsArray)
+ fSDigitsArray->Clear() ;
+ else
+ fSDigitsArray = new TClonesArray("AliPMDsdigit", 1000) ;
TBranch * branch = sdigitTree->GetBranch("PMDSDigit") ;
- branch->SetAddress(&sdigits) ;
+ branch->SetAddress(&fSDigitsArray) ;
- if ( ! branch )
- {
- AliWarning("PMD branch in SDigit Tree not found") ;
- }
- else
- {
- for (Int_t ient = 0; ient < branch->GetEntries(); ient++)
- {
- branch->GetEntry(ient) ;
- MakeSDigits(sdigits) ;
- }
+ if ( ! branch ){
+ AliWarning("PMD branch in SDigit Tree not found") ;
+ } else {
+ branch->GetEntry(0) ;
+ MakeSDigits() ;
}
}
//____________________________________________________________________________
-void AliPMDQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliPMDQADataMakerSim::MakeDigits()
{
// makes data from Digits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
Int_t cpvmul = 0, premul = 0;
- TIter next(digits) ;
+ TIter next(fDigitsArray) ;
AliPMDdigit * digit ;
while ( (digit = dynamic_cast<AliPMDdigit *>(next())) )
{
{
// makes data from Digit Tree
- TClonesArray * digits = new TClonesArray("AliPMDdigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliPMDdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("PMDDigit") ;
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
if ( ! branch )
{
{
for (Int_t ient = 0; ient < branch->GetEntries(); ient++)
{
- branch->GetEntry(ient) ;
- MakeDigits(digits) ;
+ branch->GetEntry(ient) ;
+ MakeDigits() ;
+ fDigitsArray->Clear() ;
+
}
-
+
}
}
virtual void InitSDigits();
virtual void InitDigits();
- virtual void MakeHits(TClonesArray * hits);
+ virtual void MakeHits();
virtual void MakeHits(TTree * hitTree) ;
- virtual void MakeSDigits(TClonesArray * sigits) ;
+ virtual void MakeSDigits() ;
virtual void MakeSDigits(TTree * sigitTree) ;
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * digitTree) ;
virtual void StartOfDetectorCycle() ;
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
test[specie] = 1.0 ;
- if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie))
continue ;
if (list[specie]->GetEntries() == 0)
test[specie] = 0. ; // nothing to check
Double_t AliQACheckerBase::DiffK(const TH1 * href, const TH1 * hin) const
{
// compares two histograms using the Kolmogorov test
- if ( hin->Integral() == 0 ) {
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Spectrum %s is empty", hin->GetName())) ;
+ if ( hin->Integral() == 0 || href->Integral() == 0) {
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Spectrum %s or its reference is empty", hin->GetName())) ;
return 0. ;
}
fRun(0),
fEventSpecie(AliRecoParam::kDefault),
fImage(new TCanvas*[AliRecoParam::kNSpecies]),
- fPrintImage(kTRUE)
+ fPrintImage(kTRUE),
+ fDigitsArray(NULL)
{
// ctor
fDetectorDirName = GetName() ;
fRun(qadm.fRun),
fEventSpecie(qadm.fEventSpecie),
fImage(qadm.fImage),
- fPrintImage(kTRUE)
-
+ fPrintImage(kTRUE),
+ fDigitsArray(NULL)
{
//copy ctor
fDetectorDirName = GetName() ;
}
delete[] fImage ;
delete[] fParameterList ;
+
+ if (fDigitsArray) {
+ fDigitsArray->Clear() ;
+ delete fDigitsArray ;
+ }
}
//____________________________________________________________________________
TH1 * histClone = NULL ;
TObjArray * arr = list[esindex] ;
if (arr) {
+ if ( ! arr->GetEntriesFast() ) {
+ // Initializes the histograms
+ TString arrName(arr->GetName()) ;
+ if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kRAWS)))
+ InitRaws() ;
+ else if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kHITS)))
+ InitHits() ;
+ else if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kSDIGITS)))
+ InitSDigits() ;
+ else if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kDIGITS)))
+ InitDigits() ;
+ else if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kDIGITSR)))
+ InitSDigits() ;
+ else if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)))
+ InitRecPoints() ;
+ else if (arrName.Contains(AliQAv1::GetTaskName(AliQAv1::kESDS)))
+ InitESDs() ;
+ }
if ( index > AliQAv1::GetMaxQAObj() ) {
AliError(Form("Max number of authorized QA objects is %d", AliQAv1::GetMaxQAObj())) ;
} else {
}
//____________________________________________________________________________
+Bool_t AliQADataMaker::IsValidEventSpecie(Int_t eventSpecieIndex, TObjArray ** list)
+{
+ // check if event specie was present in current run or
+ // if histograms of this event specie have been created
+ if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(eventSpecieIndex)) || ! list[eventSpecieIndex]->GetEntriesFast() )
+ return kFALSE ;
+ else
+ return kTRUE ;
+}
+
+//____________________________________________________________________________
void AliQADataMaker::MakeTheImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, const Char_t * mode)
{
// makes the QA image for sim and rec
nImages++;
}
if ( nImages == 0 ) {
- AliWarning(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
} else {
AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;
for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
virtual TObjArray** Init(AliQAv1::TASKINDEX_t, Int_t cycles = -1) = 0 ;
TObjArray* Init(AliQAv1::TASKINDEX_t, AliRecoParam::EventSpecie_t es, Int_t cycles = -1) ;
virtual void Init(AliQAv1::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
+ virtual void InitRaws() = 0 ;
Bool_t IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
+ Bool_t IsValidEventSpecie(Int_t eventSpecieIndex, TObjArray ** list) ;
virtual void MakeImage(AliQAv1::TASKINDEX_t task) = 0 ;
void Reset() { fCycleCounter = 0 ; }
void SetCycle(Int_t nevts) { fCycle = nevts ; }
virtual void InitHits() = 0 ;
//virtual void InitRecParticles() = 0 ;
virtual void InitRecPoints() = 0 ;
- virtual void InitRaws() = 0 ;
virtual void InitSDigits() = 0 ;
//virtual void InitTrackSegments() = 0 ;
virtual void MakeESDs(AliESDEvent * ) = 0 ;
- virtual void MakeHits(TClonesArray * ) = 0 ;
+ virtual void MakeHits() = 0 ;
virtual void MakeHits(TTree * ) = 0 ;
- virtual void MakeDigits(TClonesArray * ) = 0 ;
+ virtual void MakeDigits() = 0 ;
virtual void MakeDigits(TTree * ) = 0 ;
- //virtual void MakeRecParticles(TClonesArray * ) = 0 ;
+ //virtual void MakeRecParticles( ) = 0 ;
virtual void MakeRaws(AliRawReader *) = 0 ;
virtual void MakeRecPoints(TTree * ) = 0 ;
- virtual void MakeSDigits(TClonesArray * ) = 0 ;
+ virtual void MakeSDigits() = 0 ;
virtual void MakeSDigits(TTree * ) = 0 ;
//virtual void MakeTrackSegments(TTree * ) = 0 ;
virtual void MakeTheImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, const Char_t * mode) ;
AliRecoParam::EventSpecie_t fEventSpecie ; //! event specie, see AliRecoParam
TCanvas ** fImage ; //[AliRecoParam::kNSpecies]
Bool_t fPrintImage ; //! flag to print the images or not
+ TClonesArray * fDigitsArray ; //! array to hold the sdigits
+
private:
AliQADataMaker& operator = (const AliQADataMaker& /*qadm*/); // Not implemented
- ClassDef(AliQADataMaker,2) // description
+ ClassDef(AliQADataMaker,3) // description
};
fRawsQAList(NULL),
fRecPointsQAList(NULL),
fCorrNt(NULL),
- fRecoParam(NULL)
+ fRecoParam(NULL),
+ fRecPointsArray(NULL)
{
// ctor
fDetectorDirName = GetName() ;
fRawsQAList(qadm.fRawsQAList),
fRecPointsQAList(qadm.fRecPointsQAList),
fCorrNt(qadm.fCorrNt),
- fRecoParam(qadm.fRecoParam)
+ fRecoParam(qadm.fRecoParam),
+ fRecPointsArray(NULL)
{
//copy ctor
SetName(qadm.GetName()) ;
}
delete[] fRecPointsQAList ;
}
+ if (fRecPointsArray) {
+ fRecPointsArray->Clear() ;
+ delete fRecPointsArray ;
+ }
}
//__________________________________________________________________
if (!subDir)
subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
subDir->cd() ;
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) { // skip Default
+ if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) || AliRecoParam::ConvertIndex(specie) == AliRecoParam::kDefault)
continue ;
TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
if (!eventSpecieDir)
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 ; }
-
+
virtual TH1 * GetRecPointsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fRecPointsQAList, index)) ; }
virtual TH1 * GetRawsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fRawsQAList, index)) ; }
virtual TH1 * GetSDigitsData(const Int_t /*index*/) { return NULL ; }
virtual void MakeImage(AliQAv1::TASKINDEX_t task) ;
virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
virtual void Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+ virtual void InitRaws() {AliInfo("To be implemented by detectors");}
virtual void StartOfCycle(Int_t run = -1) ;
virtual void StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
virtual void SetRecoParam(const AliDetectorRecoParam *param) { fRecoParam = param; }
virtual void InitHits() {AliWarning("Call not valid") ; }
//virtual void InitRecParticles() {AliInfo("To be implemented by detectors");}
virtual void InitRecPoints() {AliInfo("To be implemented by detectors");}
- virtual void InitRaws() {AliInfo("To be implemented by detectors");}
virtual void InitSDigits() {AliWarning("Call not valid") ; }
//virtual void InitTrackSegments() {AliInfo("To ne implemented by detectors");}
virtual void MakeESDs(AliESDEvent * ) {AliInfo("To be implemented by detectors");}
- virtual void MakeHits(TClonesArray * ) {AliWarning("Call not valid") ; }
+ virtual void MakeHits() {AliWarning("Call not valid") ; }
virtual void MakeHits(TTree * ) {AliWarning("Call not valid") ; }
- virtual void MakeDigits(TClonesArray * ) {AliInfo("To be implemented by detectors");}
+ virtual void MakeDigits() {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 MakeRecParticles() {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(TClonesArray * ) {AliWarning("Call not valid") ; }
+ virtual void MakeSDigits() {AliWarning("Call not valid") ; }
virtual void MakeSDigits(TTree * ) {AliWarning("Call not valid") ; }
virtual void StartOfDetectorCycle() {AliInfo("To be implemented by detectors");}
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.
+ 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
+ TClonesArray * fRecPointsArray; //! Array that contains the RecPoints
ClassDef(AliQADataMakerRec,4) // description
AliQADataMaker(name, title),
fDigitsQAList(NULL),
fHitsQAList(NULL),
- fSDigitsQAList(NULL)
+ fSDigitsQAList(NULL),
+ fHitsArray(NULL),
+ fSDigitsArray(NULL)
{
// ctor
fDetectorDirName = GetName() ;
AliQADataMaker(qadm.GetName(), qadm.GetTitle()),
fDigitsQAList(qadm.fDigitsQAList),
fHitsQAList(qadm.fHitsQAList),
- fSDigitsQAList(qadm.fSDigitsQAList)
+ fSDigitsQAList(qadm.fSDigitsQAList),
+ fHitsArray(NULL),
+ fSDigitsArray(NULL)
{
//copy ctor
fDetectorDirName = GetName() ;
}
delete[] fSDigitsQAList ;
}
+ if (fHitsArray) {
+ fHitsArray->Clear() ;
+ delete fHitsArray ;
+ }
+ if (fSDigitsArray) {
+ fSDigitsArray->Clear() ;
+ delete fSDigitsArray ;
+ }
}
//__________________________________________________________________
if ( task == AliQAv1::kHITS ) {
AliDebug(AliQAv1::GetQADebugLevel(), "Processing Hits QA") ;
if (strcmp(data->ClassName(), "TClonesArray") == 0) {
- TClonesArray * arr = static_cast<TClonesArray *>(data) ;
- MakeHits(arr) ;
+ fHitsArray = static_cast<TClonesArray *>(data) ;
+ MakeHits() ;
} else if (strcmp(data->ClassName(), "TTree") == 0) {
TTree * tree = static_cast<TTree *>(data) ;
MakeHits(tree) ;
} else if ( task == AliQAv1::kSDIGITS ) {
AliDebug(AliQAv1::GetQADebugLevel(), "Processing SDigits QA") ;
if (strcmp(data->ClassName(), "TClonesArray") == 0) {
- TClonesArray * arr = static_cast<TClonesArray *>(data) ;
- MakeSDigits(arr) ;
+ fSDigitsArray = static_cast<TClonesArray *>(data) ;
+ MakeSDigits() ;
} else if (strcmp(data->ClassName(), "TTree") == 0) {
TTree * tree = static_cast<TTree *>(data) ;
MakeSDigits(tree) ;
} else if ( task == AliQAv1::kDIGITS ) {
AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ;
if (strcmp(data->ClassName(), "TClonesArray") == 0) {
- TClonesArray * arr = static_cast<TClonesArray *>(data) ;
- MakeDigits(arr) ;
+ fDigitsArray = static_cast<TClonesArray *>(data) ;
+ MakeDigits() ;
} else if (strcmp(data->ClassName(), "TTree") == 0) {
TTree * tree = static_cast<TTree *>(data) ;
MakeDigits(tree) ;
virtual TH1 * GetSDigitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fSDigitsQAList, index)) ; }
virtual TObjArray** Init(AliQAv1::TASKINDEX_t task, Int_t cycles = -1) ;
virtual void Init(AliQAv1::TASKINDEX_t task, TObjArray ** list, Int_t run, Int_t cycles = -1) ;
+ virtual void InitRaws() {AliWarning("Call not valid") ; }
virtual void MakeImage(AliQAv1::TASKINDEX_t task) ;
virtual void StartOfCycle(Int_t run = -1) ;
virtual void StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
virtual void InitESDs() {AliWarning("Call not valid") ; }
virtual void InitHits() {AliInfo("To be implemented by detectors");}
virtual void InitRecPoints() {AliWarning("Call not valid") ; }
- virtual void InitRaws() {AliWarning("Call not valid") ; }
virtual void InitSDigits() {AliInfo("To be implemented by detectors");}
virtual void MakeESDs(AliESDEvent * ) {AliWarning("Call not valid") ; }
- virtual void MakeHits(TClonesArray * ) {AliInfo("To be implemented by detectors");}
+ virtual void MakeHits() {AliInfo("To be implemented by detectors");}
virtual void MakeHits(TTree * ) {AliInfo("To be implemented by detectors");}
- virtual void MakeDigits(TClonesArray * ) {AliInfo("To be implemented by detectors");}
+ virtual void MakeDigits() {AliInfo("To be implemented by detectors");}
virtual void MakeDigits(TTree * ) {AliInfo("To be implemented by detectors");}
virtual void MakeRaws(AliRawReader *) {AliWarning("Call not valid") ; }
virtual void MakeRecPoints(TTree * ) {AliWarning("Call not valid") ; }
- virtual void MakeSDigits(TClonesArray * ) {AliInfo("To be implemented by detectors");}
+ virtual void MakeSDigits() {AliInfo("To be implemented by detectors");}
virtual void MakeSDigits(TTree * ) {AliInfo("To be implemented by detectors");}
virtual void StartOfDetectorCycle() {AliInfo("To be implemented by detectors");}
TObjArray * * fDigitsQAList ; //! list of the digits QA data objects
TObjArray * * fHitsQAList ; //! list of the hits QA data objects
TObjArray * * fSDigitsQAList ; //! list of the sdigits QA data objects
+ TClonesArray * fHitsArray ; //! array to hold the hits
+ TClonesArray * fSDigitsArray ; //! array to hold the digits
+
- ClassDef(AliQADataMakerSim,1) // description
+ ClassDef(AliQADataMakerSim,2) // description
};
if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
- } else if ( iDet != AliQAv1::kCORR ) {
+ } else if ( iDet < AliQAv1::kHLT ) {
// load the QA data maker object
TPluginManager* pluginManager = gROOT->GetPluginManager() ;
const UInt_t AliQAv1::fgkImageBit = 0x100000 ;
const Int_t AliQAv1::fgkQADebugLevel = 99 ;
const TString AliQAv1::fImageFileName = "QAImage" ;
-const TString AliQAv1::fImageFileFormat = "eps" ;
+const TString AliQAv1::fImageFileFormat = "pdf" ;
const UShort_t AliQAv1::fgkMaxQAObjects = 10000 ;
//____________________________________________________________________________
void Set(QABIT_t bit, AliRecoParam::EventSpecie_t es) ;
void Set(QABIT_t bit, Int_t es) ;
void SetEventSpecie(AliRecoParam::EventSpecie_t es)
- {Int_t ibit=0; while(es!=1<<ibit) ++ibit; fEventSpecies[ibit] = kTRUE ; }
+ {if(es==AliRecoParam::kDefault) return; Int_t ibit=0; while(es!=1<<ibit) ++ibit; fEventSpecies[ibit] = kTRUE ; }
static void SetQADebug() { AliLog::SetGlobalDebugLevel(GetQADebugLevel()); }
static void SetQAResultDirName(const char * name) ;
static void SetQARefStorage(const char * name) ;
reconstructor->SetRecoParam(par);
if (fRunQA) {
AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
+ AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
}
}
}
// do the QA checking
AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ if (! IsValidEventSpecie(specie, list))
continue ;
- SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
if ( task == AliQAv1::kRAWS ) {
const Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
for (Int_t itr=0; itr<6; itr++) {
//____________________________________________________________________________
void AliT0QADataMakerRec::MakeRaws( AliRawReader* rawReader)
{
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
rawReader->Reset() ;
//fills QA histos for RAW
void AliT0QADataMakerRec::MakeDigits( TTree *digitsTree)
{
//fills QA histos for Digits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
TArrayI *digCFD = new TArrayI(24);
TArrayI *digLED = new TArrayI(24);
AliError(Form("EXEC Branch T0 rec not found "));
return;
}
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(0) )
- InitRecPoints() ;
brRec->GetEntry(0);
{
//fills QA histos for ESD
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
-
GetESDsData(0) -> Fill(esd->GetT0());
GetESDsData(1)-> Fill(esd->GetT0zVertex());
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() {;}
virtual void MakeDigits(TTree * digTree);
virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
void AliT0QADataMakerSim::MakeHits(TTree *hitTree)
{
//fills QA histos for Hits
- TClonesArray * hits = new TClonesArray("AliT0hit", 1000);
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliT0hit", 1000);
TBranch * branch = hitTree->GetBranch("T0") ;
if ( ! branch ) {
} else {
if (branch) {
- branch->SetAddress(&hits);
+ branch->SetAddress(&fHitsArray);
}else{
AliError("Branch T0 hit not found");
exit(111);
if (ntracks<=0) return;
// Start loop on tracks in the hits containers
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
for (Int_t track=0; track<ntracks;track++) {
branch->GetEntry(track);
- Int_t nhits = hits->GetEntriesFast();
+ Int_t nhits = fHitsArray->GetEntriesFast();
for (Int_t ihit=0;ihit<nhits;ihit++)
{
- AliT0hit * startHit = (AliT0hit*) hits->UncheckedAt(ihit);
+ AliT0hit * startHit = (AliT0hit*) fHitsArray->UncheckedAt(ihit);
if (!startHit) {
AliError("The unchecked hit doesn't exist");
continue;
return;
}
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
digitsTree->GetEvent(0);
digitsTree->GetEntry(0);
brDigits->GetEntry(0);
virtual void InitHits() ; //book hit QA histo
virtual void InitDigits() ; //book Digit QA histo
virtual void MakeHits(TTree * hits) ; //Fill hit QA histo
- virtual void MakeHits(TClonesArray *) {} //Dummy for the moment
+ virtual void MakeHits() {} //Dummy for the moment
virtual void MakeDigits(TTree* digitsTree) ; //Fill Digit QA histo
- virtual void MakeDigits(TClonesArray *) {} //Dummy for the moment
+ virtual void MakeDigits() {} //Dummy for the moment
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void StartOfDetectorCycle() ;
ClassDef(AliT0QADataMakerSim,1) // description
// makes data from Raws
//
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
-
Double_t tdc2ns=AliTOFGeometry::TdcBinWidth()*1E-3;
Double_t tot2ns=AliTOFGeometry::ToTBinWidth()*1E-3;
}
//____________________________________________________________________________
-void AliTOFQADataMakerRec::MakeDigits(TClonesArray * digits)
+void AliTOFQADataMakerRec::MakeDigits()
{
//
// makes data from Digits
Int_t in[5];
Int_t out[5];
- Int_t nentries=digits->GetEntriesFast();
+ Int_t nentries=fDigitsArray->GetEntriesFast();
if(nentries<=0){
GetDigitsData(0)->Fill(-1.) ;
}else{
GetDigitsData(0)->Fill(TMath::Log10(nentries)) ;
}
- TIter next(digits) ;
+ TIter next(fDigitsArray) ;
AliTOFdigit * digit ;
while ( (digit = dynamic_cast<AliTOFdigit *>(next())) ) {
//
// makes data from Digit Tree
//
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
- TClonesArray * digits = new TClonesArray("AliTOFdigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliTOFdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("TOF") ;
if ( ! branch ) {
AliError("TOF branch in Digit Tree not found") ;
return;
}
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
//____________________________________________________________________________
//
// Make data from Clusters
//
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(0) )
- InitRecPoints() ;
-
+
Double_t tdc2ns=AliTOFGeometry::TdcBinWidth()*1E-3;
Double_t tot2ns=AliTOFGeometry::ToTBinWidth()*1E-3;
//
// make QA data from ESDs
//
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
Int_t ntrk = esd->GetNumberOfTracks() ;
Int_t ntof=0;
virtual void MakeESDs(AliESDEvent * esd) ;
virtual void MakeRecPoints(TTree * recTree) ;
virtual void MakeDigits(TTree * recTree) ;
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void StartOfDetectorCycle() ;
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
}
//____________________________________________________________________________
-void AliTOFQADataMakerSim::MakeHits(TClonesArray * hits)
+void AliTOFQADataMakerSim::MakeHits()
{
//
//make QA data from Hits
//
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
Int_t in[5];
Int_t out[5];
- Int_t nentries=hits->GetEntriesFast();
+ Int_t nentries= fHitsArray->GetEntriesFast();
if(nentries<=0) {
GetHitsData(0)->Fill(-1.) ;
} else{
GetHitsData(0)->Fill(TMath::Log10(nentries)) ;
}
- TIter next(hits) ;
+ TIter next(fHitsArray) ;
AliTOFhitT0 * hit ;
while ( (hit = dynamic_cast<AliTOFhitT0 *>(next())) ) {
GetMapIndeces(in,out);
GetHitsData(3)->Fill( out[0],out[1]) ;//hit map
}
-
}
return;
}
- static TClonesArray statichits("AliTOFhitT0", 1000);
- statichits.Clear();
- TClonesArray *hits = &statichits;
- static TClonesArray staticdummy("AliTOFhitT0", 1000);
- staticdummy.Clear();
- TClonesArray *dummy = &staticdummy;
- branch->SetAddress(&dummy);
- Int_t index = 0 ;
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliTOFhitT0", 1000) ;
+
+ branch->SetAddress(&fHitsArray);
for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
branch->GetEntry(ientry) ;
- for (Int_t ihit = 0 ; ihit < dummy->GetEntries() ; ihit++) {
- AliTOFhitT0 * hit = dynamic_cast<AliTOFhitT0 *> (dummy->At(ihit)) ;
- new((*hits)[index]) AliTOFhitT0(*hit) ;
- index++ ;
- }
+ MakeHits() ;
+ fHitsArray->Clear() ;
}
-
- MakeHits(hits) ;
-
}
//____________________________________________________________________________
-void AliTOFQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliTOFQADataMakerSim::MakeDigits()
{
//
// makes data from Digits
//
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
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();
+ Int_t nentries=fDigitsArray->GetEntriesFast();
if(nentries<=0){
GetDigitsData(0)->Fill(-1.) ;
}else{
GetDigitsData(0)->Fill(TMath::Log10(nentries)) ;
}
- TIter next(digits) ;
+ TIter next(fDigitsArray) ;
AliTOFdigit * digit ;
while ( (digit = dynamic_cast<AliTOFdigit *>(next())) ) {
//
// makes data from Digit Tree
//
- TClonesArray * digits = new TClonesArray("AliTOFdigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliTOFdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("TOF") ;
if ( ! branch ) {
AliError("TOF branch in Digit Tree not found") ;
return;
}
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
//____________________________________________________________________________
-void AliTOFQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliTOFQADataMakerSim::MakeSDigits()
{
//
// makes data from SDigits
//
-
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
Double_t tdc2ns=AliTOFGeometry::TdcBinWidth()*1E-3;
Int_t in[5];
Int_t out[5];
- Int_t nentries=sdigits->GetEntriesFast();
+ Int_t nentries=fSDigitsArray->GetEntriesFast();
if(nentries<=0){
GetSDigitsData(0)->Fill(-1.) ;
}else{
GetSDigitsData(0)->Fill(TMath::Log10(nentries)) ;
}
- TIter next(sdigits) ;
+ TIter next(fSDigitsArray) ;
AliTOFSDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliTOFSDigit *>(next())) ) {
//
// makes data from SDigit Tree
//
- TClonesArray * sdigits = new TClonesArray("AliTOFSDigit", 1000) ;
+ if (fSDigitsArray)
+ fSDigitsArray->Clear() ;
+ else
+ fSDigitsArray = new TClonesArray("AliTOFSDigit", 1000) ;
TBranch * branch = sdigitTree->GetBranch("TOF") ;
if ( ! branch ) {
AliError("TOF branch in SDigit Tree not found") ;
return;
}
- branch->SetAddress(&sdigits) ;
+ branch->SetAddress(&fSDigitsArray) ;
branch->GetEntry(0) ;
- MakeSDigits(sdigits) ;
+ MakeSDigits() ;
}
//____________________________________________________________________________
virtual void InitHits() ;
virtual void InitDigits() ;
virtual void InitSDigits() ;
- virtual void MakeHits(TClonesArray * hits) ;
+ virtual void MakeHits() ;
virtual void MakeHits(TTree * hitTree);
- virtual void MakeDigits(TClonesArray * digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree * digTree);
- virtual void MakeSDigits(TClonesArray * sdigits) ;
+ virtual void MakeSDigits() ;
virtual void MakeSDigits(TTree * sdigTree);
virtual void StartOfDetectorCycle() ;
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list) ;
{
// make QA data from ESDs
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(KClusters) )
- InitESDs() ;
-
const Int_t nESDTracks = esd->GetNumberOfTracks();
Int_t nTPCtracks = 0;
for(Int_t i = 0; i < nESDTracks; i++) {
// To make QA for the RAW data we use the TPC Calibration framework
// to handle the data and then in the end extract the data
//
- if ( ! GetRawsData(kOccupancy) )
- InitRaws() ;
rawReader->Reset() ;
- fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
- }
+ if (! fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)] ) {
+ AliError("Something unexpected here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") ;
+ } else {
+ fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
+ }
+}
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
{
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(kDigitsADC) )
- InitDigits() ;
-
+
TBranch* branch = digitTree->GetBranch("Segment");
AliSimDigits* digArray = 0;
branch->SetAddress(&digArray);
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
{
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(kQmaxShort) )
- InitRecPoints() ;
AliTPCClustersRow *clrow = new AliTPCClustersRow();
clrow->SetClass("AliTPCclusterMI");
// Digits QA
virtual void InitDigits();
- virtual void MakeDigits(TClonesArray* /*digits*/) {return;}
+ virtual void MakeDigits() {return;}
virtual void MakeDigits(TTree *digTree);
// RecPoints QA
//____________________________________________________________________________
void AliTPCQADataMakerSim::MakeDigits(TTree* digitTree)
{
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(kDigitsADC) )
- InitDigits() ;
TBranch* branch = digitTree->GetBranch("Segment");
AliSimDigits* digArray = 0;
{
// make QA data from Hit Tree
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(kNhits) )
- InitHits() ;
-
const Int_t nTracks = hitTree->GetEntries();
TBranch* branch = hitTree->GetBranch("TPC2");
AliTPCv2* tpc = (AliTPCv2*)gAlice->GetDetector("TPC");
// Digits QA
virtual void InitDigits();
virtual void MakeDigits(TTree *digitTree);
- virtual void MakeDigits(TClonesArray *) {AliWarning("Method not implemented\n");}
+ virtual void MakeDigits() {AliWarning("Method not implemented\n");}
// Hits QA
virtual void InitHits();
virtual void MakeHits(TTree *hitTree);
- virtual void MakeHits(TClonesArray *) {AliWarning("Method not implemented\n");}
+ virtual void MakeHits() {AliWarning("Method not implemented\n");}
// SDigits QA (empty)
virtual void InitSDigits() {}
virtual void MakeSDigits(TTree* ) {AliWarning("Method not implemented\n");}
- virtual void MakeSDigits(TClonesArray* ) {AliWarning("Method not implemented\n");}
+ virtual void MakeSDigits() {AliWarning("Method not implemented\n");}
ClassDef(AliTPCQADataMakerSim,1) // TPC Sim Quality Assurance Data Maker
};
// loop over event types
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ if (! IsValidEventSpecie(specie, list))
continue ;
- //list[specie]->Print();
+ //list[specie]->Print();
// fill detector map;
for(Int_t i = 0 ; i < 540 ; i++) {
// create ratios
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ if (! IsValidEventSpecie(specie, list))
continue ;
- for(Int_t type = 0 ; type < 2 ; type++) {
+ for(Int_t type = 0 ; type < 2 ; type++) {
for(Int_t i = 0 ; i < knRatio ; i++) {
TH1D *ratio = (TH1D*)list[specie]->At(19 + 2*i + type);
TH1D *histN = (TH1D*)list[specie]->At(3 + 2*kN[i] + type);
//
// Make QA data from ESDs
//
-
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(0) )
- InitESDs() ;
Int_t nTracks = esd->GetNumberOfTracks();
GetESDsData(0)->Fill(nTracks);
//
AliInfo("Execution of QA for Raw data");
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(0) )
- InitRaws() ;
-
+
//printf("Execution of QA for Raw data\n");
// create raw reader TB
//
// Info("MakeRecPoints", "making");
-
- // Check id histograms already created for this Event Specie
- if ( ! GetRecPointsData(0) )
- InitRecPoints() ;
-
+
Int_t nsize = Int_t(clustersTree->GetTotBytes() / (sizeof(AliTRDcluster)));
TObjArray *clusterArray = new TObjArray(nsize+1000);
//____________________________________________________________________________
AliTRDQADataMakerSim::AliTRDQADataMakerSim() :
- AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker")
+ AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kTRD), "TRD Quality Assurance Data Maker"),
+ fTmpHits(NULL)
{
//
// Default constructor
//____________________________________________________________________________
AliTRDQADataMakerSim::AliTRDQADataMakerSim(const AliTRDQADataMakerSim& qadm) :
- AliQADataMakerSim()
+ AliQADataMakerSim(),
+ fTmpHits(NULL)
{
//
// Copy constructor
}
//____________________________________________________________________________
+AliTRDQADataMakerSim::~AliTRDQADataMakerSim()
+{
+ if (fTmpHits) {
+ fTmpHits->Clear() ;
+ delete fTmpHits ;
+ }
+}
+
+//____________________________________________________________________________
void AliTRDQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//
}
//____________________________________________________________________________
-void AliTRDQADataMakerSim::MakeHits(TClonesArray * hits)
+void AliTRDQADataMakerSim::MakeHits()
{
//
// Make QA data from Hits
//
-
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
- TIter next(hits);
+
+ TIter next(fHitsArray);
AliTRDhit * hit;
while ( (hit = dynamic_cast<AliTRDhit *>(next())) ) {
if (!CheckPointer(branch, "TRD hits branch")) return;
Int_t nhits = (Int_t)(hitTree->GetTotBytes()/sizeof(AliTRDhit));
- TClonesArray *hits = new TClonesArray("AliTRDhit", nhits+1000);
- TClonesArray *tmp = new TClonesArray("AliTRDhit", 1000);
- branch->SetAddress(&tmp);
-
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliTRDhit", nhits+1000);
+
Int_t index = 0;
Int_t nEntries = (Int_t)branch->GetEntries();
for(Int_t i = 0; i < nEntries; i++) {
branch->GetEntry(i);
- Int_t nHits = (Int_t)tmp->GetEntries();
- for(Int_t j=0; j<nHits; j++) {
- AliTRDhit *hit = (AliTRDhit*)tmp->At(j);
- new((*hits)[index++]) AliTRDhit(*hit);
- }
+ MakeHits();
+ fHitsArray->Clear() ;
}
-
- tmp->Delete();
- delete tmp;
- MakeHits(hits);
- hits->Delete();
- delete hits;
-
}
//____________________________________________________________________________
-void AliTRDQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliTRDQADataMakerSim::MakeDigits()
{
//
// Makes data from Digits
//
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
+ if (!fDigitsArray)
+ return ;
- TIter next(digits) ;
+ TIter next(fDigitsArray) ;
AliTRDdigit * digit ;
// Info("Make digits", "From the arrya");
//
// Makes data from digits tree
//
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
// Info("Make digits", "From a tree");
AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
}
//____________________________________________________________________________
-void AliTRDQADataMakerSim::MakeSDigits(TClonesArray * sdigits)
+void AliTRDQADataMakerSim::MakeSDigits()
{
//
// Makes data from Digits
//
- // Check id histograms already created for this Event Specie
- if ( ! GetSDigitsData(0) )
- InitSDigits() ;
-
- TIter next(sdigits) ;
+ if (!fSDigitsArray)
+ return ;
+
+ TIter next(fSDigitsArray) ;
AliTRDdigit * digit ;
while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
GetDigitsData(0)->Fill(digit->GetDetector());
AliTRDQADataMakerSim() ; // ctor
AliTRDQADataMakerSim(const AliTRDQADataMakerSim& qadm) ;
AliTRDQADataMakerSim& operator = (const AliTRDQADataMakerSim& qadm) ;
- virtual ~AliTRDQADataMakerSim() {;} // dtor
+ virtual ~AliTRDQADataMakerSim() ; // dtor
private:
virtual void InitSDigits() ;
virtual void MakeHits(TTree * hitTree);
- virtual void MakeHits(TClonesArray * hits);
+ virtual void MakeHits();
virtual void MakeSDigits(TTree *sdigitTree);
- virtual void MakeSDigits(TClonesArray * sigits);
+ virtual void MakeSDigits();
virtual void MakeDigits(TTree *digitTree);
- virtual void MakeDigits(TClonesArray * digits);
+ virtual void MakeDigits();
virtual void StartOfDetectorCycle() ;
Int_t CheckPointer(TObject *obj, const char *name);
+ TClonesArray *fTmpHits ;
ClassDef(AliTRDQADataMakerSim,1) // Creates the TRD QA data
AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie)) )
+ if (! IsValidEventSpecie(specie, list))
continue ;
SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
if(task == AliQAv1::kRAWS){
}
//____________________________________________________________________________
-void AliVZEROQADataMakerRec::MakeDigits(TClonesArray * digits)
+void AliVZEROQADataMakerRec::MakeDigits()
{
// makes data from Digits
-
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
- GetDigitsData(0)->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
+ GetDigitsData(0)->Fill(fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
AliVZEROdigit *VZERODigit ;
while ( (VZERODigit = dynamic_cast<AliVZEROdigit *>(next())) ) {
Int_t PMNumber = VZERODigit->PMNumber();
{
// makes data from Digit Tree
- TClonesArray * digits = new TClonesArray("AliVZEROdigit", 1000) ;
+ if ( fDigitsArray )
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliVZEROdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("VZERODigit") ;
if ( ! branch ) {
AliWarning("VZERO branch in Digit Tree not found") ;
} else {
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
{
// Creates QA data from ESDs
- // Check id histograms already created for this Event Specie
- if ( ! GetESDsData(kCellMultiV0A) )
- InitESDs() ;
-
UInt_t eventType = esd->GetEventType();
switch (eventType){
AliVZEROQADataMakerRec& operator = (const AliVZEROQADataMakerRec& qadm) ;
virtual ~AliVZEROQADataMakerRec() {;} // destructor
AliVZEROCalibData *GetCalibData() const;
+ virtual void InitRaws() ;
protected:
AliVZEROCalibData *fCalibData; //! calibration data
private:
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
virtual void InitESDs() ;
- virtual void InitRaws() ;
virtual void InitDigits();
virtual void MakeESDs(AliESDEvent * esd) ;
virtual void MakeRaws(AliRawReader* rawReader) ;
- virtual void MakeDigits(TClonesArray* digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree* digitTree) ;
virtual void StartOfDetectorCycle() ;
//____________________________________________________________________________
-void AliVZEROQADataMakerSim::MakeHits(TClonesArray * hits)
+void AliVZEROQADataMakerSim::MakeHits()
{
//make QA data from Hits
- // Check id histograms already created for this Event Specie
- if ( ! GetHitsData(0) )
- InitHits() ;
-
- GetHitsData(0)->Fill(hits->GetEntriesFast()) ; // fills Hit multiplicity
- Int_t nhits = hits->GetEntriesFast();
+ Int_t nhits = fHitsArray->GetEntriesFast();
+ GetHitsData(0)->Fill(nhits) ; // fills Hit multiplicity
for (Int_t ihit=0;ihit<nhits;ihit++)
{
- AliVZEROhit * VZEROHit = (AliVZEROhit*) hits->UncheckedAt(ihit);
+ AliVZEROhit * VZEROHit = (AliVZEROhit*) fHitsArray->UncheckedAt(ihit);
if (!VZEROHit) {
AliError("The unchecked hit doesn't exist");
break;
void AliVZEROQADataMakerSim::MakeHits(TTree *hitTree)
{
//fills QA histos for Hits
- TClonesArray * hits = new TClonesArray("AliVZEROhit", 1000);
+ if (fHitsArray)
+ fHitsArray->Clear() ;
+ else
+ fHitsArray = new TClonesArray("AliVZEROhit", 1000);
TBranch * branch = hitTree->GetBranch("VZERO") ;
if ( ! branch ) {
} else {
if (branch) {
- branch->SetAddress(&hits);
+ branch->SetAddress(&fHitsArray);
}else{
AliError("Branch VZERO hit not found");
exit(111);
// Start loop on tracks in the hits containers
for (Int_t track=0; track<ntracks;track++) {
branch->GetEntry(track);
- GetHitsData(0)->Fill(hits->GetEntriesFast()) ; // fills Hit multiplicity
- Int_t nhits = hits->GetEntriesFast();
+ Int_t nhits = fHitsArray->GetEntriesFast();
+ GetHitsData(0)->Fill(nhits) ; // fills Hit multiplicity
for (Int_t ihit=0;ihit<nhits;ihit++)
{
- AliVZEROhit * VZEROHit = (AliVZEROhit*) hits->UncheckedAt(ihit);
+ AliVZEROhit * VZEROHit = (AliVZEROhit*) fHitsArray->UncheckedAt(ihit);
if (!VZEROHit) {
AliError("The unchecked hit doesn't exist");
break;
//____________________________________________________________________________
-void AliVZEROQADataMakerSim::MakeDigits(TClonesArray * digits)
+void AliVZEROQADataMakerSim::MakeDigits()
{
// makes data from Digits
- // Check id histograms already created for this Event Specie
- if ( ! GetDigitsData(0) )
- InitDigits() ;
-
- GetDigitsData(0)->Fill(digits->GetEntriesFast()) ;
- TIter next(digits) ;
+ GetDigitsData(0)->Fill(fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
AliVZEROdigit *VZERODigit ;
while ( (VZERODigit = dynamic_cast<AliVZEROdigit *>(next())) ) {
Int_t PMNumber = VZERODigit->PMNumber();
{
// makes data from Digit Tree
- TClonesArray * digits = new TClonesArray("AliVZEROdigit", 1000) ;
+ if (fDigitsArray)
+ fDigitsArray->Clear() ;
+ else
+ fDigitsArray = new TClonesArray("AliVZEROdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("VZERODigit") ;
if ( ! branch ) {
AliWarning("VZERO branch in Digit Tree not found") ;
} else {
- branch->SetAddress(&digits) ;
+ branch->SetAddress(&fDigitsArray) ;
branch->GetEntry(0) ;
- MakeDigits(digits) ;
+ MakeDigits() ;
}
}
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list);
virtual void InitHits();
virtual void InitDigits();
- virtual void MakeHits(TClonesArray* hits) ;
+ virtual void MakeHits() ;
virtual void MakeHits(TTree* hitTree) ;
- virtual void MakeDigits(TClonesArray* digits) ;
+ virtual void MakeDigits() ;
virtual void MakeDigits(TTree* digitTree) ;
virtual void StartOfDetectorCycle() ;
virtual void InitRecPoints() {;}
virtual void InitRaws();
virtual void MakeDigits(TTree * /*recTree*/) ;
- virtual void MakeDigits(TClonesArray* /*digits*/) {return;}
+ virtual void MakeDigits() {return;}
virtual void MakeRecPoints(TTree * /*recTree*/) {;}
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void MakeESDs(AliESDEvent * esd) ;
//____________________________________________________________________________ \r
AliZDCQADataMakerSim::AliZDCQADataMakerSim() : \r
AliQADataMakerSim(AliQAv1::GetDetName(AliQAv1::kZDC), "ZDC Quality Assurance Data Maker"),\r
- fHits(0),\r
fDigit(0)\r
{\r
// ctor\r
//____________________________________________________________________________ \r
AliZDCQADataMakerSim::AliZDCQADataMakerSim(const AliZDCQADataMakerSim& qadm) :\r
AliQADataMakerSim(), \r
- fHits(0),\r
fDigit(0) \r
{\r
//copy ctor \r
}\r
\r
//____________________________________________________________________________\r
-void AliZDCQADataMakerSim::MakeHits(TClonesArray * /*data*/)\r
+void AliZDCQADataMakerSim::MakeHits()\r
{\r
//filling QA histos for Hits\r
//\r
if ( ! GetHitsData(0) )\r
InitHits() ;\r
\r
- TIter next(fHits); \r
+ TIter next(fHitsArray); \r
AliZDCHit * hit; \r
while((hit = dynamic_cast<AliZDCHit *>(next()))){\r
if(hit->GetVolume(0)==1) GetHitsData(0)->Fill(hit->GetXImpact(),hit->GetYImpact());\r
return;\r
} \r
else{\r
+ if (fHitsArray) \r
+ fHitsArray->Clear() ; \r
char** add = (char**) (branch->GetAddress());\r
if(add){\r
- fHits = (TClonesArray*)(*add);\r
+ fHitsArray = (TClonesArray*)(*add);\r
} \r
else{\r
- if(!fHits) fHits = new TClonesArray("AliZDCHit", 1000);\r
- branch->SetAddress(&fHits);\r
+ if(!fHitsArray) fHitsArray = new TClonesArray("AliZDCHit", 1000);\r
+ branch->SetAddress(&fHitsArray);\r
}\r
Int_t ntracks = (Int_t) hitTree->GetEntries();\r
//printf("\n\t *** no.track %d\n",ntracks);\r
//printf("\n");\r
//\r
MakeHits(); \r
- fHits->Clear();\r
+ fHitsArray->Clear();\r
} \r
}\r
}\r
virtual void InitHits(); \r
virtual void InitDigits(); \r
virtual void InitSDigits() {;} \r
- virtual void MakeHits(TClonesArray * hits = 0);\r
+ virtual void MakeHits();\r
virtual void MakeHits(TTree * hitTree);\r
- virtual void MakeDigits(TClonesArray * /*digits*/){;} \r
+ virtual void MakeDigits(){;} \r
virtual void MakeDigits(TTree * digTree);\r
- virtual void MakeSDigits(TClonesArray * /*sdigits*/) {;} \r
+ virtual void MakeSDigits() {;} \r
virtual void MakeSDigits(TTree * /*sdigTree*/) {;}\r
virtual void StartOfDetectorCycle(); \r
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);\r
//\r
- TClonesArray *fHits; //! Array containing ZDC hits\r
AliZDCDigit *fDigit; //! Pointer to digit in tree \r
\r
ClassDef(AliZDCQADataMakerSim,2) // description \r
-void sim(Int_t nev=20) {
+void sim(Int_t nev=1) {
if (gSystem->Getenv("EVENT"))
nev = atoi(gSystem->Getenv("EVENT")) ;
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff