if (hdata) {
Double_t rv = 0.0 ;
if(hdata->GetEntries()>0)rv=1;
- AliInfo(Form("%s -> %f", hdata->GetName(), rv)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv)) ;
count[specie]++ ;
test[specie] += rv ;
}
}
}
- // AliInfo(Form("Test Result = %f", test[specie])) ;
+ // AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test[specie])) ;
}
return test ;
}
{
//Detector specific actions at end of cycle
// do the QA checking
- AliInfo("ACORDE---->Detector specific actions at END of cycle\n................\n");
+ AliDebug(AliQAv1::GetQADebugLevel(), "ACORDE---->Detector specific actions at END of cycle\n................\n");
AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;
}
void AliACORDEQADataMakerSim::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
- AliInfo("ACORDE---->Detector specific actions at START of cycle\n................\n");
+ AliDebug(AliQAv1::GetQADebugLevel(), "ACORDE---->Detector specific actions at START of cycle\n................\n");
}
//____________________________________________________________________________
void AliACORDEQADataMakerSim::InitHits()
if(h.Contains("size MIP")) if(TMath::Abs(histo->GetMean()-5) > 2) counter++;
if(h.Contains("size Phots")) if(TMath::Abs(histo->GetMean()-2) > 2) counter++;
if(h.Contains("distribution")) if(histo->KolmogorovTest((TH1F *)listref->At(0))<0.8) counter++;
- AliDebug(1,Form(" Kolm. test : %f ",histo->KolmogorovTest((TH1F *)listref->At(0))));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form(" Kolm. test : %f ",histo->KolmogorovTest((TH1F *)listref->At(0))));
}
}
Float_t response = counter/(7.+7.+42.+42.); // 7.+7.+42 +42 = N checked histograms (-> To be replaced by listrec->GetEntries())
// Standard constructor
fkOnline = kMode; fDet = subDet; fLDC = ldc;
if(fDet == 0 || fDet == 1) {
- AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SPD Checker\n");
}
if(fDet == 0 || fDet == 2) {
- AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SDD Checker\n");
}
if(fDet == 0 || fDet == 3) {
- AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SSD Checker\n");
}
}
rv[specie] = 0.0 ;
if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
continue ;
- AliDebug(1,"Checker for ESD");
+ AliDebug(AliQAv1::GetQADebugLevel(),"Checker for ESD");
Int_t tested = 0;
Int_t empty = 0;
// The following flags are set to kTRUE if the corresponding
Double_t entries = hdata->GetEntries();
++tested;
if(!(entries>0.))++empty;
- AliDebug(1,Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("ESD hist name %s - entries %12.1g",hname.Data(),entries));
if(hname.Contains("hESDClusterMapSA") && entries>0.){
cluMapSA = kTRUE;
- AliDebug(1,Form("Processing histogram %s",hname.Data()));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
// Check if there are layers with anomalously low
// contributing points to SA reconstructed tracks
for(Int_t k=1;k<7;k++){
if(skipped[k-1]) continue;
if(hdata->GetBinContent(k)<0.5*(entries/6.)){
cluMapSA = kFALSE;
- AliInfo(Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("SA tracks have few points on layer %d - look at histogram hESDClustersSA",k));
}
}
}
else if(hname.Contains("hESDClusterMapMI") && entries>0.){
// Check if there are layers with anomalously low
// contributing points to MI reconstructed tracks
- AliDebug(1,Form("Processing histogram %s",hname.Data()));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
cluMapMI = kTRUE;
for(Int_t k=1;k<7;k++){
// check if the layer was skipped
if(skipped[k-1]) continue;
if(hdata->GetBinContent(k)<0.5*(entries/6.)){
cluMapMI = kFALSE;
- AliInfo(Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("MI tracks have few points on layer %d - look at histogram hESDClustersMI",k));
}
}
}
else if(hname.Contains("hESDClustersMI") && entries>0.){
// Check if 6 clusters MI tracks are the majority
- AliDebug(1,Form("Processing histogram %s",hname.Data()));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
cluMI = kTRUE;
Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
for(Int_t k=2; k<7-nskipped; k++){
if(hdata->GetBinContent(k)>maxlaytracks){
cluMI = kFALSE;
- AliInfo(Form("MI Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersMI",k-1,6-nskipped));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("MI Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersMI",k-1,6-nskipped));
}
}
}
else if(hname.Contains("hESDClustersSA") && entries>0.){
// Check if 6 clusters SA tracks are the majority
- AliDebug(1,Form("Processing histogram %s",hname.Data()));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
cluSA = kTRUE;
Double_t maxlaytracks = hdata->GetBinContent(7-nskipped);
for(Int_t k=2; k<7-nskipped; k++){
if(hdata->GetBinContent(k)>maxlaytracks){
cluSA = kFALSE;
- AliInfo(Form("SA Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersSA",k-1,6-nskipped));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("SA Tracks with %d clusters are more than tracks with %d clusters. Look at histogram hESDClustersSA",k-1,6-nskipped));
}
}
}
else if(hname.Contains("hSPDVertexZ") && entries>0.){
// Check if average Z vertex coordinate is -5 < z < 5 cm
- AliDebug(1,Form("Processing histogram %s",hname.Data()));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Processing histogram %s",hname.Data()));
verSPDZ = kTRUE;
if(hdata->GetMean()<-5. && hdata->GetMean()>5.){
verSPDZ = kFALSE;
- AliInfo(Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Average z vertex coordinate is at z= %10.4g cm",hdata->GetMean()));
}
}
}
}
}
}
- AliInfo(Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("ESD - Tested %d histograms, Return value %f \n",tested,rv[specie]));
}
return rv ;
} // end of ESD QA
Double_t spdCheck, sddCheck, ssdCheck;
//pixel
if(fDet == 0 || fDet == 1) {
- AliDebug(1,"AliITSQAChecker::Create SPD Checker\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SPD Checker\n");
if(!fSPDChecker) {
fSPDChecker = new AliITSQASPDChecker();
}
}
//drift
if(fDet == 0 || fDet == 2) {
- AliDebug(1,"AliITSQAChecker::Create SDD Checker\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SDD Checker\n");
if(!fSDDChecker) {
fSDDChecker = new AliITSQASDDChecker();
}
}
//strip
if(fDet == 0 || fDet == 3) {
- AliDebug(1,"AliITSQAChecker::Create SSD Checker\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQAChecker::Create SSD Checker\n");
if(!fSSDChecker) {
fSSDChecker = new AliITSQASSDChecker();
- AliInfo(Form("Number of monitored objects SSD: %d", list[AliRecoParam::kDefault]->GetEntries()));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of monitored objects SSD: %d", list[AliRecoParam::kDefault]->GetEntries()));
}
fSSDChecker->SetTaskOffset(fSSDOffset);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
// Initialization for RAW data
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM::Create SPD DataMakerRec\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SPD DataMakerRec\n");
fSPDDataMaker = new AliITSQASPDDataMakerRec(this,fkOnline);
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM::Create SDD DataMakerRec\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SDD DataMakerRec\n");
fSDDDataMaker = new AliITSQASDDDataMakerRec(this,fkOnline);
if(fkOnline){SetHLTMode(fSDDDataMaker->GetHLTMode()); }
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM::Create SSD DataMakerRec\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SSD DataMakerRec\n");
fSSDDataMaker = new AliITSQASSDDataMakerRec(this,fkOnline);
}
}
void AliITSQADataMakerRec::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of ITS Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of ITS Cycle\n");
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->StartOfDetectorCycle();
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n");
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[specie]);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[specie]);
{
// Initialization for RAW data
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM:: SPD InitRaws\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRaws\n");
fSPDDataMaker->InitRaws();
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM:: SDD InitRaws\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRaws\n");
fSDDDataMaker->InitRaws();
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM:: SSD InitRaws\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRaws\n");
fSSDDataMaker->InitRaws();
}
}
{
// Initialization for RECPOINTS
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM:: SPD InitRecPoints\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRecPoints\n");
fSPDDataMaker->InitRecPoints();
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM:: SDD InitRecPoints\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRecPoints\n");
fSDDDataMaker->InitRecPoints();
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM:: SSD InitRecPoints\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRecPoints\n");
fSSDDataMaker->InitRecPoints();
}
}
// Initialization for RAW data
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM::Create SPD DataMakerSim\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SPD DataMakerSim\n");
fSPDDataMaker = new AliITSQASPDDataMakerSim(this);
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM::Create SDD DataMakerSim\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SDD DataMakerSim\n");
//printf("AliITSQADM::Create SDD DataMakerSim\n");
fSDDDataMaker = new AliITSQASDDDataMakerSim(this);
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM::Create SSD DataMakerSim\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SSD DataMakerSim\n");
fSSDDataMaker = new AliITSQASSDDataMakerSim(this);
}
}
void AliITSQADataMakerSim::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of ITS Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of ITS Cycle\n");
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->StartOfDetectorCycle();
// launch the QA checking
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
SetEventSpecie(specie) ;
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
+ 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]);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[specie]);
{
// Initialization for RAW data
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM:: SPD InitDigits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitDigits\n");
fSPDDataMaker->InitDigits();
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM:: SDD InitDigits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitDigits\n");
fSDDDataMaker->InitDigits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM:: SSD InitDigits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitDigits\n");
fSSDDataMaker->InitDigits();
}
}
{
// Initialization for RECPOINTS
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM:: SPD InitSDigits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitSDigits\n");
fSPDDataMaker->InitSDigits();
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM:: SDD InitSDigits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitSDigits\n");
fSDDDataMaker->InitSDigits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM:: SSD InitSDigits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitSDigits\n");
fSSDDataMaker->InitSDigits();
}
}
{
// Initialization for RECPOINTS
if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(1,"AliITSQADM:: SPD InitHits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitHits\n");
fSPDDataMaker->InitHits();
}
if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(1,"AliITSQADM:: SDD InitHits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitHits\n");
fSDDDataMaker->InitHits();
}
if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(1,"AliITSQADM:: SSD InitHits\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitHits\n");
fSSDDataMaker->InitHits();
}
}
void AliITSQASDDDataMakerRec::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of SDD Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SDD Cycle\n");
}
//____________________________________________________________________________
void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
}
//____________________________________________________________________________
} // kONLINE
- AliDebug(1,Form("%d SDD Raws histograms booked\n",fSDDhRawsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Raws histograms booked\n",fSDDhRawsTask));
}
return;
}
if(rawReader->GetType() != 7) return; // skips non physical triggers
- AliDebug(1,"entering MakeRaws\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"entering MakeRaws\n");
rawReader->Reset();
AliITSRawStream *stream;
isddmod = fDDLModuleMap->GetModuleNumber(iddl,stream->GetCarlosId());
if(isddmod==-1){
- AliDebug(1,Form("Found module with iddl: %d, stream->GetCarlosId: %d \n",iddl,stream->GetCarlosId()));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Found module with iddl: %d, stream->GetCarlosId: %d \n",iddl,stream->GetCarlosId()));
continue;
}
if(stream->IsCompletedModule()) {
- AliDebug(1,Form("IsCompletedModule == KTRUE\n"));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("IsCompletedModule == KTRUE\n"));
continue;
}
if(stream->IsCompletedDDL()) {
- AliDebug(1,Form("IsCompletedDDL == KTRUE\n"));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("IsCompletedDDL == KTRUE\n"));
continue;
}
moduleSDD = isddmod - fgkmodoffset;
if(isddmod <fgkmodoffset|| isddmod>fgknSDDmodules+fgkmodoffset-1) {
- AliDebug(1,Form( "Module SDD = %d, resetting it to 1 \n",isddmod));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form( "Module SDD = %d, resetting it to 1 \n",isddmod));
isddmod = 1;
}
index1 = activeModule * 2 + iside;
if(index1<0){
- AliDebug(1,Form("Wrong index number %d - patched to 0\n",index1));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Wrong index number %d - patched to 0\n",index1));
index1 = 0;
}
fAliITSQADataMakerRec->GetRawsData(3+fGenRawsOffset)->Fill(2*(stream->GetCarlosId())+iside,iddl);
}
}
cnt++;
- if(!(cnt%10000)) AliDebug(1,Form(" %d raw digits read",cnt));
+ if(!(cnt%10000)) AliDebug(AliQAv1::GetQADebugLevel(),Form(" %d raw digits read",cnt));
}
- AliDebug(1,Form("Event completed, %d raw digits read",cnt));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",cnt));
delete stream;
stream = NULL;
}
//printf("%d SDD Recs histograms booked\n",fSDDhRecPointsTask);
- AliDebug(1,Form("%d SDD Recs histograms booked\n",fSDDhRecPointsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Recs histograms booked\n",fSDDhRecPointsTask));
}
void AliITSQASDDDataMakerSim::StartOfDetectorCycle()\r
{\r
//Detector specific actions at start of cycle\r
- AliDebug(1,"AliITSQADM::Start of SDD Cycle\n");\r
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SDD Cycle\n");\r
}\r
\r
//____________________________________________________________________________ \r
void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)\r
{\r
// launch the QA checking\r
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); \r
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); \r
//AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);\r
}\r
\r
h3->GetYaxis()->SetTitle("# DIGITS");\r
fAliITSQADataMakerSim->Add2DigitsList(h3,3+fGenOffsetD, !expert, image);\r
fSDDhDTask ++;\r
- AliDebug(1,Form("%d SDD Digits histograms booked\n",fSDDhDTask));\r
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Digits histograms booked\n",fSDDhDTask));\r
}\r
\r
//____________________________________________________________________________\r
fAliITSQADataMakerSim->Add2SDigitsList(h3,3+fGenOffsetS, !expert, image);\r
fSDDhSTask ++;\r
\r
- AliDebug(1,Form("%d SDD SDigits histograms booked\n",fSDDhSTask));\r
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD SDigits histograms booked\n",fSDDhSTask));\r
}\r
\r
//____________________________________________________________________________\r
h3->GetYaxis()->SetTitle("# HITS");\r
fAliITSQADataMakerSim->Add2HitsList(h3,3+fGenOffsetH, !expert, image);\r
fSDDhHTask ++;\r
- AliDebug(1,Form("%d SDD Hits histograms booked\n",fSDDhHTask));\r
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Hits histograms booked\n",fSDDhHTask));\r
}\r
\r
//____________________________________________________________________________\r
//__________________________________________________________________
Double_t AliITSQASPDChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray * list)
{
- AliDebug(1,Form("AliITSQASPDChecker called with offset: %d\n", fSubDetOffset));
+ AliDebug(2, Form("AliITSQASPDChecker called with offset: %d\n", fSubDetOffset));
Double_t test = 0.0;
Int_t count = 0;
if (histName.Contains("LayPattern")) {
if (hdata->GetBinContent(1)) {
Double_t ratio=hdata->GetBinContent(2)/hdata->GetBinContent(1);
- AliInfo(Form("%s: ratio RecPoints lay2 / lay1 = %f", hdata->GetName(), ratio));
+ AliDebug(2, Form("%s: ratio RecPoints lay2 / lay1 = %f", hdata->GetName(), ratio));
}
else
- AliInfo("No RecPoints in lay1");
+ AliDebug(AliQAv1::GetQADebugLevel(), "No RecPoints in lay1");
}
else if(histName.Contains("ModPattern")) {
Int_t ndead=0;
if(histName.Contains("SPD1") && ibin<80 && hdata->GetBinContent(ibin+1)>0) ndead++;
if(histName.Contains("SPD2") && ibin>79 && hdata->GetBinContent(ibin+1)>0) ndead++;
}
- AliInfo(Form("%s: Entries = %d number of empty modules = %d",
+ AliDebug(2, Form("%s: Entries = %d number of empty modules = %d",
hdata->GetName(),(Int_t)hdata->GetEntries(),ndead));
}
else if(histName.Contains("SizeYvsZ")) {
Double_t meany=hdata->GetMean(2);
Double_t rmsz=hdata->GetRMS(1);
Double_t rmsy=hdata->GetRMS(2);
- AliInfo(Form("%s: Cluster sizeY mean = %f rms = %f", hdata->GetName(),meany,rmsy));
- AliInfo(Form("%s: Cluster sizeZ mean = %f rms = %f", hdata->GetName(),meanz,rmsz));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s: Cluster sizeY mean = %f rms = %f", hdata->GetName(),meany,rmsy));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s: Cluster sizeZ mean = %f rms = %f", hdata->GetName(),meanz,rmsz));
}
else if(histName.Contains("Multiplicity")) {
- AliInfo(Form("%s: Events = %d mean = %f rms = %f",
+ AliDebug(2, Form("%s: Events = %d mean = %f rms = %f",
hdata->GetName(),(Int_t)hdata->GetEntries(),hdata->GetMean(),hdata->GetRMS()));}
- // else AliInfo(Form("%s -> %f", hdata->GetName(), rv));
+ // else AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv));
count++;
test += rv;
}
}
}
- AliInfo(Form("Test Result = %f", test));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test));
return test ;
}
void AliITSQASPDDataMakerRec::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of SPD Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SPD Cycle\n");
}
//____________________________________________________________________________
void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
//AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
fGenRawsOffset = (fAliITSQADataMakerRec->fRawsQAList[AliRecoParam::kDefault])->GetEntries();
fAdvLogger = new AliITSRawStreamSPDErrorLog();
- AliInfo("Book Offline Histograms for SPD\n ");
+ AliDebug(AliQAv1::GetQADebugLevel(), "Book Offline Histograms for SPD\n ");
Char_t name[50];
Char_t title[50];
fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits2MultSPDhits1, 45+fGenRawsOffset, !expert, image, !saveCorr);
fSPDhRawsTask++;
- AliDebug(1,Form("%d SPD Raws histograms booked\n",fSPDhRawsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Raws histograms booked\n",fSPDhRawsTask));
}
fAliITSQADataMakerRec->GetRawsData(45+fGenRawsOffset)->Fill(nDigitsL1,nDigitsL2);
delete rawStreamSPD;
- AliDebug(1,Form("Event completed, %d raw digits read",nDigitsL1+nDigitsL2));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",nDigitsL1+nDigitsL2));
}
//____________________________________________________________________________
fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl2MultSPDcl1, 25+fGenRecPointsOffset, !expert, image);
fSPDhRecPointsTask++;
- AliDebug(1,Form("%d SPD Recs histograms booked\n",fSPDhRecPointsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Recs histograms booked\n",fSPDhRecPointsTask));
}
void AliITSQASPDDataMakerSim::StartOfDetectorCycle()
{
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of SPD Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SPD Cycle\n");
}
//____________________________________________________________________________
void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
{
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
//AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
fAliITSQADataMakerSim->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenOffsetD, !expert, image);
fSPDhDTask++;
- AliDebug(1,Form("%d SPD Digits histograms booked\n",fSPDhDTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Digits histograms booked\n",fSPDhDTask));
}
fSPDhSTask++;
}
- AliDebug(1,Form("%d SPD SDigits histograms booked\n",fSPDhSTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD SDigits histograms booked\n",fSPDhSTask));
}
fAliITSQADataMakerSim->Add2HitsList(hEdepos,4+fGenOffsetH, !expert, image);
fSPDhHTask++;
- AliDebug(1,Form("%d SPD Hits histograms booked\n",fSPDhHTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Hits histograms booked\n",fSPDhHTask));
}
//__________________________________________________________________
Double_t AliITSQASSDChecker::Check(AliQAv1::ALITASK_t /*index*/, TObjArray * list) {
- AliDebug(1,Form("AliITSQASSDChecker called with offset: %d\n", fSubDetOffset));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("AliITSQASSDChecker called with offset: %d\n", fSubDetOffset));
Double_t test = 0.0 ;
Int_t count = 0 ;
if(!histname.Contains("fHistSSD")) continue;
Double_t rv = 0.;
if(hdata->GetEntries()>0) rv = 1;
- //AliInfo(Form("%s -> %f", hdata->GetName(), rv)) ;
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv)) ;
//cout<<hdata->GetName()<<" - "<<rv<<endl;
count++ ;
test += rv ;
}
}
- //AliInfo(Form("Test Result = %f", test)) ;
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test)) ;
//cout<<"Test result: "<<test<<endl;
return test ;
fCDBManager->SetDefaultStorage(gSystem->Getenv("AMORE_CDB_URI"));
Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER"));
if(!runNumber)
- AliInfo("DATE_RUN_NUMBER not defined!!!\n");
+ AliWarning("DATE_RUN_NUMBER not defined!!!\n");
fCDBManager->SetRun(runNumber);
AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data");
- if(!geomGRP) AliInfo("GRP geometry not found!!!\n");
+ if(!geomGRP) AliWarning("GRP geometry not found!!!\n");
Int_t gLayer = 0,gLadder = 0, gModule = 0;
Int_t gHistCounter = 0;
return ;
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SSD Cycle\n");
//Data size per DDL
((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset+4)))->Reset();
if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
return ;
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
- AliInfo(Form("Offset: %d\n",fGenRawsOffset));
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Offset: %d\n",fGenRawsOffset));
//Data size per DDL
for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
Double_t gSizePerDDL = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset+5+i))->GetMean())/1e+06;
fGenRawsOffset = (fAliITSQADataMakerRec->fRawsQAList[AliRecoParam::kDefault])->GetEntries();
if(fkOnline) {
- AliInfo("Book Online Histograms for SSD\n");
+ AliDebug(AliQAv1::GetQADebugLevel(), "Book Online Histograms for SSD\n");
}
else {
- AliInfo("Book Offline Histograms for SSD\n ");
+ AliDebug(AliQAv1::GetQADebugLevel(), "Book Offline Histograms for SSD\n ");
}
- AliInfo(Form("Number of histograms (SPD+SDD): %d\n",fGenRawsOffset));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD): %d\n",fGenRawsOffset));
TString gTitle = 0;
//book online-offline QA histos
TH1D *fHistSSDEventType = new TH1D("SSD/DataSize/fHistSSDEventType",
}//online flag
fSSDhRawsTask = fSSDRawsOffset;
- AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhRawsTask));
- AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhRawsTask));
- AliDebug(1,Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Raws histograms booked\n",fSSDhRawsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhRawsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
/*
fSSDhTask = fSSDRawsOffset;
- AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhTask));
- AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhTask));
- AliDebug(1,Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Raws histograms booked\n",fSSDhTask));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDhTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset+fSSDRawsOffset));
*/
}
if(gSSDStream.GetStrip() < 0) continue;
gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
- //AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));
if(fkOnline)
fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());
//fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal());
/*if(histname.Contains("Layer5_Ladder507_Module3"))
cout<<"Fired strips: "<<lNumFiredBins<<
" - Occupancy: "<<lOccupancy<<endl;*/
- //AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
return lOccupancy;
}
const Bool_t image = kTRUE ;
fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
- //AliInfo(Form("**-------*-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints offset %d \t %d \n",fGenOffset,fGenRecPointsOffset));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("**-------*-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints offset %d \t %d \n",fGenOffset,fGenRecPointsOffset));
Int_t nModuleOffset = 500;
Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
fGenRecPointsOffset + 37, !expert, image);
fSSDhRecPointsTask += 1;
//printf ("%d SSD Recs histograms booked\n",fSSDhRecPointsTask);
- AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhRecPointsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Recs histograms booked\n",fSSDhRecPointsTask));
}
//____________________________________________________________________________
offset=fGenRecPointsOffset;
}
else {
- AliInfo("No task has been selected. Offset set to zero.\n");
+ AliWarning("No task has been selected. Offset set to zero.\n");
}
return offset;
histotot=fSSDhRecPointsTask;
}
else {
- AliInfo("No task has been selected. TaskHisto set to zero.\n");
+ AliWarning("No task has been selected. TaskHisto set to zero.\n");
}
return histotot;
//____________________________________________________________________________
void AliITSQASSDDataMakerSim::StartOfDetectorCycle() {
//Detector specific actions at start of cycle
- AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SSD Cycle\n");
}
//____________________________________________________________________________
void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/) {
// launch the QA checking
- AliDebug(1,"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
// AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
}
fGenOffsetD + 1, !expert, image);
fSSDhDTask += 1;
- AliDebug(1,Form("%d SSD Digits histograms booked\n",fSSDhDTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Digits histograms booked\n",fSSDhDTask));
}
Int_t ndigits = iSSDdigits->GetEntries();
fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD + 0)->Fill(iModule,ndigits);
if(ndigits != 0)
- AliDebug(1,Form("Module: %d - Digits: %d",iModule,ndigits));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
AliITSdigit *dig = (AliITSdigit*)iSSDdigits->UncheckedAt(iDigit);
fGenOffsetS + 0, !expert, image);
fSSDhSTask += 1;
- AliDebug(1,Form("%d SSD SDigits histograms booked\n",fSSDhSTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD SDigits histograms booked\n",fSSDhSTask));
}
//____________________________________________________________________________
iSSDEmpty.Clear();
TClonesArray *iSSDsdigits = &iSSDEmpty;
- AliInfo(Form("Trying to access the sdigits histogram: %d\n",fGenOffsetS));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Trying to access the sdigits histogram: %d\n",fGenOffsetS));
TBranch *brchSDigits = sdigits->GetBranch("ITS");
brchSDigits->SetAddress(&iSSDsdigits);
Int_t ndigits = iSSDsdigits->GetEntries();
fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS + 0)->Fill(iModule,ndigits);
if(ndigits != 0)
- AliDebug(1,Form("Module: %d - Digits: %d",iModule,ndigits));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
AliITSpListItem *dig=(AliITSpListItem*)iSSDsdigits->At(iDigit);
fGenOffsetH + 8, !expert, image);
fSSDhHTask += 1;
- AliDebug(1,Form("%d SSD Hits histograms booked\n",fSSDhHTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Hits histograms booked\n",fSSDhHTask));
}
TObjArray *arrHits = module->GetHits();
Int_t nhits = arrHits->GetEntriesFast();
if(nhits != 0)
- AliDebug(1,Form("Module: %d - Hits: %d",iModule,nhits));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Hits: %d",iModule,nhits));
for (Int_t iHit = 0; iHit < nhits; iHit++) {
AliITShit *hit = (AliITShit*) arrHits->At(iHit);
{
/// ctor
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
Ctor();
}
{
///copy ctor
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
SetName((const char*)qadm.GetName()) ;
{
/// Assignment operator
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
// check assignment to self
if (this == &qadm) return *this;
{
/// dtor
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
AliCodeTimerAuto("");
}
if (!alreadyThere && fTrackerDataMaker)
{
- AliInfo("Adding fTrackerDataMaker to the list of qa objects");
+ AliDebug(AliQAv1::GetQADebugLevel(), "Adding fTrackerDataMaker to the list of qa objects");
list[specie]->AddAt(fTrackerDataMaker->Data(),(Int_t)kTrackerData);
}
if ( fTrackerDataMaker )
for(Int_t iMeas=0; iMeas<AliMpDCSNamer::kNDCSMeas; iMeas++){
TString currAlias = triggerDcsNamer.DCSChannelName(detElemId, 0, iMeas);
- AliDebug(2, Form("\nDetElemId %i dcsAlias %s", detElemId, currAlias.Data()));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("\nDetElemId %i dcsAlias %s", detElemId, currAlias.Data()));
TPair* triggerDcsPair = static_cast<TPair*>(triggerDcsMap->FindObject(currAlias.Data()));
{
Float_t hvi = val->GetFloat();
- AliDebug(2, Form("Value %f", hvi));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Value %f", hvi));
switch(iMeas){
case AliMpDCSNamer::kDCSI:
{
/// Default constructor
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
}
//____________________________________________________________________________
{
/// Copy constructor
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
if ( qadm.fHitStore )
{
{
/// Assignment operator
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
this->~AliMUONQADataMakerSim();
new(this) AliMUONQADataMakerSim(qadm);
{
/// Destructor
- AliDebug(1,"");
+ AliDebug(AliQAv1::GetQADebugLevel(),"");
delete fHitStore;
delete fDigitStore;
}
if ( !((entry-1)%100) )
- AliInfo(Form("%s ----> Processing event # %lld", (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s ----> Processing event # %lld", (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ;
//************************ PHOS *************************************
fhPHOSDigitsEvent = (TH1I*)fOutputContainer->At(7);
Bool_t problem = kFALSE ;
- AliInfo(Form(" *** %s Report:", GetName())) ;
- printf(" PHOSEnergy Mean : %5.3f , RMS : %5.3f \n", fhPHOSEnergy->GetMean(), fhPHOSEnergy->GetRMS() ) ;
- printf(" PHOSDigits Mean : %5.3f , RMS : %5.3f \n", fhPHOSDigits->GetMean(), fhPHOSDigits->GetRMS() ) ;
- printf(" PHOSRecParticles Mean : %5.3f , RMS : %5.3f \n", fhPHOSRecParticles->GetMean(), fhPHOSRecParticles->GetRMS() ) ;
- printf(" PHOSPhotons Mean : %5.3f , RMS : %5.3f \n", fhPHOSPhotons->GetMean(), fhPHOSPhotons->GetRMS() ) ;
- printf(" PHOSInvariantMass Mean : %5.3f , RMS : %5.3f \n", fhPHOSInvariantMass->GetMean(), fhPHOSInvariantMass->GetRMS() ) ;
- printf(" PHOSDigitsEvent Mean : %5.3f , RMS : %5.3f \n", fhPHOSDigitsEvent->GetMean(), fhPHOSDigitsEvent->GetRMS() ) ;
-
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" *** %s Report:", GetName())) ;
+ if ( AliDebugLevel() == AliQAv1::GetQADebugLevel() ) {
+ printf(" PHOSEnergy Mean : %5.3f , RMS : %5.3f \n", fhPHOSEnergy->GetMean(), fhPHOSEnergy->GetRMS() ) ;
+ printf(" PHOSDigits Mean : %5.3f , RMS : %5.3f \n", fhPHOSDigits->GetMean(), fhPHOSDigits->GetRMS() ) ;
+ printf(" PHOSRecParticles Mean : %5.3f , RMS : %5.3f \n", fhPHOSRecParticles->GetMean(), fhPHOSRecParticles->GetRMS() ) ;
+ printf(" PHOSPhotons Mean : %5.3f , RMS : %5.3f \n", fhPHOSPhotons->GetMean(), fhPHOSPhotons->GetRMS() ) ;
+ printf(" PHOSInvariantMass Mean : %5.3f , RMS : %5.3f \n", fhPHOSInvariantMass->GetMean(), fhPHOSInvariantMass->GetRMS() ) ;
+ printf(" PHOSDigitsEvent Mean : %5.3f , RMS : %5.3f \n", fhPHOSDigitsEvent->GetMean(), fhPHOSDigitsEvent->GetRMS() ) ;
+ }
+
TCanvas * cPHOS = new TCanvas("cPHOS", "PHOS ESD Test", 400, 10, 600, 700) ;
cPHOS->Divide(3, 2);
if(!queryPath.IsWildcard()) { // path is not wildcard, get it directly from the cache and unload it!
if(fEntryCache.Contains(path)){
- AliDebug(1,Form("Unloading object \"%s\" from cache", path));
+ AliDebug(2, Form("Unloading object \"%s\" from cache", path));
TObjString pathStr(path);
AliCDBEntry *entry = dynamic_cast<AliCDBEntry*> (fEntryCache.GetValue(&pathStr));
if(entry) delete entry;
} else {
AliError(Form("Cache does not contain object \"%s\"!", path))
}
- AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
+ AliDebug(2, Form("Cache entries: %d",fEntryCache.GetEntries()));
return;
}
while((pair = dynamic_cast<TPair*> (iter.Next()))){
AliCDBPath entryPath = pair->Key()->GetName();
if(queryPath.Comprises(entryPath)) {
- AliDebug(1,Form("Unloading object \"%s\" from cache", entryPath.GetPath().Data()));
+ AliDebug(2, Form("Unloading object \"%s\" from cache", entryPath.GetPath().Data()));
TObjString pathStr(entryPath.GetPath().Data());
AliCDBEntry *entry = dynamic_cast<AliCDBEntry*> (fEntryCache.GetValue(&pathStr));
if(entry) delete entry;
} else if (det == AliQAv1::kCORR) {
qac = new AliCorrQAChecker() ;
} else {
- AliDebug(1, Form("Retrieving QA checker for %s", detName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Retrieving QA checker for %s", detName.Data())) ;
TPluginManager* pluginManager = gROOT->GetPluginManager() ;
TString qacName = "Ali" + detName + "QAChecker" ;
TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQAChecker", detName.Data());
// if not, add a plugin for it
if (!pluginHandler) {
- //AliInfo(Form("defining plugin for %s", qacName.Data()));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", qacName.Data()));
TString libs = gSystem->GetLibraries();
if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0))
TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
if (m) {
- AliInfo("It is a map");
+ AliDebug(AliQAv1::GetQADebugLevel(), "It is a map");
//m->Print();
grpObject = new AliGRPObject();
grpObject->ReadValuesFromMap(m);
}
else {
- AliInfo("It is a new GRP object");
+ AliDebug(AliQAv1::GetQADebugLevel(), "It is a new GRP object");
grpObject = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
}
TIter nextd(detKeyList) ;
TKey * detKey ;
while ( (detKey = dynamic_cast<TKey *>(nextd()) ) ) {
- AliDebug(1, Form("Found %s", detKey->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Found %s", detKey->GetName())) ;
//Check which detector
TString detName ;
TString detNameQA(detKey->GetName()) ;
// now search for the tasks dir
while ( (taskKey = static_cast<TKey *>(nextt()) ) ) {
TString taskName( taskKey->GetName() ) ;
- AliInfo(Form("Found %s", taskName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Found %s", taskName.Data())) ;
TDirectory * taskDir = detDir->GetDirectory(taskName.Data()) ;
taskDir->cd() ;
AliQACheckerBase * qac = GetDetQAChecker(det) ;
if (qac)
- AliInfo(Form("QA checker found for %s", detName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("QA checker found for %s", detName.Data())) ;
if (!qac)
AliFatal(Form("QA checker not found for %s", detName.Data())) ;
AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
AliQACheckerBase * qac = GetDetQAChecker(det) ;
if (qac)
- AliDebug(1, Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
if (!qac)
AliError(Form("QA checker not found for %s", AliQAv1::GetDetName(det).Data())) ;
AliQACheckerBase * qac = GetDetQAChecker(det) ;
if (qac)
- AliDebug(1, Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("QA checker found for %s", AliQAv1::GetDetName(det).Data())) ;
if (!qac)
AliError(Form("QA checker not found for %s", AliQAv1::GetDetName(det).Data())) ;
fLowTestValue[AliQAv1::kFATAL] = -1.0 ;
fUpTestValue[AliQAv1::kFATAL] = 0.0 ;
- AliInfo("Default setting is:") ;
- printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
- printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
- printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
- printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
-
+ AliDebug(AliQAv1::GetQADebugLevel(), "Default setting is:") ;
+ if ( AliDebugLevel() == AliQAv1::GetQADebugLevel() ) {
+ printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
+ printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
+ printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
+ printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
+ }
}
//____________________________________________________________________________
test[specie] = -1 ; // no reference data ;
else {
Double_t rv = DiffK(hdata, href) ;
- AliInfo(Form("%s ->Test = %f", hdata->GetName(), rv)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s ->Test = %f", hdata->GetName(), rv)) ;
test[specie] += rv ;
count[specie]++ ;
}
test[specie] = -1 ; // no reference data ;
else {
Double_t rv = DiffK(hdata, href) ;
- AliInfo(Form("%s ->Test = %f", hdata->GetName(), rv)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s ->Test = %f", hdata->GetName(), rv)) ;
test[specie] += rv ;
count[specie]++ ;
}
{
// compares two histograms using the Chi2 test
if ( hin->Integral() == 0 ) {
- AliWarning(Form("Spectrum %s is empty", hin->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Spectrum %s is empty", hin->GetName())) ;
return 0. ;
}
{
// compares two histograms using the Kolmogorov test
if ( hin->Integral() == 0 ) {
- AliWarning(Form("Spectrum %s is empty", hin->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Spectrum %s is empty", hin->GetName())) ;
return 0. ;
}
//____________________________________________________________________________
void AliQACheckerBase::Run(AliQAv1::ALITASK_t index, TObjArray ** list)
{
- AliDebug(1, Form("Processing %s", AliQAv1::GetAliTaskName(index))) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Processing %s", AliQAv1::GetAliTaskName(index))) ;
Double_t * rv = NULL ;
if ( !list)
rv = Check(index, list) ;
SetQA(index, rv) ;
- AliDebug(1, Form("Test result of %s", AliQAv1::GetAliTaskName(index))) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Test result of %s", AliQAv1::GetAliTaskName(index))) ;
if (rv)
delete [] rv ;
//____________________________________________________________________________
void AliQACheckerBase::SetHiLo(Float_t * hiValue, Float_t * lowValue)
{
- AliInfo("Previous setting was:") ;
- printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
- printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
- printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
- printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Previous setting was:") ;
+ if ( AliDebugLevel() == AliQAv1::GetQADebugLevel() ) {
+ printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
+ printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
+ printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
+ printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
+ }
for (Int_t index = 0 ; index < AliQAv1::kNBIT ; index++) {
fLowTestValue[index] = lowValue[index] ;
fUpTestValue[index] = hiValue[index] ;
}
- AliInfo("Current setting is:") ;
- printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
- printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
- printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
- printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Current setting is:") ;
+ if ( AliDebugLevel() == AliQAv1::GetQADebugLevel() ) {
+ printf( " INFO -> %1.5f < value < %1.5f \n", fLowTestValue[AliQAv1::kINFO], fUpTestValue[AliQAv1::kINFO]) ;
+ printf( " WARNING -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kWARNING], fUpTestValue[AliQAv1::kWARNING]) ;
+ printf( " ERROR -> %1.5f < value <= %1.5f \n", fLowTestValue[AliQAv1::kERROR], fUpTestValue[AliQAv1::kERROR]) ;
+ printf( " FATAL -> %1.5f <= value < %1.5f \n", fLowTestValue[AliQAv1::kFATAL], fUpTestValue[AliQAv1::kFATAL]) ;
+ }
}
//____________________________________________________________________________
}
fOutput->Save() ;
}
- MakeImage(task) ;
+ if ( AliDebugLevel() == AliQAv1::GetQADebugLevel() )
+ MakeImage(task) ;
}
//____________________________________________________________________________
nImages++;
}
if ( nImages == 0 ) {
- AliInfo(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
+ AliWarning(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
} else {
- AliInfo(Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;
Double_t w = 1000 ;
Double_t h = 1000 ;
for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
// creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
if ( task == AliQAv1::kRAWS ) {
- AliDebug(1, "Processing Raws QA") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ;
AliRawReader * rawReader = dynamic_cast<AliRawReader *>(data) ;
if (rawReader)
MakeRaws(rawReader) ;
else
- AliInfo("Raw data are not processed") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;
} else if ( task == AliQAv1::kRECPOINTS ) {
- AliDebug(1, "Processing RecPoints QA") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ;
TTree * tree = dynamic_cast<TTree *>(data) ;
if (tree) {
MakeRecPoints(tree) ;
AliWarning("data are not a TTree") ;
}
} else if ( task == AliQAv1::kESDS ) {
- AliDebug(1, "Processing ESDs QA") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ;
AliESDEvent * esd = dynamic_cast<AliESDEvent *>(data) ;
if (esd)
MakeESDs(esd) ;
void AliQADataMakerRec::InitRecoParams()
{
if (!fRecoParam) {
- AliInfo(Form("Loading reconstruction parameter objects for detector %s", GetName()));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Loading reconstruction parameter objects for detector %s", GetName()));
AliCDBPath path(GetName(),"Calib","RecoParam");
AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
if(!entry) {
TObject * recoParamObj = entry->GetObject() ;
if (dynamic_cast<TObjArray*>(recoParamObj)) {
// The detector has only one set of reco parameters
- AliInfo(Form("Array of reconstruction parameters found for detector %s",GetName()));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Array of reconstruction parameters found for detector %s",GetName()));
TObjArray *recoParamArray = dynamic_cast<TObjArray*>(recoParamObj) ;
for (Int_t iRP=0; iRP<recoParamArray->GetEntriesFast(); iRP++) {
fRecoParam = dynamic_cast<AliDetectorRecoParam*>(recoParamArray->At(iRP)) ;
else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
// The detector has only onse set of reco parameters
// Registering it in AliRecoParam
- AliInfo(Form("Single set of reconstruction parameters found for detector %s",GetName()));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Single set of reconstruction parameters found for detector %s",GetName()));
dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
fRecoParam = dynamic_cast<AliDetectorRecoParam*>(recoParamObj) ;
} else {
fOutput->Close() ;
fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;
}
- AliInfo(Form(" Run %d Cycle %d task %s file %s",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s",
fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
// creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
if ( task == AliQAv1::kHITS ) {
- AliDebug(1, "Processing Hits QA") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing Hits QA") ;
TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ;
if (arr) {
MakeHits(arr) ;
}
}
} else if ( task == AliQAv1::kSDIGITS ) {
- AliDebug(1, "Processing SDigits QA") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing SDigits QA") ;
TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ;
if (arr) {
MakeSDigits(arr) ;
}
}
} else if ( task == AliQAv1::kDIGITS ) {
- AliDebug(1, "Processing Digits QA") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ;
TClonesArray * arr = dynamic_cast<TClonesArray *>(data) ;
if (arr) {
MakeDigits(arr) ;
nImages++;
}
if ( nImages == 0 ) {
- AliInfo(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
+ AliWarning(Form("No histogram will be plotted for %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data())) ;
} else {
- AliInfo(Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data())) ;
Double_t w = 1000 ;
Double_t h = 1000 ;
for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
canvasQA->cd(++npad) ;
}
}
- canvasQA->Print() ;
+ if ( AliDebugLevel() == AliQAv1::GetQADebugLevel() )
+ canvasQA->Print() ;
}
}
}
fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;
}
- AliInfo(Form(" Run %d Cycle %d task %s file %s",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s",
fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
fCurrentEvent++ ;
// Get the event
if ( iEvent%10 == 0 )
- AliInfo(Form("processing event %d", iEvent));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("processing event %d", iEvent));
if ( taskIndex == AliQAv1::kRAWS ) {
if ( !fRawReader->NextEvent() )
break ;
Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
}
TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ;
- AliInfo(Form("Retrieving reference data from %s/%s for %s", AliQAv1::GetQARefStorage(), detOCDBDir.Data(), AliQAv1::GetTaskName(task).Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Retrieving reference data from %s/%s for %s", AliQAv1::GetQARefStorage(), detOCDBDir.Data(), AliQAv1::GetTaskName(task).Data())) ;
AliCDBEntry* entry = QAManager()->Get(detOCDBDir.Data(), 0) ; //FIXME 0 --> Run Number
TList * listDetQAD = dynamic_cast<TList *>(entry->GetObject()) ;
if ( listDetQAD )
TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
// if not, add a plugin for it
if (!pluginHandler) {
- AliDebug(1, Form("defining plugin for %s", loaderName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", loaderName.Data())) ;
TString libs = gSystem->GetLibraries() ;
if (libs.Contains("lib" + detName + "base.so") || (gSystem->Load("lib" + detName + "base.so") >= 0)) {
pluginManager->AddHandler("AliQADataMaker", detName, loaderName, detName + "loader", loaderName + "()") ;
TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName) ;
// if not, add a plugin for it
if (!pluginHandler) {
- AliDebug(1, Form("defining plugin for %s", qadmName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("defining plugin for %s", qadmName.Data())) ;
TString libs = gSystem->GetLibraries() ;
if (libs.Contains("lib" + detName + fMode + ".so") || (gSystem->Load("lib" + detName + fMode + ".so") >= 0)) {
pluginManager->AddHandler("AliQADataMaker", detName, qadmName, detName + "qadm", qadmName + "()") ;
} else {
if (fQAWriteExpert[iDet])
qadm->SetWriteExpert() ;
- AliDebug(1, Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Data Maker found for %s %d", qadm->GetName(), qadm->WriteExpert())) ;
// skip non active detectors
if (detArray) {
AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
else
file = Form("%s", turl) ;
- AliInfo(Form("%s\n", file)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", file)) ;
merger.AddFile(file) ;
index++ ;
}
if (index)
merger.Merge() ;
- AliInfo(Form("Files merged into %s\n", outFile)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Files merged into %s\n", outFile)) ;
rv = kFALSE;
return rv ;
while ( (srun = dynamic_cast<TObjString *> (nextRun())) ) {
runNumber = (srun->String()).Atoi() ;
hisRun->Fill(runNumber) ;
- AliInfo(Form("Merging run number %d", runNumber)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Merging run number %d", runNumber)) ;
// search all QA files for runNumber in the current directory
char * fileList[AliQAv1::kNDET] ;
index = 0 ;
while ( (obj1 = nextkey()) ) {
TDirectory * directoryDet = inFile->GetDirectory(obj1->GetName()) ;
if ( directoryDet ) {
-// AliInfo(Form("%s dir = %s", inFile->GetName(), directoryDet->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s dir = %s", inFile->GetName(), directoryDet->GetName())) ;
dirName += Form("%s/", directoryDet->GetName() ) ;
directoryDet->cd() ;
TList * listOfTasks = directoryDet->GetListOfKeys() ;
TDirectory * directoryTask = directoryDet->GetDirectory(obj2->GetName()) ;
if ( directoryTask ) {
dirName += Form("%s", obj2->GetName()) ;
- //AliInfo(Form("%s", dirName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s", dirName.Data())) ;
directoryTask->cd() ;
TList * listOfEventSpecie = directoryTask->GetListOfKeys() ;
TIter nextEventSpecie(listOfEventSpecie) ;
TDirectory * directoryEventSpecie = directoryTask->GetDirectory(obj3->GetName()) ;
if ( directoryEventSpecie ) {
dirName += Form("/%s/", obj3->GetName()) ;
-// AliInfo(Form("%s\n", dirName.Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s\n", dirName.Data())) ;
directoryEventSpecie->cd() ;
// histograms are here
TDirectory * mergedDirectory = mergedFile.GetDirectory(dirName.Data()) ;
if ( className.Contains("TH") || className.Contains("TProfile") ) {
TH1 * histIn = dynamic_cast<TH1*> (key->ReadObj()) ;
TH1 * histOu = dynamic_cast<TH1*> (mergedDirectory->FindObjectAny(histIn->GetName())) ;
- //AliInfo(Form("%s %x %x\n", key->GetName(), histIn, histOu)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s %x %x\n", key->GetName(), histIn, histOu)) ;
mergedDirectory->cd() ;
if ( ! histOu ) {
histIn->Write() ;
in >> fileList[index] ;
if ( !in.good() )
break ;
- AliInfo(Form("index = %d file = %s", index, (fileList[index].Data()))) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ;
index++ ;
}
rl->CdGAFile() ;
rl->LoadgAlice() ;
if ( ! rl->GetAliRun() ) {
- AliInfo("AliRun not found in galice.root") ;
+ AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
} else {
rl->LoadHeader() ;
man->SetRun(rl->GetHeader()->GetRun()) ;
{
// reads the TH1 from file and adds it to appropriate list before saving to OCDB
Bool_t rv = kTRUE ;
- AliInfo(Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving TH1s in %s to %s", inputFile->GetName(), AliQAv1::GetQARefStorage())) ;
if ( ! IsDefaultStorageSet() ) {
TString tmp( AliQAv1::GetQARefStorage() ) ;
if ( tmp.Contains(AliQAv1::GetLabLocalOCDB()) )
for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
if ( detDir ) {
- AliInfo(Form("Entering %s", detDir->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Entering %s", detDir->GetName())) ;
AliQAv1::SetQARefDataDirName(es) ;
TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ;
AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity()) ;
while ( (taskKey = dynamic_cast<TKey*>(nextTask())) ) {
TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
TDirectory * esDir = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ;
- AliInfo(Form("Saving %s", esDir->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Saving %s", esDir->GetName())) ;
TObjArray * listTaskQAD = new TObjArray(100) ;
listTaskQAD->SetName(Form("%s/%s", taskKey->GetName(), AliRecoParam::GetEventSpecieName(es))) ;
listDetQAD->Add(listTaskQAD) ;
if ( !expertOdata ) {
AliError(Form("%s in %s/%s/Expert returns a NULL pointer !!", expertHistKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
} else {
- AliInfo(Form("Adding %s", expertHistKey->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
if ( expertOdata->IsA()->InheritsFrom("TH1") ) {
- AliInfo(Form("Adding %s", expertHistKey->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", expertHistKey->GetName())) ;
TH1 * hExpertdata = static_cast<TH1*>(expertOdata) ;
listTaskQAD->Add(hExpertdata) ;
}
}
}
}
- AliInfo(Form("Adding %s", histKey->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
if ( odata->IsA()->InheritsFrom("TH1") ) {
- AliInfo(Form("Adding %s", histKey->GetName())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
TH1 * hdata = static_cast<TH1*>(odata) ;
listTaskQAD->Add(hdata) ;
}
const UInt_t AliQAv1::fgkExpertBit = 16 ;
const UInt_t AliQAv1::fgkQABit = 17 ;
const UInt_t AliQAv1::fgkImageBit = 18 ;
-
+const Int_t AliQAv1::fgkQADebugLevel = 99 ;
//____________________________________________________________________________
AliQAv1::AliQAv1() :
TNamed("", ""),
static const char * GetQADataFileName(const char * name, Int_t run)
{return Form("%s.%s.%d.root", name, fgQADataFileName.Data(), run) ; }
static const char * GetQADataFileName() { return fgQADataFileName.Data() ; }
+ static Int_t GetQADebugLevel() { return fgkQADebugLevel ; }
static const char * GetQAName() { return fgkQAName ; }
static const char * GetQACorrName() { return fgkQACorrNtName ; }
static TFile * GetQAResultFile() ;
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 ; }
+ static void SetQADebug() { AliLog::SetGlobalDebugLevel(GetQADebugLevel()); }
static void SetQAResultDirName(const char * name) ;
static void SetQARefStorage(const char * name) ;
static void SetQARefDataDirName(AliRecoParam::EventSpecie_t es) { fgRefDataDirName = AliRecoParam::GetEventSpecieName(es) ; }
void ShowASCIIStatus(AliRecoParam::EventSpecie_t es, DETECTORINDEX_t det, ALITASK_t tsk, ULong_t status) const ;
void ResetStatus(DETECTORINDEX_t det) ;
void Set(DETECTORINDEX_t det) { fDet = det ;}
- void Set(ALITASK_t tsk) { fTask = tsk ; AliDebug(1, Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
+ void Set(ALITASK_t tsk) { fTask = tsk ; AliDebug(GetQADebugLevel(), Form("Ready to set QA status in %s", GetAliTaskName(tsk) )) ; }
void SetStatus(DETECTORINDEX_t det, AliRecoParam::EventSpecie_t es, ULong_t status) { fQA[det*fNEventSpecies+(Int_t)TMath::Log2(es)] = status ; }
void SetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
void UnSetStatusBit(DETECTORINDEX_t det, ALITASK_t tsk, AliRecoParam::EventSpecie_t es, QABIT_t bit) ;
- static AliQAv1 * fgQA ; // pointer to the instance of the singleton
+ static AliQAv1 * fgQA ; // pointer to the instance of the singleton
Int_t fNdet ; // number of detectors
Int_t fNEventSpecies ; // number of Event Species (see AliRecoParam)
Int_t fLengthQA ; // Auxiliary length of fQA
static const TString fgkLabAliEnOCDB ; //! label to identify a file as AliEn OCDB
static const TString fgkRefFileName ; //! name of Reference File Name
static const UInt_t fgkQABit ; //! bit in the QA data object which is set when Checker does not return 0
+ static const Int_t fgkQADebugLevel ; //! debug level used for QA verbosity
static const TString fgkQAName ; //! name of QA object
static const TString fgkQACorrNtName ; //! name of QA Correlation Ntuple
static const TString fgkRefOCDBDirName ; //! name of Reference directory name in OCDB
static const TString fgkQARefOCDBDefault ; //! default storage for QA in OCDB
Bool_t * fEventSpecies ; //[fNEventSpecies] list of event species encountered in a run
- ClassDef(AliQAv1,2) //ALICE Quality Assurance Object
+ ClassDef(AliQAv1,3) //ALICE Quality Assurance Object
};
#endif
TIter next(list[specie]) ;
TH1 * hdata ;
TH2 * h ;
- // AliInfo(Form(" data type %i %s nentries %i\n",
+ // AliDebug(AliQAv1::GetQADebugLevel(), Form(" data type %i %s nentries %i\n",
// index,dataType.Data(),list->GetEntries()));
for (Int_t ir=0; ir<list[specie]->GetEntries(); ir++) {
//raw
if(hdata) {
cname = hdata->GetName();
hname[ir] = cname;
- AliDebug(10,Form("count %i %s \n",ir, hname[ir].Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("count %i %s \n",ir, hname[ir].Data())) ;
fhRaw[ir] = hdata;
}
}*/
if(ir > 204) {
// else{
h = (TH2*) list[specie]->UncheckedAt(ir);
- AliInfo(Form(" index %i ir %i \n", index,ir));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" index %i ir %i \n", index,ir));
if(h) {
cname = h->GetName();
hname[ir] = cname;
- AliDebug(1,Form("count %i %s \n",ir, hname[ir].Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("count %i %s \n",ir, hname[ir].Data())) ;
fhRawEff[ir] = h;
}
}
if(h) {
cname = h->GetName();
hname[ir] = cname;
- AliDebug(1,Form("count %i %s \n",ir, hname[ir].Data())) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("count %i %s \n",ir, hname[ir].Data())) ;
fhRecDiff[ir] = h;
}
}
//esd
if(index==3){
- cout<<" ir "<<ir<<endl;
+ // cout<<" ir "<<ir<<endl;
hdata = (TH1*) list[specie]->UncheckedAt(ir);
if(hdata){
fhESD[ir] = hdata;
- AliDebug(1,Form("count %i %s ",ir, hname[ir].Data()) );
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("count %i %s ",ir, hname[ir].Data()) );
}
}
}
Double_t rms= fhRawEff[icase]->ProjectionY(Form("%s_py%i_%i",
fhRawEff[icase]->GetName(), idet,icase),
idet,idet+1)->GetRMS();
- AliInfo(Form("name %s icase %i idet %i mean %f, rms %f\n",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("name %s icase %i idet %i mean %f, rms %f\n",
fhRawEff[icase]->GetName(), icase, idet, mean,rms));
if (mean<1.2 && mean> 0.8 ) {
test[specie] = 1;
- AliDebug(1,Form("All channels works meane efficieny %f with rms %f test %f", mean, rms, test[specie])) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("All channels works meane efficieny %f with rms %f test %f", mean, rms, test[specie])) ;
}
if (mean<=0.8 && mean>= 0.5 ){
test[specie] = 0.5;
- AliDebug(1,Form("%s problem in channel %i efficieny %f test %f",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s problem in channel %i efficieny %f test %f",
fhRawEff[icase]->GetName(), idet, mean, test[specie])) ;
}
if (mean<0.5 ) {
test[specie] = 0.25;
- AliDebug(1,Form("%s big problem in channel %i efficieny %f test %f",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s big problem in channel %i efficieny %f test %f",
fhRawEff[icase]->GetName(), idet, mean, test[specie])) ;
}
}
Double_t rms= fhRecDiff[icase]->
ProjectionY(Form("%s_py", fhRecDiff[icase]->GetName()),
idet,idet+1)->GetRMS();
- AliInfo(Form("name %s icase %i idet %i mean %f, rms %f\n",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("name %s icase %i idet %i mean %f, rms %f\n",
fhRecDiff[icase]->GetName(), icase, idet, mean,rms));
if(TMath::Abs(mean) >1.5 || rms >1){
- AliDebug(1,Form(" calibration is nor perfect; test=%f", test)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" calibration is nor perfect; test=%f", test)) ;
test[specie]=0.25;
}
if(mean>3 || rms >5) {
test[specie] = 0.1;
- AliDebug(1,Form(" wrong calibration test=%f", test[specie])) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" wrong calibration test=%f", test[specie])) ;
}
}
}
Double_t rmsVertex = fhESD[icase]->GetRMS();
Double_t meanVertex = fhESD[icase]->GetMean();
test[specie]=1;
- AliInfo(Form("numentries %d meanVertex %f rmsVertex %f", fhESD[icase]->GetEntries(), meanVertex, rmsVertex));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("numentries %d meanVertex %f rmsVertex %f", fhESD[icase]->GetEntries(), meanVertex, rmsVertex));
if (TMath::Abs(rmsVertex)>3) {
test[specie]=0.25;
- AliDebug(1,Form("Vertex position resolution not good , rms= %f test=%f",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Vertex position resolution not good , rms= %f test=%f",
rmsVertex, test[specie])) ;
}
if (TMath::Abs(meanVertex)>3) {
test[specie]=0.25;
- AliDebug(1,Form("Vertex position bad calibrated , Mean= %f test=%f",
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Vertex position bad calibrated , Mean= %f test=%f",
meanVertex, test[specie])) ;
}
}
}
} // if (list->GetEntries() != 0
- AliInfo(Form("Test Result = %f", test[specie])) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test[specie])) ;
}
return test ;
}
AliT0RawReader *start = new AliT0RawReader(rawReader);
// start->Next();
if (! start->Next())
- AliDebug(1,Form(" no raw data found!!"));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form(" no raw data found!!"));
else
{
fnEvent++;
if (hdata) {
Double_t rv = 0.;
if(hdata->GetEntries()>0)rv=1;
- AliInfo(Form("%s -> %f", hdata->GetName(), rv)) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv)) ;
count[specie]++ ;
test[specie] += rv ;
}
else {
test[specie] /= count[specie] ;
}
- AliInfo(Form("Test Result = %f", test[specie])) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Test Result = %f", test[specie])) ;
}
}
}
//TStopwatch watch;
//watch.Start();
- //AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task))
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("EndOfCycle", "Fitting RecPoints %d", task))
TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
if (task == AliQAv1::kRECPOINTS) {
//TH1D *test = ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, 0, 35);
//if (test->GetSum() < 100) continue;
- //AliInfo(Form("fitting det = %d", i));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("fitting det = %d", i));
for(Int_t j=0; j<35; j++) {
//TStopwatch watch;
//watch.Start();
- AliInfo("End of TRD cycle");
+ AliDebug(AliQAv1::GetQADebugLevel(), "End of TRD cycle");
if (task == AliQAv1::kRECPOINTS) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
}
// Rec points full chambers
for (Int_t i = 0 ; i < 540 ; i++) {
- //AliInfo(Form("I = %d", i));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("I = %d", i));
//TH1D *h = ((TH2D*)list[specie]->At(1))->ProjectionY(Form("qaTRD_recPoints_amp_%d",i), i+1, i+1);
hist->Reset();
for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
Double_t value = ((TH2D*)list[specie]->At(1))->GetBinContent(bin);
hist->SetBinContent(b, value);
}
- //AliInfo(Form("Sum = %d %f\n", i, hist->GetSum()));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("Sum = %d %f\n", i, hist->GetSum()));
if (hist->GetSum() < 100)
continue; // chamber not present
Double_t value = ((TH3D*)list[specie]->At(10))->GetBinContent(bin);
svalue += value;
}
- //AliInfo(Form("v = %f\n", value));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("v = %f\n", value));
hist->SetBinContent(b, svalue);
}
if (hist->GetSum() < 100)
continue;
- //AliInfo(Form("fitting %d %d %f\n", i, j, hist->GetSum()));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("fitting %d %d %f\n", i, j, hist->GetSum()));
hist->Fit("landau", "q0", "goff", 10, 180);
TF1 *fit = hist->GetFunction("landau");
TH1D *h1 = (TH1D*)list[specie]->At(14+18+i);
Int_t bin = h1->FindBin(j);
- // AliInfo(Form("%d %d %d\n", det, j, bin));
+ // AliDebug(AliQAv1::GetQADebugLevel(), Form("%d %d %d\n", det, j, bin));
h1->SetBinContent(bin, TMath::Abs(fit->GetParameter(1)));
}
}
//TH1D *test = ((TH3D*)list[specie]->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, 0, 35);
//if (test->GetSum() < 100) continue;
- //AliInfo(Form("fitting det = %d", i));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("fitting det = %d", i));
for(Int_t j = 0 ; j < 35 ; j++) {
//TH1D *h = ((TH3D*)list[specie]->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, j+1, j+1);
Double_t xvalue = hist->GetBinCenter(b);
Int_t bin = ((TH3D*)list[specie]->At(10))->FindBin(i,j,xvalue);
Double_t value = ((TH3D*)list[specie]->At(10))->GetBinContent(bin);
- //AliInfo(Form("v = %f\n", value));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("v = %f\n", value));
hist->SetBinContent(b, value);
}
if (hist->GetSum() < 100) continue;
- //AliInfo(Form("fitting %d %d %f\n", i, j, hist->GetSum()));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("fitting %d %d %f\n", i, j, hist->GetSum()));
hist->Fit("landau", "q0", "goff", 10, 180);
TF1 *fit = hist->GetFunction("landau");
Int_t det = i%30;
TH2D *h2 = (TH2D*)list[specie]->At(14+sm);
Int_t bin = h2->FindBin(det,j);
- // AliInfo(Form("%d %d %d\n", det, j, bin));
+ // AliDebug(AliQAv1::GetQADebugLevel(), Form("%d %d %d\n", det, j, bin));
h2->SetBinContent(bin, TMath::Abs(fit->GetParameter(1)));
h2->SetBinError(bin,fit->GetParError(1));
}
// Detector specific actions at end of cycle
//
- //AliInfo(Form("EndOfCycle", "Fitting RecPoints %d", task));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("EndOfCycle", "Fitting RecPoints %d", task));
// call the checker
AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;
// Main check function: Depending on the TASK, different checks will be applied
// Check for empty histograms
-// AliDebug(1,Form("AliVZEROChecker"));
+// AliDebug(AliQAv1::GetQADebugLevel(),Form("AliVZEROChecker"));
// AliCDBEntry *QARefRec = AliCDBManager::Instance()->Get("VZERO/QARef/RAW");
// if( !QARefRec){
-// AliInfo("QA reference data NOT retrieved for QA check...");
+// AliDebug(AliQAv1::GetQADebugLevel(), "QA reference data NOT retrieved for QA check...");
// return 1.;
// }
if (list->GetEntries() == 0){
test = 1.0;
- AliInfo(Form("There are NO ENTRIES to be checked..."));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("There are NO ENTRIES to be checked..."));
} else {
TIter next(list) ;
TH1 * hdata ;
if (hdata) {
Double_t rv = 0.0;
if(hdata->GetEntries()>0) rv=1.0;
-// AliInfo(Form("%s -> %f", hdata->GetName(), rv));
+// AliDebug(AliQAv1::GetQADebugLevel(), Form("%s -> %f", hdata->GetName(), rv));
count++ ; // number of histos
test += rv ; // number of histos filled
}else{
{
// Constructor
- AliInfo("Construct VZERO QA Object");
+ AliDebug(AliQAv1::GetQADebugLevel(), "Construct VZERO QA Object");
for(Int_t i=0; i<64; i++){
fEven[i] = 0;
h2d = new TH2D(name, title,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++;
- AliInfo(Form("%d Histograms has been added to the Raws List",iHisto));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto));
}
//____________________________________________________________________________
AliWarning("\tAliZDCQAChecker->The list to be checked is empty!"); // nothing to check
return test;
}
- //AliInfo(Form("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName));
TIter next(list[specie]);
ntests[specie] = 0;
TH1 * hdata;
if(hdata){
// -------------------------------------------------------------------
if(index == AliQAv1::kSIM){
- //AliInfo(Form("\tAliZDCQAChecker-> checking histo %s",hdata->GetName()));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\tAliZDCQAChecker-> checking histo %s",hdata->GetName()));
// Check DIGITS histos
if(!(strncmp(hdata->GetName(),"hDig",4))){
if(hdata->GetEntries()>0){
AliWarning("\tAliZDCQAChecker->The list to be checked is empty!");
return test;
}
- //AliInfo(Form("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\n\tAliZDCQAChecker-> checking QA histograms for task %s\n\n",taskName));
TIter next(list[specie]);
TH1 * hdata;
while((hdata = dynamic_cast<TH1 *>(next()))){
if(hdata){
- //AliInfo(Form("\tAliZDCQAChecker-> checking histo %s",hdata->GetName()));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\tAliZDCQAChecker-> checking histo %s",hdata->GetName()));
ntests[specie] = 0;
Double_t meanX=0., meanY=0.;
Double_t meanZNA=0., rmsZNA=0., meanZNC=0.;
testgood=0;
test[specie] += res;
ntests[specie]++;
- //AliInfo(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
}
else res=0.;
}
test[specie] += res;
ntests[specie]++;
testgood=0;
- //AliInfo(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]);
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]);
}
else res=0.;
}
res=0.5;
test[specie] += res;
ntests[specie]++;
- //AliInfo(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
}
else if(digInd==9){
pmCZNA = hdata->GetMean();
res=0.5;
test[specie] += res;
ntests[specie]++;
- //AliInfo(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
}
else if(digInd==10){
pmCZPC = hdata->GetMean();
res=0.5;
test[specie] += res;
ntests[specie]++;
- //AliInfor(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]);
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]);
}
else if(digInd==11){
pmCZPA = hdata->GetMean();
res=0.5;
test[specie] += res;
ntests[specie]++;
- //AliInfor(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
}
}
digInd++;
res=0.5;
test[specie] += res;
ntests[specie]++;
- //AliInfo(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]);
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]);
}
}
// -------------------------------------------------------------------
}
esdInd++;
}
- //AliInfor(Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("\t %d performed tests, results %1.2f\n",ntests[specie],test[specie]/ntests[specie]));
}
else {
AliWarning(Form("\n\t No ZDC QA for %s task\n",taskName));
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if(ntests[specie]!=0) test[specie] = test[specie]/ntests[specie];
- printf("\n\tAliZDCQAChecker-> QA check result = %1.2f\n",test[specie]);
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("\n\tAliZDCQAChecker-> QA check result = %1.2f\n",test[specie]));
}
delete [] ntests ;
return test;
-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